enterprise-user-management-system-ai

Enterprise User Management System AI Skill

Skill by ara.so — Data Skills collection.

This skill enables AI coding agents to work with the Enterprise User Management System, a full-stack application that combines user/task management with AI-powered analytics for risk detection, anomaly detection, burnout analysis, and predictive insights.

What This Project Does

The Enterprise User Management System provides:

• User Management: Role-based authentication (Admin/User) with JWT tokens
• Task Management: Kanban board (To Do → In Progress → Done) with time tracking
• Support Tickets: AI-powered classification and routing
• AI Analytics: Risk prediction, anomaly detection, burnout analysis, project delay prediction
• Dashboards: Separate admin and user dashboards with real-time insights

Tech Stack: React.js frontend, Node.js backend, FastAPI ML service, MongoDB database

Installation & Setup

Prerequisites

# Ensure you have installed:
# - Node.js (v14+)
# - Python (v3.8+)
# - MongoDB (running locally or cloud)

Clone and Setup

git clone https://github.com/Nareshkumar2583/Enterprise-User-Management-System-with-AI-Analytics.git
cd Enterprise-User-Management-System-with-AI-Analytics

Backend Setup (Node.js)

cd backend
npm install

# Create .env file
cat > .env << EOF
PORT=5000
MONGODB_URI=mongodb://localhost:27017/user_management
JWT_SECRET=your_jwt_secret_key_here
JWT_EXPIRE=7d
ML_SERVICE_URL=http://localhost:8000
EOF

# Start backend
npm start

ML Service Setup (FastAPI)

cd ml-service
pip install -r requirements.txt

# Create .env file
cat > .env << EOF
BACKEND_URL=http://localhost:5000
MODEL_PATH=./models
EOF

# Start ML service
uvicorn main:app --reload --port 8000

Frontend Setup (React)

cd frontend
npm install

# Create .env file
cat > .env << EOF
REACT_APP_API_URL=http://localhost:5000
REACT_APP_ML_URL=http://localhost:8000
EOF

# Start frontend
npm start

Key API Endpoints

Authentication APIs

// POST /api/auth/register - Register new user
{
  "username": "john_doe",
  "email": "john@example.com",
  "password": "SecurePass123",
  "role": "user" // or "admin"
}

// POST /api/auth/login - Login
{
  "email": "john@example.com",
  "password": "SecurePass123"
}

// Response includes JWT token
{
  "token": "eyJhbGciOiJIUzI1NiIs...",
  "user": {
    "id": "user_id",
    "username": "john_doe",
    "role": "user"
  }
}

User Management APIs (Admin)

// GET /api/users - Get all users (Admin only)
// PUT /api/users/:id - Update user
// DELETE /api/users/:id - Delete user

// Example: Update user role
fetch('http://localhost:5000/api/users/user_id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${token}`
  },
  body: JSON.stringify({
    role: 'admin',
    status: 'active'
  })
});

Task Management APIs

// GET /api/tasks - Get user tasks
// POST /api/tasks - Create task
// PUT /api/tasks/:id - Update task status
// DELETE /api/tasks/:id - Delete task

// Create new task
const createTask = async (taskData, token) => {
  const response = await fetch('http://localhost:5000/api/tasks', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      title: 'Implement login feature',
      description: 'Add JWT authentication',
      status: 'todo', // todo, in_progress, done
      priority: 'high',
      assignedTo: 'user_id',
      dueDate: '2026-05-01'
    })
  });
  return response.json();
};

Support Ticket APIs

// POST /api/tickets - Create support ticket
// GET /api/tickets - Get tickets
// PUT /api/tickets/:id - Update ticket

// Create ticket with AI classification
const createTicket = async (ticketData, token) => {
  const response = await fetch('http://localhost:5000/api/tickets', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      title: 'Cannot access dashboard',
      description: 'Getting 403 error when accessing admin panel',
      category: 'technical', // AI can auto-classify
      priority: 'medium'
    })
  });
  return response.json();
};

AI Analytics APIs

// POST /api/ai/risk-analysis - Analyze user risk
// POST /api/ai/anomaly-detection - Detect anomalies
// POST /api/ai/burnout-prediction - Predict burnout
// POST /api/ai/project-insights - Get project predictions

// Risk analysis example
const analyzeRisk = async (userId, token) => {
  const response = await fetch('http://localhost:5000/api/ai/risk-analysis', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      userId: userId,
      metrics: {
        loginFrequency: 15,
        taskCompletionRate: 0.85,
        ticketCount: 3,
        lastActive: '2026-04-15T10:30:00Z'
      }
    })
  });
  return response.json();
};

Common Code Patterns

Frontend: Authentication Context

// src/context/AuthContext.js
import React, { createContext, useState, useEffect } from 'react';
import axios from 'axios';

export const AuthContext = createContext();

export const AuthProvider = ({ children }) => {
  const [user, setUser] = useState(null);
  const [token, setToken] = useState(localStorage.getItem('token'));

  useEffect(() => {
    if (token) {
      axios.defaults.headers.common['Authorization'] = `Bearer ${token}`;
      fetchUser();
    }
  }, [token]);

  const fetchUser = async () => {
    try {
      const res = await axios.get(`${process.env.REACT_APP_API_URL}/api/auth/me`);
      setUser(res.data);
    } catch (err) {
      logout();
    }
  };

  const login = async (email, password) => {
    const res = await axios.post(`${process.env.REACT_APP_API_URL}/api/auth/login`, {
      email,
      password
    });
    setToken(res.data.token);
    setUser(res.data.user);
    localStorage.setItem('token', res.data.token);
  };

  const logout = () => {
    setToken(null);
    setUser(null);
    localStorage.removeItem('token');
    delete axios.defaults.headers.common['Authorization'];
  };

  return (
    <AuthContext.Provider value={{ user, token, login, logout }}>
      {children}
    </AuthContext.Provider>
  );
};

Frontend: Kanban Board Component

// src/components/KanbanBoard.jsx
import React, { useState, useEffect } from 'react';
import axios from 'axios';
import './KanbanBoard.css';

const KanbanBoard = () => {
  const [tasks, setTasks] = useState({ todo: [], in_progress: [], done: [] });

  useEffect(() => {
    fetchTasks();
  }, []);

  const fetchTasks = async () => {
    try {
      const res = await axios.get(`${process.env.REACT_APP_API_URL}/api/tasks`);
      const grouped = res.data.reduce((acc, task) => {
        acc[task.status] = acc[task.status] || [];
        acc[task.status].push(task);
        return acc;
      }, { todo: [], in_progress: [], done: [] });
      setTasks(grouped);
    } catch (err) {
      console.error('Error fetching tasks:', err);
    }
  };

  const updateTaskStatus = async (taskId, newStatus) => {
    try {
      await axios.put(`${process.env.REACT_APP_API_URL}/api/tasks/${taskId}`, {
        status: newStatus
      });
      fetchTasks();
    } catch (err) {
      console.error('Error updating task:', err);
    }
  };

  const renderColumn = (status, title) => (
    <div className="kanban-column">
      <h3>{title}</h3>
      {tasks[status].map(task => (
        <div key={task._id} className="kanban-card">
          <h4>{task.title}</h4>
          <p>{task.description}</p>
          <div className="task-actions">
            {status !== 'todo' && (
              <button onClick={() => updateTaskStatus(task._id, 'todo')}>← To Do</button>
            )}
            {status !== 'in_progress' && (
              <button onClick={() => updateTaskStatus(task._id, 'in_progress')}>
                {status === 'todo' ? '→' : '←'} In Progress
              </button>
            )}
            {status !== 'done' && (
              <button onClick={() => updateTaskStatus(task._id, 'done')}>Done →</button>
            )}
          </div>
        </div>
      ))}
    </div>
  );

  return (
    <div className="kanban-board">
      {renderColumn('todo', 'To Do')}
      {renderColumn('in_progress', 'In Progress')}
      {renderColumn('done', 'Done')}
    </div>
  );
};

export default KanbanBoard;

Backend: JWT Authentication Middleware

// backend/middleware/auth.js
const jwt = require('jsonwebtoken');
const User = require('../models/User');

const authMiddleware = async (req, res, next) => {
  try {
    const token = req.header('Authorization')?.replace('Bearer ', '');
    
    if (!token) {
      return res.status(401).json({ error: 'Authentication required' });
    }

    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    const user = await User.findById(decoded.userId);

    if (!user) {
      return res.status(401).json({ error: 'User not found' });
    }

    req.user = user;
    req.token = token;
    next();
  } catch (err) {
    res.status(401).json({ error: 'Invalid token' });
  }
};

const adminMiddleware = (req, res, next) => {
  if (req.user.role !== 'admin') {
    return res.status(403).json({ error: 'Admin access required' });
  }
  next();
};

module.exports = { authMiddleware, adminMiddleware };

Backend: User Management Routes

// backend/routes/users.js
const express = require('express');
const router = express.Router();
const User = require('../models/User');
const { authMiddleware, adminMiddleware } = require('../middleware/auth');

// Get all users (Admin only)
router.get('/', authMiddleware, adminMiddleware, async (req, res) => {
  try {
    const users = await User.find().select('-password');
    res.json(users);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Update user
router.put('/:id', authMiddleware, adminMiddleware, async (req, res) => {
  try {
    const { role, status } = req.body;
    const user = await User.findByIdAndUpdate(
      req.params.id,
      { role, status },
      { new: true }
    ).select('-password');
    
    res.json(user);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Delete user
router.delete('/:id', authMiddleware, adminMiddleware, async (req, res) => {
  try {
    await User.findByIdAndDelete(req.params.id);
    res.json({ message: 'User deleted successfully' });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

module.exports = router;

Backend: Task Management Routes

// backend/routes/tasks.js
const express = require('express');
const router = express.Router();
const Task = require('../models/Task');
const { authMiddleware } = require('../middleware/auth');

// Get user tasks
router.get('/', authMiddleware, async (req, res) => {
  try {
    const tasks = await Task.find({ 
      $or: [
        { assignedTo: req.user._id },
        { createdBy: req.user._id }
      ]
    }).populate('assignedTo', 'username email');
    
    res.json(tasks);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Create task
router.post('/', authMiddleware, async (req, res) => {
  try {
    const task = new Task({
      ...req.body,
      createdBy: req.user._id
    });
    await task.save();
    res.status(201).json(task);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Update task
router.put('/:id', authMiddleware, async (req, res) => {
  try {
    const task = await Task.findByIdAndUpdate(
      req.params.id,
      req.body,
      { new: true }
    );
    res.json(task);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

module.exports = router;

ML Service: Risk Analysis

# ml-service/main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from sklearn.ensemble import RandomForestClassifier
import numpy as np
import pickle
import os

app = FastAPI()

class RiskAnalysisRequest(BaseModel):
    userId: str
    metrics: dict

class RiskAnalysisResponse(BaseModel):
    riskLevel: str
    riskScore: float
    factors: list

# Load or initialize model
model_path = os.getenv('MODEL_PATH', './models')
try:
    with open(f'{model_path}/risk_model.pkl', 'rb') as f:
        risk_model = pickle.load(f)
except:
    # Initialize with dummy model if not exists
    risk_model = RandomForestClassifier(n_estimators=100)

@app.post("/api/ai/risk-analysis", response_model=RiskAnalysisResponse)
async def analyze_risk(request: RiskAnalysisRequest):
    try:
        metrics = request.metrics
        
        # Extract features
        features = np.array([[
            metrics.get('loginFrequency', 0),
            metrics.get('taskCompletionRate', 0),
            metrics.get('ticketCount', 0),
            metrics.get('missedDeadlines', 0),
            metrics.get('workHours', 0)
        ]])
        
        # Calculate risk score (0-1)
        risk_score = calculate_risk_score(features)
        
        # Determine risk level
        if risk_score < 0.3:
            risk_level = "low"
        elif risk_score < 0.7:
            risk_level = "medium"
        else:
            risk_level = "high"
        
        # Identify risk factors
        factors = []
        if metrics.get('taskCompletionRate', 1) < 0.5:
            factors.append("Low task completion rate")
        if metrics.get('ticketCount', 0) > 10:
            factors.append("High number of support tickets")
        if metrics.get('missedDeadlines', 0) > 3:
            factors.append("Multiple missed deadlines")
        
        return RiskAnalysisResponse(
            riskLevel=risk_level,
            riskScore=float(risk_score),
            factors=factors
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

def calculate_risk_score(features):
    # Weighted scoring algorithm
    weights = np.array([0.2, 0.3, 0.2, 0.2, 0.1])
    normalized = features[0] / np.array([30, 1, 20, 10, 80])
    score = np.dot(weights, normalized)
    return min(max(score, 0), 1)

ML Service: Anomaly Detection

# ml-service/anomaly_detection.py
from fastapi import HTTPException
from pydantic import BaseModel
from river import anomaly
from river import compose
from river import preprocessing
import json
import os

class AnomalyRequest(BaseModel):
    userId: str
    activity: dict

class AnomalyResponse(BaseModel):
    isAnomaly: bool
    anomalyScore: float
    reason: str

# Initialize online learning model
anomaly_detector = compose.Pipeline(
    preprocessing.StandardScaler(),
    anomaly.HalfSpaceTrees(n_trees=10, height=8, window_size=250)
)

@app.post("/api/ai/anomaly-detection", response_model=AnomalyResponse)
async def detect_anomaly(request: AnomalyRequest):
    try:
        activity = request.activity
        
        # Convert activity to feature vector
        features = {
            'login_time_hour': activity.get('loginTime', 12),
            'actions_per_minute': activity.get('actionsPerMinute', 5),
            'failed_attempts': activity.get('failedAttempts', 0),
            'unusual_ip': int(activity.get('unusualIP', False)),
            'off_hours_access': int(activity.get('offHoursAccess', False))
        }
        
        # Get anomaly score
        score = anomaly_detector.score_one(features)
        
        # Update model with new data
        anomaly_detector.learn_one(features)
        
        # Determine if anomaly (threshold: 0.5)
        is_anomaly = score > 0.5
        
        # Determine reason
        reason = ""
        if is_anomaly:
            if features['failed_attempts'] > 3:
                reason = "Multiple failed login attempts detected"
            elif features['off_hours_access']:
                reason = "Access during unusual hours"
            elif features['unusual_ip']:
                reason = "Login from unusual location"
            else:
                reason = "Unusual activity pattern detected"
        else:
            reason = "Normal activity"
        
        return AnomalyResponse(
            isAnomaly=is_anomaly,
            anomalyScore=float(score),
            reason=reason
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

ML Service: Burnout Prediction

# ml-service/burnout_prediction.py
from pydantic import BaseModel

class BurnoutRequest(BaseModel):
    userId: str
    workload: dict

class BurnoutResponse(BaseModel):
    burnoutRisk: str
    burnoutScore: float
    recommendations: list

@app.post("/api/ai/burnout-prediction", response_model=BurnoutResponse)
async def predict_burnout(request: BurnoutRequest):
    try:
        workload = request.workload
        
        # Calculate burnout score
        score = 0.0
        
        # Weekly work hours (weight: 0.3)
        weekly_hours = workload.get('weeklyHours', 40)
        if weekly_hours > 60:
            score += 0.3
        elif weekly_hours > 50:
            score += 0.15
        
        # Task overload (weight: 0.25)
        active_tasks = workload.get('activeTasks', 5)
        if active_tasks > 15:
            score += 0.25
        elif active_tasks > 10:
            score += 0.15
        
        # Deadline pressure (weight: 0.25)
        urgent_tasks = workload.get('urgentTasks', 0)
        if urgent_tasks > 5:
            score += 0.25
        elif urgent_tasks > 3:
            score += 0.15
        
        # Work-life balance (weight: 0.2)
        days_off = workload.get('daysOffLastMonth', 4)
        if days_off < 2:
            score += 0.2
        elif days_off < 4:
            score += 0.1
        
        # Determine risk level
        if score < 0.3:
            risk = "low"
        elif score < 0.6:
            risk = "medium"
        else:
            risk = "high"
        
        # Generate recommendations
        recommendations = []
        if weekly_hours > 50:
            recommendations.append("Reduce weekly work hours to below 50")
        if active_tasks > 10:
            recommendations.append("Delegate or postpone some tasks")
        if urgent_tasks > 3:
            recommendations.append("Reprioritize urgent tasks")
        if days_off < 4:
            recommendations.append("Take regular time off for recovery")
        
        return BurnoutResponse(
            burnoutRisk=risk,
            burnoutScore=score,
            recommendations=recommendations
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

MongoDB Schema Examples

User Model

// backend/models/User.js
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const userSchema = new mongoose.Schema({
  username: {
    type: String,
    required: true,
    unique: true,
    trim: true
  },
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true
  },
  password: {
    type: String,
    required: true,
    minlength: 6
  },
  role: {
    type: String,
    enum: ['user', 'admin'],
    default: 'user'
  },
  status: {
    type: String,
    enum: ['active', 'inactive', 'suspended'],
    default: 'active'
  },
  profile: {
    firstName: String,
    lastName: String,
    department: String,
    position: String
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});

// Hash password before saving
userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  this.password = await bcrypt.hash(this.password, 10);
  next();
});

// Compare password method
userSchema.methods.comparePassword = async function(candidatePassword) {
  return bcrypt.compare(candidatePassword, this.password);
};

module.exports = mongoose.model('User', userSchema);

Task Model

// backend/models/Task.js
const mongoose = require('mongoose');

const taskSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true
  },
  description: {
    type: String,
    required: true
  },
  status: {
    type: String,
    enum: ['todo', 'in_progress', 'done'],
    default: 'todo'
  },
  priority: {
    type: String,
    enum: ['low', 'medium', 'high', 'urgent'],
    default: 'medium'
  },
  assignedTo: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  createdBy: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  dueDate: {
    type: Date
  },
  timeTracking: {
    totalTime: { type: Number, default: 0 }, // in seconds
    sessions: [{
      startTime: Date,
      endTime: Date,
      duration: Number
    }]
  },
  createdAt: {
    type: Date,
    default: Date.now
  },
  updatedAt: {
    type: Date,
    default: Date.now
  }
});

taskSchema.pre('save', function(next) {
  this.updatedAt = Date.now();
  next();
});

module.exports = mongoose.model('Task', taskSchema);

Ticket Model

// backend/models/Ticket.js
const mongoose = require('mongoose');

const ticketSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true
  },
  description: {
    type: String,
    required: true
  },
  category: {
    type: String,
    enum: ['technical', 'billing', 'general', 'feature_request'],
    default: 'general'
  },
  priority: {
    type: String,
    enum: ['low', 'medium', 'high', 'critical'],
    default: 'medium'
  },
  status: {
    type: String,
    enum: ['open', 'in_progress', 'resolved', 'closed'],
    default: 'open'
  },
  createdBy: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  assignedTo: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'
  },
  aiClassification: {
    confidence: Number,
    suggestedCategory: String,
    suggestedPriority: String
  },
  comments: [{
    user: {
      type: mongoose.Schema.Types.ObjectId,
      ref: 'User'
    },
    text: String,
    createdAt: {
      type: Date,
      default: Date.now
    }
  }],
  createdAt: {
    type: Date,
    default: Date.now
  },
  updatedAt: {
    type: Date,
    default: Date.now
  }
});

module.exports = mongoose.model('Ticket', ticketSchema);

Configuration

Environment Variables

Backend (.env):

PORT=5000
MONGODB_URI=mongodb://localhost:27017/user_management
JWT_SECRET=your_jwt_secret_key
JWT_EXPIRE=7d
ML_SERVICE_URL=http://localhost:8000
CORS_ORIGIN=http://localhost:3000

ML Service (.env):

BACKEND_URL=http://localhost:5000
MODEL_PATH=./models
LOG_LEVEL=INFO

Frontend (.env):

REACT_APP_API_URL=http://localhost:5000
REACT_APP_ML_URL=http://localhost:8000

Troubleshooting

JWT Token Issues

// Check if token is expired
const jwt = require('jsonwebtoken');

try {
  const decoded = jwt.verify(token, process.env.JWT_SECRET);
  console.log('Token valid:', decoded);
} catch (err) {
  if (err.name === 'TokenExpiredError') {
    console.log('Token expired, please login again');
  } else {
    console.log('Invalid token');
  }
}

MongoDB Connection Issues

// backend/config/database.js
const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true
    });
    console.log('MongoDB connected successfully');
  } catch (err) {
    console.error('MongoDB connection error:', err);
    process.exit(1);
  }
};

module.exports = connectDB;

CORS Issues

// backend/server.js
const cors = require('cors');

app.use(cors({
  origin: process.env.CORS_ORIGIN || 'http://localhost:3000',
  credentials: true
}));

ML Service Not Responding

# Check if ML service is running
import requests

try:
    response = requests.get('http://localhost:8000/health')
    print('ML Service status:', response.status_code)
except Exception as e:
    print('ML Service error:', str(e))

Task Status Update Failures

// Ensure proper status values
const validStatuses = ['todo', 'in_progress', 'done'];

const updateTask = async (taskId, newStatus) => {
  if (!validStatuses.includes(newStatus)) {
    console.error('Invalid status:', newStatus);
    return;
  }
  
  try {
    await axios.put(`${API_URL}/api/tasks/${taskId}`, { status: newStatus });
  } catch (err) {
    console.error('Update failed:', err.response?.data || err.message);
  }
};

Frontend Build Issues

# Clear cache and rebuild
rm -rf node_modules package-lock.json
npm install
npm run build

# If port 3000 is in use
PORT=3001 npm start

This skill provides comprehensive coverage of the Enterprise User Management System with AI Analytics, enabling AI coding agents to effectively help developers integrate authentication, manage tasks, implement AI features, and troubleshoot common issues.