enterprise-user-management-system-ai

name	enterprise-user-management-system-ai
description	Full-stack user management system with AI-powered analytics for task tracking, ticket management, and predictive insights
triggers	["set up enterprise user management with AI analytics","create user management dashboard with AI features","implement task tracking with burnout detection","build support ticket system with AI classification","add AI-powered risk detection to user system","configure user management with kanban board","integrate ML analytics for project insights","deploy user management system with FastAPI ML"]

Enterprise User Management System with AI Analytics

Skill by ara.so — Data Skills collection.

A full-stack enterprise user management platform combining React frontend, Node.js backend, and FastAPI ML service. Provides role-based access control, task management with Kanban boards, support ticket system, and AI-powered analytics including risk detection, anomaly detection, burnout analysis, and predictive project insights.

What It Does

• User Management: JWT-authenticated system with role-based access (Admin/User)
• Task Tracking: Kanban board (To Do → In Progress → Done) with time tracking
• Support Tickets: AI-classified ticket routing and management
• AI Analytics: Risk prediction, anomaly detection, burnout analysis, project delay prediction
• Real-time Insights: Dashboard with performance metrics and alerts

Installation

Prerequisites

# Required
node >= 14.x
python >= 3.8
mongodb >= 4.x

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

cd backend
npm install

Create backend/.env:

PORT=5000
MONGODB_URI=mongodb://localhost:27017/enterprise-user-mgmt
JWT_SECRET=your_jwt_secret_key
ML_SERVICE_URL=http://localhost:8000
NODE_ENV=development

Start backend:

npm start
# Runs at http://localhost:5000

ML Service Setup

cd ml-service
pip install -r requirements.txt

Create ml-service/.env:

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

Start ML service:

uvicorn main:app --reload --port 8000
# Runs at http://localhost:8000

Frontend Setup

cd frontend
npm install

Create frontend/.env:

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

Start frontend:

npm start
# Runs at http://localhost:3000

Key API Endpoints

Authentication (Backend)

// POST /api/auth/register
{
  "name": "John Doe",
  "email": "[e-mail]",
  "password": "securepass123",
  "role": "user" // or "admin"
}

// POST /api/auth/login
{
  "email": "[e-mail]",
  "password": "securepass123"
}
// Returns: { token: "jwt_token", user: {...} }

User Management (Backend)

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

Task Management (Backend)

// GET /api/tasks - Get user's tasks
// POST /api/tasks - Create task
{
  "title": "Implement login feature",
  "description": "Add JWT authentication",
  "assignedTo": "user_id",
  "status": "todo", // todo, in_progress, done
  "priority": "high",
  "dueDate": "2026-05-01"
}

// PATCH /api/tasks/:id - Update task status
{
  "status": "in_progress",
  "timeSpent": 120 // minutes
}

Support Tickets (Backend)

// POST /api/tickets - Create ticket
{
  "title": "Unable to access dashboard",
  "description": "Getting 403 error",
  "priority": "high",
  "category": "technical"
}

// GET /api/tickets - Get tickets
// PATCH /api/tickets/:id - Update ticket
{
  "status": "in_progress",
  "assignedTo": "admin_id"
}

AI Analytics (ML Service)

# POST /api/ml/classify-ticket
{
  "title": "Password reset not working",
  "description": "Clicked forgot password but no email received"
}
# Returns: { "category": "technical", "priority": "medium", "confidence": 0.89 }

# POST /api/ml/detect-risk
{
  "userId": "user_id",
  "failedLogins": 5,
  "unusualActivity": true,
  "accessPatterns": ["night", "weekend"]
}
# Returns: { "riskScore": 0.76, "riskLevel": "high", "factors": [...] }

# POST /api/ml/detect-burnout
{
  "userId": "user_id",
  "tasksCompleted": 45,
  "hoursWorked": 65,
  "overtimeHours": 15,
  "missedDeadlines": 3
}
# Returns: { "burnoutScore": 0.82, "recommendation": "reduce_workload" }

# POST /api/ml/predict-delay
{
  "projectId": "proj_123",
  "tasksRemaining": 12,
  "averageCompletionTime": 4.5,
  "teamSize": 5,
  "complexityScore": 7
}
# Returns: { "delayProbability": 0.65, "estimatedDelay": 5 }

Frontend Integration Examples

Authentication Flow

// src/services/authService.js
import axios from 'axios';

const API_URL = process.env.REACT_APP_API_URL;

export const login = async (email, password) => {
  const response = await axios.post(`${API_URL}/api/auth/login`, {
    email,
    password
  });
  
  if (response.data.token) {
    localStorage.setItem('token', response.data.token);
    localStorage.setItem('user', JSON.stringify(response.data.user));
  }
  
  return response.data;
};

export const logout = () => {
  localStorage.removeItem('token');
  localStorage.removeItem('user');
};

export const getAuthHeader = () => {
  const token = localStorage.();
   token ? { :  } : {};
};

Task Management Component

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

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

  const API_URL = process.env.REACT_APP_API_URL;

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

  const fetchTasks = async () => {
    try {
      const response = await axios.get(`${API_URL}/api/tasks`, {
        headers: getAuthHeader()
      });
      
      const grouped = response.data.reduce((acc, task) => {
        acc[task.status] = acc[task.status] || [];
        acc[task.status].push(task);
        return acc;
      }, {});
      
      setTasks(grouped);
    }  (error) {
      .(, error);
    }
  };

    =  () => {
     {
       axios.(
        ,
        { : newStatus },
        { : () }
      );
      
      (); 
    }  (error) {
      .(, error);
    }
  };

   (
    
  );
};

  ;

AI-Powered Ticket Classification

// src/components/CreateTicket.jsx
import React, { useState } from 'react';
import axios from 'axios';
import { getAuthHeader } from '../services/authService';

const CreateTicket = () => {
  const [formData, setFormData] = useState({
    title: '',
    description: ''
  });
  const [aiSuggestion, setAiSuggestion] = useState(null);

  const API_URL = process.env.REACT_APP_API_URL;
  const ML_API_URL = process.env.REACT_APP_ML_API_URL;

  const classifyWithAI = async () => {
    try {
      const response = await axios.post(
        `${ML_API_URL}/api/ml/classify-ticket`,
        {
          title: formData.title,
          description: formData.description
        }
      );
      
      setAiSuggestion(response.data);
    } catch (error) {
      console.(, error);
    }
  };

    =  () => {
    e.();
    
     {
       axios.(
        ,
        {
          ...formData,
          : aiSuggestion?. || ,
          : aiSuggestion?. || 
        },
        { : () }
      );
      
      ();
      ({ : , :  });
      ();
    }  (error) {
      .(, error);
    }
  };

   (
    
  );
};

  ;

Backend Implementation Patterns

Express Route with JWT Authentication

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

const authMiddleware = (req, res, next) => {
  try {
    const token = req.headers.authorization?.split(' ')[1];
    
    if (!token) {
      return res.status(401).json({ message: 'No token provided' });
    }
    
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    return res.status(401).json({ message: 'Invalid token' });
  }
};

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

module.exports = { authMiddleware, adminOnly };

Task Controller

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

exports.getTasks = async (req, res) => {
  try {
    const tasks = await Task.find({ 
      assignedTo: req.user.id 
    }).populate('assignedTo', 'name email');
    
    res.json(tasks);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

exports.createTask = async (req, res) => {
  try {
    const task = new Task({
      ...req.body,
      createdBy: req.user.id
    });
    
    await task.save();
    res.status(201).json(task);
  } catch (error) {
    res.status(400).json({ message: error.message });
  }
};

exports.updateTask =  (req, res) => {
   {
     task =  .(
      req..,
      req.,
      { :  }
    );
    
     (!task) {
       res.().({ :  });
    }
    
    res.(task);
  }  (error) {
    res.().({ : error. });
  }
};

MongoDB Models

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

const taskSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true
  },
  description: String,
  status: {
    type: String,
    enum: ['todo', 'in_progress', 'done'],
    default: 'todo'
  },
  priority: {
    type: String,
    enum: ['low', 'medium', 'high'],
    default: 'medium'
  },
  assignedTo: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  createdBy: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'
  },
  timeSpent: {
    type: Number,
    default: 0 // minutes
  },
  : 
}, {
  : 
});

. = mongoose.(, taskSchema);

ML Service Implementation

FastAPI ML Endpoints

# ml-service/main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Dict
import joblib
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from river import anomaly, ensemble

app = FastAPI()

# Load or initialize models
try:
    ticket_classifier = joblib.load('./models/ticket_classifier.pkl')
except:
    ticket_classifier = None

risk_detector = ensemble.AdaptiveRandomForestClassifier()
anomaly_detector = anomaly.HalfSpaceTrees()

class TicketInput(BaseModel):
    title: str
    description: str

class RiskInput(BaseModel):
    userId: str
    failedLogins: int
    unusualActivity: bool
    accessPatterns: List[str]

class BurnoutInput(BaseModel):
    userId: str
    tasksCompleted: int
    hoursWorked: float
    overtimeHours: float
    missedDeadlines: int

@app.post("/api/ml/classify-ticket")
async  ():
    :
        
        text = .lower()
        
        category = 
         (word  text  word  [, , , ]):
            category = 
         (word  text  word  [, , , ]):
            category = 
         (word  text  word  [, , , ]):
            category = 
        
        priority = 
         (word  text  word  [, , , ]):
            priority = 
         (word  text  word  [, , ]):
            priority = 
        
         {
            : category,
            : priority,
            : 
        }
     Exception  e:
         HTTPException(status_code=, detail=(e))


  ():
    :
        
        risk_score = 
        factors = []
        
         data.failedLogins > :
            risk_score += 
            factors.append()
        
         data.unusualActivity:
            risk_score += 
            factors.append()
        
        unusual_patterns = [, ]
         (pattern  data.accessPatterns  pattern  unusual_patterns):
            risk_score += 
            factors.append()
        
        risk_level = 
         risk_score > :
            risk_level = 
         risk_score > :
            risk_level = 
        
         {
            : (risk_score, ),
            : risk_level,
            : factors
        }
     Exception  e:
         HTTPException(status_code=, detail=(e))


  ():
    :
        
        burnout_score = 
        
        
         data.hoursWorked > :
            burnout_score += 
        
        
         data.overtimeHours > :
            burnout_score += 
        
        
         data.missedDeadlines > :
            burnout_score += 
        
        
         data.tasksCompleted > :
            burnout_score += 
        
        recommendation = 
         burnout_score > :
            recommendation = 
         burnout_score > :
            recommendation = 
        
         {
            : (burnout_score, ),
            : recommendation,
            : [
                ,
                ,
                
            ]  burnout_score >   []
        }
     Exception  e:
         HTTPException(status_code=, detail=(e))


  ():
    :
        
        tasks_remaining = data.get(, )
        avg_time = data.get(, )
        team_size = data.get(, )
        complexity = data.get(, )
        
        estimated_days = (tasks_remaining * avg_time) / team_size
        complexity_factor = complexity / 
        
        delay_probability = (estimated_days * complexity_factor / , )
        estimated_delay = (estimated_days * complexity_factor)  delay_probability >   
        
         {
            : delay_probability,
            : estimated_delay,
            : 
        }
     Exception  e:
         HTTPException(status_code=, detail=(e))


  ():
     {: , : }

Configuration

Backend Environment Variables

# Server
PORT=5000
NODE_ENV=production

# Database
MONGODB_URI=mongodb://localhost:27017/enterprise-user-mgmt
# Or MongoDB Atlas: mongodb+srv://user:[e-mail]/dbname

# Authentication
JWT_SECRET=your_secure_jwt_secret_here
JWT_EXPIRY=24h

# ML Service
ML_SERVICE_URL=http://localhost:8000

# CORS
ALLOWED_ORIGINS=http://localhost:3000,https://yourdomain.com

Frontend Environment Variables

# API URLs
REACT_APP_API_URL=http://localhost:5000
REACT_APP_ML_API_URL=http://localhost:8000

# Production
# REACT_APP_API_URL=https://api.yourdomain.com
# REACT_APP_ML_API_URL=https://ml.yourdomain.com

ML Service Configuration

# ml-service/config.py
import os
from pathlib import Path

class Config:
    MODEL_PATH = Path(os.getenv("MODEL_PATH", "./models"))
    LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
    BACKEND_URL = os.getenv("BACKEND_URL", "http://localhost:5000")
    
    # Model parameters
    TICKET_CONFIDENCE_THRESHOLD = 0.7
    RISK_HIGH_THRESHOLD = 0.7
    RISK_MEDIUM_THRESHOLD = 0.4
    BURNOUT_THRESHOLD = 0.6

Common Patterns

Protected Route Component

// src/components/ProtectedRoute.jsx
import React from 'react';
import { Navigate } from 'react-router-dom';

const ProtectedRoute = ({ children, requiredRole }) => {
  const token = localStorage.getItem('token');
  const user = JSON.parse(localStorage.getItem('user') || '{}');
  
  if (!token) {
    return <Navigate to="/login" />;
  }
  
  if (requiredRole && user.role !== requiredRole) {
    return <Navigate to="/unauthorized" />;
  }
  
  return children;
};

// Usage in App.js
import { BrowserRouter, Routes, Route } from 'react-router-dom';

<Routes>
  <Route path="/login" element=< />} />
  
      
    
  } />
  
      
    
  } />

Time Tracking Component

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

const TimeTracker = ({ taskId, onSave }) => {
  const [seconds, setSeconds] = useState(0);
  const [isRunning, setIsRunning] = useState(false);

  useEffect(() => {
    let interval;
    if (isRunning) {
      interval = setInterval(() => {
        setSeconds(s => s + 1);
      }, 1000);
    }
    return () => clearInterval(interval);
  }, [isRunning]);

  const formatTime = (sec) => {
    const hrs = Math.floor(sec / 3600);
    const mins = Math.floor((sec % 3600) / 60);
    const secs = sec % 60;
    return `${hrs.toString().padStart(2, '0')}:${mins.toString().padStart(2, '0')}:${secs.toString().padStart(, )}`;
  };

    = () => {
    (.(seconds / )); 
    ();
    ();
  };

   (
    
  );
};

  ;

Admin Analytics Dashboard

// src/components/AdminAnalytics.jsx
import React, { useState, useEffect } from 'react';
import axios from 'axios';
import { getAuthHeader } from '../services/authService';

const AdminAnalytics = () => {
  const [analytics, setAnalytics] = useState({
    totalUsers: 0,
    activeTasks: 0,
    openTickets: 0,
    highRiskUsers: []
  });

  const API_URL = process.env.REACT_APP_API_URL;
  const ML_API_URL = process.env.REACT_APP_ML_API_URL;

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

  const fetchAnalytics = async () => {
    try {
      const [users, tasks, tickets] = await Promise.all([
        axios.get(`${API_URL}/api/users`, { headers: getAuthHeader() }),
        axios.get(`/api/tasks`, { : () }),
        axios.(, { : () })
      ]);

      
       riskChecks =  .(
        users..( 
          axios.(, {
            : user.,
            : user. || ,
            : user. || ,
            : user. || []
          }).( ({ : { :  } }))
        )
      );

       highRiskUsers = users..( 
        riskChecks[i].. === 
      );

      ({
        : users..,
        : tasks..( t. !== ).,
        : tickets..( t. !== ).,
        highRiskUsers
      });
    }  (error) {
      .(, error);
    }
  };

   (
    
  );
};

  ;

Troubleshooting

JWT Token Expiration

// Add axios interceptor to handle token refresh
import axios from 'axios';

axios.interceptors.response.use(
  response => response,
  error => {
    if (error.response?.status === 401) {
      localStorage.removeItem('token');
      localStorage.removeItem('user');
      window.location.href = '/login';
    }
    return Promise.reject(error);
  }
);

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,
      serverSelectionTimeoutMS: 5000
    });
    console.log('MongoDB connected');
  } catch (error) {
    console.error('MongoDB connection error:', error);
    process.exit(1);
  }
};

module.exports = connectDB;

CORS Configuration

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

const app = express();

const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(',') || 
  ['http://localhost:3000'];

app.use(cors({
  origin: (origin, callback) => {
    if (!origin || allowedOrigins.includes(origin)) {
      callback(null, true);
    } else {
      callback(new Error('Not allowed by CORS'));
    }
  },
  credentials: true
}));

ML Service Not Responding

# Check if ML service is running
curl http://localhost:8000/health

# Check logs
cd ml-service
tail -f logs/app.log

# Restart with verbose logging
uvicorn main:app --reload --log-level debug

Frontend Build Issues

# Clear cache and rebuild
cd frontend
rm -rf node_modules package-lock.json
npm install
npm start

# Production build
npm run build

Deployment

Production Build

# Frontend
cd frontend
npm run build
# Serve build folder with nginx or serve

# Backend
cd backend
npm install --production
NODE_ENV=production node server.js

# ML Service
cd ml-service
pip install -r requirements