enterprise-user-management-system-ai-analytics

name	enterprise-user-management-system-ai-analytics
description	Full-stack user management system with AI-powered analytics for risk detection, burnout analysis, and predictive insights
triggers	["set up enterprise user management system","integrate AI analytics into user management","implement JWT authentication for user management","create admin dashboard with user analytics","add AI-based ticket classification system","build kanban board for task management","detect user burnout with ML models","implement role-based access control with AI"]

Enterprise User Management System with AI Analytics

Skill by ara.so — Data Skills collection.

Overview

Enterprise User Management System with AI Analytics is a full-stack application that combines user management, task tracking, and support ticket systems with AI-powered insights. It provides risk detection, anomaly detection, burnout analysis, and predictive project insights using machine learning models built with FastAPI, scikit-learn, and River.

The system consists of three main components:

• Frontend: React.js application with user/admin dashboards
• Backend: Node.js REST API with MongoDB and JWT authentication
• ML Service: FastAPI service for AI/ML predictions and analytics

Installation

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 .env file
cat > .env << EOF
PORT=5000
MONGODB_URI=${MONGODB_URI}
JWT_SECRET=${JWT_SECRET}
JWT_EXPIRE=7d
ML_SERVICE_URL=http://localhost:8000
EOF

npm start

ML Service Setup

cd ml-service
pip install -r requirements.txt

# Create .env file
cat > .env << EOF
MONGODB_URI=${MONGODB_URI}
MODEL_PATH=./models
LOG_LEVEL=INFO
EOF

uvicorn main:app --reload --port 8000

Frontend Setup

cd frontend
npm install

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

npm start

Core Architecture

Backend API Structure (Node.js)

// server.js - Main entry point
const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
const jwt = require('jsonwebtoken');
require('dotenv').config();

const app = express();

app.use(cors());
app.use(express.json());

// Connect to MongoDB
mongoose.connect(process.env.MONGODB_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true
}).then(() => console.log('MongoDB Connected'))
  .catch(err => console.error('MongoDB connection error:', err));

// Routes
app.use('/api/auth', require('./routes/auth'));
app.use('/api/users', require('./routes/users'));
app.use(, ());
app.(, ());
app.(, ());

  = process.. || ;
app.(,  .());

Authentication Middleware

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

module.exports = function(req, res, next) {
  const token = req.header('x-auth-token');
  
  if (!token) {
    return res.status(401).json({ msg: 'No token, authorization denied' });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded.user;
    next();
  } catch (err) {
    res.status(401).json({ msg: 'Token is not valid' });
  }
};

// middleware/admin.js
module.exports = function(req, res, next) {
  if (req.user.role !== 'admin') {
    return res.status(403).json({ msg: 'Access denied. Admin only.' });
  }
  next();
};

User Model

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

const UserSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  },
  password: {
    type: String,
    required: true
  },
  role: {
    type: String,
    enum: ['user', 'admin', 'manager'],
    default: 'user'
  },
  department: String,
  status: {
    type: String,
    enum: ['active', 'inactive', 'suspended'],
    default: 'active'
  },
  tasksAssigned: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Task'
  }],
  workloadScore: {
    type: ,
    : 
  },
  : {
    : ,
    : .
  }
});

. = mongoose.(, );

Task Model

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

const TaskSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true
  },
  description: String,
  assignedTo: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  status: {
    type: String,
    enum: ['todo', 'in-progress', 'done'],
    default: 'todo'
  },
  priority: {
    type: String,
    enum: ['low', 'medium', 'high', 'critical'],
    default: 'medium'
  },
  dueDate: Date,
  timeTracked: {
    type: Number,
    default: 0
  },
  createdBy: {
    type: mongoose.Schema.Types.,
    : 
  },
  : {
    : ,
    : .
  },
  : 
});

. = mongoose.(, );

Ticket Model

// 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', 'administrative', 'hr', 'other']
  },
  priority: {
    type: String,
    enum: ['low', 'medium', 'high', 'critical']
  },
  status: {
    type: String,
    enum: ['open', 'in-progress', 'resolved', 'closed'],
    default: 'open'
  },
  createdBy: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  assignedTo: {
    : mongoose...,
    : 
  },
  : {
    : ,
    : 
  },
  : {
    : ,
    : .
  }
});

. = mongoose.(, );

ML Service API

FastAPI Main Application

# ml-service/main.py
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import List, Optional
import numpy as np
from sklearn.ensemble import RandomForestClassifier, IsolationForest
from river import linear_model, metrics
import joblib
import os

app = FastAPI(title="Enterprise AI Analytics Service")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Load or initialize models
MODEL_PATH = os.getenv('MODEL_PATH', './models')
os.makedirs(MODEL_PATH, exist_ok=True)

# Risk detection model
risk_model = RandomForestClassifier(n_estimators=100, random_state=42)

# Anomaly detection model
anomaly_model = IsolationForest(contamination=0.1, random_state=42)

# Online learning model for burnout detection
burnout_model = linear_model.LogisticRegression()

class UserBehavior(BaseModel):
    user_id: str
    login_frequency: float
    task_completion_rate: float
    average_task_time: float
    missed_deadlines: int
    workload_score: 
    overtime_hours: 

 ():
    title: 
    description: 

 ():
    prediction: 
    confidence: 
    risk_score: [] = 


 ():
     {: }


  ():
    
    :
        features = np.array([[
            data.login_frequency,
            data.task_completion_rate,
            data.average_task_time,
            data.missed_deadlines,
            data.workload_score,
            data.overtime_hours
        ]])
        
        
        risk_score = (
            ( - data.task_completion_rate) *  +
            data.missed_deadlines *  +
            (data.workload_score / ) *  +
            (data.overtime_hours / ) * 
        )
        
         risk_score > :
            prediction = 
         risk_score > :
            prediction = 
        :
            prediction = 
        
        confidence = ((risk_score - ) / , )
        
         PredictionResponse(
            prediction=prediction,
            confidence=confidence,
            risk_score=risk_score
        )
     Exception  e:
         HTTPException(status_code=, detail=(e))


  ():
    
    :
        features = np.array([[
            data.login_frequency,
            data.task_completion_rate,
            data.average_task_time,
            data.missed_deadlines,
            data.workload_score,
            data.overtime_hours
        ]])
        
        
        is_anomaly = (
            data.login_frequency >  
            data.login_frequency <  
            data.task_completion_rate <  
            data.overtime_hours >  
            data.missed_deadlines > 
        )
        
         {
            : is_anomaly,
            : (data.workload_score)  is_anomaly  ,
            : {
                : data.login_frequency > ,
                : data.task_completion_rate < ,
                : data.overtime_hours > ,
                : data.missed_deadlines > 
            }
        }
     Exception  e:
         HTTPException(status_code=, detail=(e))


  ():
    
    :
        burnout_score = (
            (data.workload_score / ) *  +
            (data.overtime_hours / ) *  +
            ( - data.task_completion_rate) *  +
            (data.missed_deadlines / ) * 
        )
        
         burnout_score > :
            prediction = 
            recommendation = 
         burnout_score > :
            prediction = 
            recommendation = 
        :
            prediction = 
            recommendation = 
        
         PredictionResponse(
            prediction=prediction,
            confidence=(burnout_score / , ),
            risk_score=burnout_score
        )
     Exception  e:
         HTTPException(status_code=, detail=(e))


  ():
    
    :
        text = .lower()
        
        
         (word  text  word  [, , , ]):
            category = 
            priority = 
         (word  text  word  [, , , ]):
            category = 
            priority = 
         (word  text  word  [, , ]):
            category = 
            priority = 
        :
            category = 
            priority = 
        
         {
            : category,
            : priority,
            : ,
            : category.title()
        }
     Exception  e:
         HTTPException(status_code=, detail=(e))


  ():
    
    :
        tasks = data.get(, [])
        total_tasks = (tasks)
        completed_tasks = (  t  tasks  t.get() == )
        overdue_tasks = (  t  tasks  t.get(, ))
        
        completion_rate = completed_tasks / total_tasks  total_tasks >   
        
        
        delay_risk = overdue_tasks / total_tasks  total_tasks >   
        
        insights = {
            : completion_rate,
            : delay_risk,
            : (delay_risk * ),
            : []
        }
        
         delay_risk > :
            insights[].append()
         completion_rate < :
            insights[].append()
        
         insights
     Exception  e:
         HTTPException(status_code=, detail=(e))

Frontend Integration

API Service Helper

// frontend/src/services/api.js
import axios from 'axios';

const API_URL = process.env.REACT_APP_API_URL || 'http://localhost:5000';
const ML_API_URL = process.env.REACT_APP_ML_API_URL || 'http://localhost:8000';

// Set auth token
export const setAuthToken = (token) => {
  if (token) {
    axios.defaults.headers.common['x-auth-token'] = token;
    localStorage.setItem('token', token);
  } else {
    delete axios.defaults.headers.common['x-auth-token'];
    localStorage.removeItem('token');
  }
};

// Auth APIs
export const login = async (email, password) => {
  const response = await axios.post(`${API_URL}/api/auth/login`, {
    email,
    password
  });
  setAuthToken(response.data.token);
   response.;
};

   =  () => {
   response =  axios.(, userData);
   response.;
};


   =  () => {
   response =  axios.();
   response.;
};

   =  () => {
   response =  axios.(, userData);
   response.;
};

   =  () => {
   response =  axios.(, userData);
   response.;
};

   =  () => {
   response =  axios.();
   response.;
};


   =  () => {
   response =  axios.();
   response.;
};

   =  () => {
   response =  axios.(, taskData);
   response.;
};

   =  () => {
   response =  axios.(, taskData);
   response.;
};


   =  () => {
   response =  axios.();
   response.;
};

   =  () => {
   response =  axios.(, ticketData);
  
  
   classification =  ({
    : ticketData.,
    : ticketData.
  });
  
   { ...response., classification };
};


   =  () => {
   response =  axios.(, userBehavior);
   response.;
};

   =  () => {
   response =  axios.(, userBehavior);
   response.;
};

   =  () => {
   response =  axios.(, userBehavior);
   response.;
};

   =  () => {
   response =  axios.(, ticketData);
   response.;
};

   =  () => {
   response =  axios.(, projectData);
   response.;
};

React Component Example - Admin Dashboard

// frontend/src/components/AdminDashboard.jsx
import React, { useState, useEffect } from 'react';
import { getUsers, getTasks, getProjectInsights, getRiskPrediction } from '../services/api';

const AdminDashboard = () => {
  const [users, setUsers] = useState([]);
  const [tasks, setTasks] = useState([]);
  const [insights, setInsights] = useState(null);
  const [riskUsers, setRiskUsers] = useState([]);

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

  const loadDashboardData = async () => {
    try {
      const usersData = await getUsers();
      const tasksData = await getTasks();
      
      setUsers(usersData);
      setTasks(tasksData);

      // Get project insights
      const projectInsights = await getProjectInsights({ tasks: tasksData });
      setInsights(projectInsights);

      // Check risk for each user
      const risks = await Promise.(
        usersData.( (user) => {
           userTasks = tasksData.( t. === user.);
           completedTasks = userTasks.( t. === ).;
           missedDeadlines = userTasks.( t.).;

           riskData =  ({
            : user.,
            : user. || ,
            : completedTasks / userTasks. || ,
            : user. || ,
            : missedDeadlines,
            : user. || ,
            : user. || 
          });

           { ...user, : riskData };
        })
      );

       highRiskUsers = risks.( u.. === );
      (highRiskUsers);
    }  (error) {
      .(, error);
    }
  };

   (
    
  );
};

  ;

Kanban Board Component

// frontend/src/components/KanbanBoard.jsx
import React, { useState, useEffect } from 'react';
import { DragDropContext, Droppable, Draggable } from 'react-beautiful-dnd';
import { getTasks, updateTask } from '../services/api';

const KanbanBoard = ({ userId }) => {
  const [columns, setColumns] = useState({
    todo: { name: 'To Do', items: [] },
    'in-progress': { name: 'In Progress', items: [] },
    done: { name: 'Done', items: [] }
  });

  useEffect(() => {
    loadTasks();
  }, [userId]);

  const loadTasks = async () => {
    try {
      const tasks = await getTasks();
      const userTasks = tasks.filter(t => t.assignedTo === userId);

      const newColumns = {
        todo: { name: 'To Do', : [] },
        : { : , : [] },
        : { : , : [] }
      };

      userTasks.( {
         (newColumns[task.]) {
          newColumns[task.]..(task);
        }
      });

      (newColumns);
    }  (error) {
      .(, error);
    }
  };

    =  () => {
     (!result.) ;

     { source, destination } = result;

     (source. !== destination.) {
       sourceColumn = columns[source.];
       destColumn = columns[destination.];
       sourceItems = [...sourceColumn.];
       destItems = [...destColumn.];
       [removed] = sourceItems.(source., );
      destItems.(destination., , removed);

      ({
        ...columns,
        [source.]: {
          ...sourceColumn,
          : sourceItems
        },
        [destination.]: {
          ...destColumn,
          : destItems
        }
      });

      
       (removed., { : destination. });
    }
  };

   (
    
  );
};

  ;

Common Patterns

Protected Routes with Role-Based Access

// frontend/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;
};

export default ProtectedRoute;

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

 () {
   (
    
  );
}

Real-time Burnout Monitoring

// backend/services/burnoutMonitor.js
const User = require('../models/User');
const axios = require('axios');

async function checkUserBurnout(userId) {
  const user = await User.findById(userId).populate('tasksAssigned');
  
  const completedTasks = user.tasksAssigned.filter(t => t.status === 'done').length;
  const totalTasks = user.tasksAssigned.length;
  const missedDeadlines = user.tasksAssigned.filter(t => {
    return t.dueDate && new Date(t.dueDate) < new Date() && t.status !== 'done';
  }).length;

  const behaviorData = {
    user_id: userId,
    login_frequency: user.loginFrequency || 10,
    task_completion_rate: totalTasks > 0 ? completedTasks / totalTasks : ,
    : user. || ,
    : missedDeadlines,
    : user. || ,
    : user. || 
  };

   response =  axios.(
    ,
    behaviorData
  );

   response.;
}

. = { checkUserBurn