}
- if (created && created.data) return created;
- return { data: created };
- } catch (error) {
- console.error("Backend unavailable, falling back to mock:", error);
- await delay(800);
- return createTicketMock(ticketData);
+ const tickets = getStorage('tickets', MOCK_TICKETS);
+ const newTicket = {
+ ticket_id: "TCKT-" + Math.floor(Math.random() * 10000),
+ status: 'Open',
+ createdAt: new Date().toISOString(),
+ ...ticketData,
+ messages: [
+ {
+ sender: 'user',
+ message: ticketData.description || ticketData.summary || '',
+ timestamp: new Date().toISOString()
+ }
+ ]
+ };
+ tickets.unshift(newTicket); // Add to beginning
+ setStorage('tickets', tickets);
+ return { data: newTicket };
}
},
diff --git a/Frontend/src/store/authStore.js b/Frontend/src/store/authStore.js
index ae0e53f6cb8edf7cbc39d1de8632683ab0758173..4e6014f48f280c34f58ece3c44427653016ac702 100644
--- a/Frontend/src/store/authStore.js
+++ b/Frontend/src/store/authStore.js
@@ -1,55 +1,10 @@
import { create } from 'zustand';
import { persist } from 'zustand/middleware';
import { supabase } from '../lib/supabaseClient';
-import { API_CONFIG } from '../config';
import useTicketStore from './ticketStore';
-const BACKEND_URL = API_CONFIG.BACKEND_URL;
-
-const verifyServerCookieSession = async () => {
- try {
- const res = await fetch(`${BACKEND_URL}/auth/me`, {
- method: 'GET',
- credentials: 'include',
- headers: { Accept: 'application/json' },
- });
- if (!res.ok) return null;
- const body = await res.json();
- return body?.user || null;
- } catch (e) {
- console.warn('Server cookie session check failed:', e?.message || e);
- return null;
- }
-};
-
-const mirrorBackendAuth = async (path, payload) => {
- try {
- await fetch(`${BACKEND_URL}${path}`, {
- method: 'POST',
- credentials: 'include',
- headers: { 'Content-Type': 'application/json' },
- body: JSON.stringify(payload),
- });
- } catch (e) {
- console.warn(`Backend auth ${path} failed:`, e?.message || e);
- }
-};
-
let currentUserPromise = null;
-const getProfileCache = (profile) => {
- if (!profile?.id) return null;
-
- return {
- id: profile.id,
- email: profile.email,
- full_name: profile.full_name,
- company: profile.company,
- company_id: profile.company_id,
- profile_picture: profile.profile_picture,
- };
-};
-
const useAuthStore = create(
persist(
(set, get) => ({
@@ -66,25 +21,38 @@ const useAuthStore = create(
if (!user) return null;
const metadata = user.user_metadata || {};
- set({ profile: null });
-
- // Always resolve authorization fields from the database. Local storage and
- // user_metadata are client-controlled surfaces and must not grant roles.
- const dbProfile = await get()._syncProfile(user.id);
- if (dbProfile) {
- return dbProfile;
+ const currentProfile = get().profile;
+
+ // 1. Resolve FROM METADATA or PERSISTED state
+ // Priority 1: If we have a persisted session for THIS user and it's active, keep it
+ // to prevent temporary lobbies during refresh/tab switching.
+ if (currentProfile && currentProfile.id === user.id && currentProfile.status === 'active') {
+ console.log("Active profile retained from state.");
+ // Background fetch to ensure session is still valid/synced
+ get()._syncProfile(user.id);
+ return currentProfile;
}
+ // Priority 2: Use Auth Metadata (Instant fallback)
+ const isMasterAdmin = user.email === 'masteradmin@helpdesk.ai';
+
const instantProfile = {
id: user.id,
email: user.email,
- full_name: metadata.full_name || 'User',
- role: 'user',
- status: 'pending_email_verification',
+ full_name: isMasterAdmin ? 'Master Admin' : (metadata.full_name || 'User'),
+ role: isMasterAdmin ? 'master_admin' : (metadata.role || 'user'),
+ status: isMasterAdmin ? 'active' : 'pending_email_verification',
company: metadata.company || ''
};
- console.log("Falling back to non-authoritative profile:", instantProfile.role);
+ // 2. Sync with Database First before setting a fallback
+ // This prevents flashes of 'pending_email_verification' when returning from magic links
+ const dbProfile = await get()._syncProfile(user.id);
+ if (dbProfile) {
+ return dbProfile;
+ }
+
+ console.log("Falling back to instant profile resolved from metadata:", instantProfile.role);
set({ profile: instantProfile });
return instantProfile;
},
@@ -121,19 +89,13 @@ const useAuthStore = create(
currentUserPromise = (async () => {
try {
set({ isCheckingSession: true });
- const cookieUser = await verifyServerCookieSession();
- if (cookieUser) {
- set({ user: cookieUser });
- await get().getProfile(cookieUser);
- return cookieUser;
- }
-
const { data: { user }, error } = await supabase.auth.getUser();
if (error) throw error;
if (user) {
set({ user });
- await get().getProfile(user);
+ // Don't 'await' here because we want 'loading: false' ASAP
+ get().getProfile(user);
} else {
set({ user: null, profile: null });
}
@@ -155,8 +117,6 @@ const useAuthStore = create(
set({ loading: true });
console.log("Attempting login for:", email);
try {
- await mirrorBackendAuth('/auth/login', { email, password });
-
const { data, error } = await supabase.auth.signInWithPassword({
email,
password,
@@ -245,14 +205,6 @@ const useAuthStore = create(
console.log("Starting signup for:", email);
try {
- await mirrorBackendAuth('/auth/signup', {
- email,
- password,
- full_name: fullName,
- role,
- company,
- });
-
// 1. Auth Signup with Metadata
console.log("Step 1: Auth.signUp...");
const { data, error } = await supabase.auth.signUp({
@@ -293,15 +245,6 @@ const useAuthStore = create(
logout: async () => {
set({ loading: true });
try {
- try {
- await fetch(`${BACKEND_URL}/auth/logout`, {
- method: 'POST',
- credentials: 'include',
- });
- } catch (e) {
- console.warn('Backend cookie logout failed:', e?.message || e);
- }
-
const { error } = await supabase.auth.signOut();
if (error) throw error;
set({ user: null, profile: null });
@@ -350,8 +293,8 @@ const useAuthStore = create(
supabase.auth.onAuthStateChange(async (event, session) => {
console.log("Auth state change:", event);
if (session?.user) {
- set({ user: session.user, loading: true, isCheckingSession: true });
- await get().getProfile(session.user);
+ set({ user: session.user });
+ get().getProfile(session.user);
} else {
set({ user: null, profile: null });
}
@@ -362,8 +305,9 @@ const useAuthStore = create(
{
name: 'auth-storage',
partialize: (state) => ({
- // Cache display-only profile fields. Role/status must come from the DB.
- profile: getProfileCache(state.profile)
+ // We keep profile persisted for quick UI transitions,
+ // but session is handled by Supabase cookie/localStorage
+ profile: state.profile
}),
}
)
diff --git a/Frontend/src/store/ticketStore.js b/Frontend/src/store/ticketStore.js
index 013330a7f946696641a63db65aa3bf50a44ee9e0..1b88dddfb0ff1fde84d53e9acc671109045d36d9 100644
--- a/Frontend/src/store/ticketStore.js
+++ b/Frontend/src/store/ticketStore.js
@@ -3,19 +3,14 @@ import { persist } from 'zustand/middleware';
const useTicketStore = create(
persist(
- (set, get) => ({
+ (set) => ({
aiTicket: null,
activeTicket: null,
autoResolvedTickets: [], // For analytics
tickets: [], // Global queue for admins
notifications: [], // User notifications
- wsConnected: false, // WebSocket connection status
-
setAITicket: (data) => set({ aiTicket: data }),
setActiveTicket: (ticket) => set({ activeTicket: ticket }),
-
- setWsConnected: (connected) => set({ wsConnected: connected }),
-
addAutoResolvedTicket: (record) => set((state) => ({
autoResolvedTickets: [...state.autoResolvedTickets, record]
})),
@@ -35,68 +30,27 @@ const useTicketStore = create(
tickets: [...state.tickets, ticket]
};
}),
- upsertTicket: (ticket) => set((state) => {
- const ticketId = ticket?.id ?? ticket?.ticket_id;
- if (!ticketId) return state;
+ updateTicket: (ticketId, updates) => set((state) => {
+// eslint-disable-next-line no-unused-vars
+ const existingTicket = state.tickets.find(t => t.ticket_id === ticketId);
+ const updatedTickets = state.tickets.map(t => t.ticket_id === ticketId ? { ...t, ...updates } : t);
+ const shouldUpdateActive = state.activeTicket?.ticket_id === ticketId;
+
+
- const exists = state.tickets.some(t => (t.id ?? t.ticket_id) === ticketId);
- const tickets = exists
- ? state.tickets.map(t => (t.id ?? t.ticket_id) === ticketId ? { ...t, ...ticket } : t)
- : [ticket, ...state.tickets];
- const shouldUpdateActive = (state.activeTicket?.id ?? state.activeTicket?.ticket_id) === ticketId;
- return {
- tickets,
- activeTicket: shouldUpdateActive ? { ...state.activeTicket, ...ticket } : state.activeTicket
- };
- }),
- removeTicket: (ticketId) => set((state) => ({
- tickets: state.tickets.filter(t => (t.id ?? t.ticket_id) !== ticketId),
- activeTicket: (state.activeTicket?.id ?? state.activeTicket?.ticket_id) === ticketId
- ? null
- : state.activeTicket
- })),
- updateTicket: (ticketId, updates) => set((state) => {
- const existingTicket = state.tickets.find(t => (t.id ?? t.ticket_id) === ticketId);
- if (!existingTicket) return state;
- const updatedTickets = state.tickets.map(t => (t.id ?? t.ticket_id) === ticketId ? { ...t, ...updates } : t);
- const shouldUpdateActive = (state.activeTicket?.id ?? state.activeTicket?.ticket_id) === ticketId;
return {
tickets: updatedTickets,
activeTicket: shouldUpdateActive ? { ...state.activeTicket, ...updates } : state.activeTicket
};
}),
- /**
- * Route an incoming WebSocket message to the correct store action.
- *
- * Call this from the component that owns the WebSocket connection
- * (e.g. AdminDashboard) whenever a message arrives.
- */
- handleWsMessage: (msg) => {
- if (!msg || !msg.type) return;
-
- const { type, event, ticket, ticket_id } = msg;
-
- switch (type) {
- case "ticket_update": {
- if (!ticket) break;
- if (event === "created") {
- // Avoid duplicates — use upsert
- get().upsertTicket(ticket);
- } else if (event === "updated") {
- get().upsertTicket(ticket);
- } else if (event === "deleted") {
- get().removeTicket(ticket_id);
- }
- break;
- }
- default:
- // Ignore unknown message types (e.g. heartbeat)
- break;
- }
- },
-
+ removeTicket: (ticketId) => set((state) => ({
+ tickets: state.tickets.filter(t => t.ticket_id !== ticketId),
+ activeTicket: state.activeTicket?.ticket_id === ticketId
+ ? null
+ : state.activeTicket
+})),
appendMessage: (ticketId, message) => set((state) => {
const updatedTickets = state.tickets.map(t =>
t.ticket_id === ticketId
diff --git a/Frontend/src/user/components/RecentTickets.jsx b/Frontend/src/user/components/RecentTickets.jsx
index eb8d7d67e33f1e8525cda128ecabf298d59ad72b..b60a70ddf1893fd577087ad1675841059e40cf40 100644
--- a/Frontend/src/user/components/RecentTickets.jsx
+++ b/Frontend/src/user/components/RecentTickets.jsx
@@ -150,11 +150,6 @@ const RecentTickets = () => {
{ticket.summary || ticket.subject || ticket.description || "No description provided"}
- {ticket?.metadata?.translation?.translated && (
-
- Translated from {ticket.metadata.translation.source_language_name || ticket.metadata.translation.source_language || 'Unknown'}
-
- )}
{getStatusBadge(ticket.status)}
diff --git a/Frontend/src/user/pages/AutoResolveChat.jsx b/Frontend/src/user/pages/AutoResolveChat.jsx
index f1fae74896b76cb83721e914e9b25611cb8938f9..d8863209b8b4e69d6e8fcc8a7482be584e339d05 100644
--- a/Frontend/src/user/pages/AutoResolveChat.jsx
+++ b/Frontend/src/user/pages/AutoResolveChat.jsx
@@ -19,7 +19,6 @@ const AutoResolveChat = () => {
const { aiTicket } = useTicketStore();
const navigate = useNavigate();
const [messages, setMessages] = useState([]);
- const [steps, setSteps] = useState([]);
const [isThinking, setIsThinking] = useState(false);
const [isFinal, setIsFinal] = useState(false);
const [inputText, setInputText] = useState('');
@@ -78,7 +77,7 @@ const AutoResolveChat = () => {
}
if (newSteps.length >= 2) {
- setSteps(newSteps);
+ // Steps parsed successfully; welcome message sent below
} else {
const sentences = response
.replace(/\*\*/g, '')
@@ -88,12 +87,7 @@ const AutoResolveChat = () => {
.slice(0, 4);
if (sentences.length >= 2) {
- const sentenceSteps = sentences.map((s, i) => ({
- id: i + 1,
- task: s,
- completed: false
- }));
- setSteps(sentenceSteps);
+ // Plan parsed but not rendered; welcome message sent below
} else {
throw new Error("Could not parse steps from AI response.");
}
@@ -203,12 +197,6 @@ const AutoResolveChat = () => {
else recognition.start();
};
- const toggleStep = (stepId) => {
- setSteps(prev => prev.map(step =>
- step.id === stepId ? { ...step, completed: !step.completed } : step
- ));
- };
-
if (!aiTicket) return null;
return (
@@ -261,48 +249,6 @@ const AutoResolveChat = () => {
- {/* Troubleshooting Steps */}
- {steps.length > 0 && (
-
-
-
- Troubleshooting Plan
-
-
-
- {steps.map((step) => (
-
toggleStep(step.id)}
- className={`w-full text-left flex items-center gap-3 p-3 rounded-xl border transition-all duration-300 ${
- step.completed
- ? 'bg-emerald-100 border-emerald-200 opacity-60'
- : 'bg-white border-slate-100 hover:border-emerald-200 hover:bg-emerald-50/50'
- }`}
- >
-
- {step.completed ? (
- {step.id}
- )}
-
-
- {step.task}
-
-
- ))}
-
-
{
const processOCR = async (imageFile) => {
setIsOcrLoading(true);
try {
- const { default: Tesseract } = await import('tesseract.js');
const { data: { text } } = await Tesseract.recognize(imageFile, 'eng');
setExtractedOCR(text.trim());
} catch (err) {
diff --git a/Frontend/src/user/pages/MyTickets.jsx b/Frontend/src/user/pages/MyTickets.jsx
index 94baf3a499ee494f60e71e3cda0d6ae0f11aac13..47b952b887cf925f0eca691116864b2b12cb9290 100644
--- a/Frontend/src/user/pages/MyTickets.jsx
+++ b/Frontend/src/user/pages/MyTickets.jsx
@@ -120,14 +120,6 @@ function MyTickets() {
return 'text-gray-600';
};
- const getTranslationInfo = (ticket) => {
- const t = ticket?.metadata?.translation;
- if (!t?.translated) return null;
- return {
- sourceLanguageName: t.source_language_name || t.source_language || 'Unknown',
- };
- };
-
return (
{/* Header section */}
@@ -325,11 +317,6 @@ function MyTickets() {
{ticket.summary || ticket.subject || ticket.description || "No subject"}
- {getTranslationInfo(ticket) && (
-
- Translated from {getTranslationInfo(ticket).sourceLanguageName}
-
- )}
diff --git a/Frontend/src/user/pages/TicketDetail.jsx b/Frontend/src/user/pages/TicketDetail.jsx
index 445f1d4105209d2b3751a5ca979d0c873f1d9330..e2b66f667686e65e78b1059bbffa030d383fd31c 100644
--- a/Frontend/src/user/pages/TicketDetail.jsx
+++ b/Frontend/src/user/pages/TicketDetail.jsx
@@ -22,7 +22,6 @@ const TicketDetail = () => {
const [isReopening, setIsReopening] = useState(false);
const [showCsat, setShowCsat] = useState(false);
const [csatHasBeenDismissed, setCsatHasBeenDismissed] = useState(false);
- const [showOriginalText, setShowOriginalText] = useState(false);
useEffect(() => {
window.scrollTo(0, 0);
@@ -123,10 +122,6 @@ const TicketDetail = () => {
const solutionSteps = Array.isArray(ticket.solution_steps) ? ticket.solution_steps : [];
const isAutoResolved = ticket.auto_resolve === true;
const confidenceScore = ticket.metadata?.confidence ?? ticket.routing_confidence ?? 0.92;
- const translationMeta = ticket.metadata?.translation;
- const originalTextMeta = ticket.metadata?.original_text;
- const isTranslated = Boolean(translationMeta?.translated && originalTextMeta?.description);
- const sourceLanguageName = translationMeta?.source_language_name || translationMeta?.source_language || 'Unknown';
const handleReopen = async () => {
@@ -189,27 +184,6 @@ const TicketDetail = () => {
{/* LEFT SIDE (Main Content) */}
- {isTranslated && (
-
-
-
- Translated from {sourceLanguageName}
-
-
setShowOriginalText(prev => !prev)}
- className="text-xs font-bold text-sky-700 hover:text-sky-900"
- >
- {showOriginalText ? "View English" : "View Original"}
-
-
- {originalTextMeta?.description}
-
- )}
-
- )}
{/* Card 1: Ticket Timeline */}
diff --git a/Frontend/vite.config.js b/Frontend/vite.config.js
index 4232886f5e1cccfa7b5fa4edcdff334225b6fb26..d9048b718cda48dbe657e892a9f5b407eb2b73fc 100644
--- a/Frontend/vite.config.js
+++ b/Frontend/vite.config.js
@@ -15,6 +15,6 @@ export default defineConfig({
},
},
build: {
- sourcemap: 'hidden'
+ sourcemap: true
}
})
diff --git a/MobileApp/App.js b/MobileApp/App.js
index 1d2f3e9e0771859dd8c4dd81e6e939fe7cb70020..b4194b485bbd05fb958416fe844452b6c9ac6c7a 100644
--- a/MobileApp/App.js
+++ b/MobileApp/App.js
@@ -127,55 +127,17 @@ const AppContent = () => {
const [userRole, setUserRole] = useState('user'); // 'user', 'admin', 'master_admin'
useEffect(() => {
- let finished = false;
-
const initialize = async () => {
- // Safety timeout wrapper: if anything hangs, force mount after 3 seconds
- const timeoutId = setTimeout(async () => {
- if (!finished) {
- console.log('[AuthInit] Timeout reached (3s). Forcing mount fallback.');
- try {
- const onboardingDone = await AsyncStorage.getItem('@onboarding_complete');
- setShowOnboarding(onboardingDone === null);
- } catch (err) {
- setShowOnboarding(false);
- }
- setLoading(false);
- }
- }, 3000);
-
try {
- // 1. Instantly load cached status and role from AsyncStorage (stale-while-revalidate pattern)
- const [cachedStatus, cachedRole] = await Promise.all([
- AsyncStorage.getItem('@user_status'),
- AsyncStorage.getItem('@user_role'),
- ]);
-
- if (cachedStatus) setUserStatus(cachedStatus);
- if (cachedRole) setUserRole(cachedRole);
-
- // 2. Fetch session with a 2.5 second timeout wrapper to prevent slow refreshing from locking the app
- const sessionPromise = supabase.auth.getSession();
- const sessionTimeoutPromise = new Promise((_, reject) =>
- setTimeout(() => reject(new Error('Session fetch timed out')), 2500)
- );
-
- const { data: { session } } = await Promise.race([sessionPromise, sessionTimeoutPromise]);
+ const { data: { session } } = await supabase.auth.getSession();
setSession(session);
- // 3. If session is valid, validate/fetch the user profile
if (session?.user) {
- const profilePromise = supabase
+ const { data, error } = await supabase
.from('profiles')
.select('status, role')
.eq('id', session.user.id)
.single();
-
- const profileTimeoutPromise = new Promise((_, reject) =>
- setTimeout(() => reject(new Error('Profile fetch timed out')), 2000)
- );
-
- const { data, error } = await Promise.race([profilePromise, profileTimeoutPromise]);
if (error) {
console.log('[AuthInit] Profile fetch error, validating session:', error.message);
@@ -184,29 +146,20 @@ const AppContent = () => {
if (userError) {
console.log('[AuthInit] Token validation failed. Clearing session.');
setSession(null);
- await AsyncStorage.removeItem('@user_status');
- await AsyncStorage.removeItem('@user_role');
} else {
- // Valid token but profiles table is offline; retain cached or default to safe user status
- if (!cachedStatus) setUserStatus('active');
- if (!cachedRole) setUserRole('user');
+ // Valid token but profiles table is temporarily offline; default to user
+ setUserStatus('active');
+ setUserRole('user');
}
} else {
- const status = data?.status || 'active';
- const role = data?.role || 'user';
- setUserStatus(status);
- setUserRole(role);
- await Promise.all([
- AsyncStorage.setItem('@user_status', status),
- AsyncStorage.setItem('@user_role', role),
- ]);
+ setUserStatus(data?.status || 'active');
+ setUserRole(data?.role || 'user');
}
}
} catch (e) {
- console.log('[AuthInit] Exception caught during initialization:', e.message || e);
+ console.log('[AuthInit] Crash caught during initialization:', e);
} finally {
- finished = true;
- clearTimeout(timeoutId);
+ // Guarantee showOnboarding is resolved to a boolean to prevent React Navigation stack layout mismatch
try {
const onboardingDone = await AsyncStorage.getItem('@onboarding_complete');
setShowOnboarding(onboardingDone === null);
@@ -231,17 +184,12 @@ const AppContent = () => {
if (error) {
console.log('[AuthChange] Profile query failed:', error.message);
+ // Default to safe values to avoid blank screens
setUserStatus('active');
setUserRole('user');
} else {
- const status = data?.status || 'active';
- const role = data?.role || 'user';
- setUserStatus(status);
- setUserRole(role);
- await Promise.all([
- AsyncStorage.setItem('@user_status', status),
- AsyncStorage.setItem('@user_role', role),
- ]);
+ setUserStatus(data?.status || 'active');
+ setUserRole(data?.role || 'user');
}
} catch (err) {
console.warn('[AuthChange] Uncaught exception inside handler:', err);
@@ -251,10 +199,6 @@ const AppContent = () => {
} else {
setUserStatus(null);
setUserRole('user');
- await Promise.all([
- AsyncStorage.removeItem('@user_status'),
- AsyncStorage.removeItem('@user_role'),
- ]);
}
});
@@ -272,15 +216,9 @@ const AppContent = () => {
schema: 'public',
table: 'profiles',
filter: `id=eq.${session.user.id}`,
- }, async (payload) => {
- const status = payload.new.status;
- const role = payload.new.role || 'user';
- setUserStatus(status);
- setUserRole(role);
- await Promise.all([
- AsyncStorage.setItem('@user_status', status),
- AsyncStorage.setItem('@user_role', role),
- ]);
+ }, (payload) => {
+ setUserStatus(payload.new.status);
+ setUserRole(payload.new.role || 'user');
})
.subscribe();
@@ -291,6 +229,7 @@ const AppContent = () => {
useEffect(() => {
const handleUrl = async ({ url }) => {
if (!url) return;
+ // Parse hash fragment: helpdeskai://login#access_token=...&refresh_token=...
const hashIndex = url.indexOf('#');
if (hashIndex === -1) return;
const hash = url.substring(hashIndex + 1);
@@ -316,7 +255,9 @@ const AppContent = () => {
}
};
+ // Handle app already open
const subscription = Linking.addEventListener('url', handleUrl);
+ // Handle cold start — app launched from the link
Linking.getInitialURL().then(url => url && handleUrl({ url }));
return () => subscription.remove();
diff --git a/MobileApp/package-lock.json b/MobileApp/package-lock.json
index ec2e17cb5c4ab6f4917d39cd5982503cdddcbb37..cf581c8ea446b453613e1b52e8c9aa4b3981c83c 100644
--- a/MobileApp/package-lock.json
+++ b/MobileApp/package-lock.json
@@ -31,7 +31,7 @@
"react-native-screens": "~4.16.0",
"react-native-svg": "15.12.1",
"react-native-url-polyfill": "^3.0.0",
- "react-native-webview": "^13.15.0",
+ "react-native-webview": "^13.16.1",
"zustand": "^5.0.12"
},
"devDependencies": {
diff --git a/MobileApp/package.json b/MobileApp/package.json
index cf88eae6afef07e73474bbe4f6b4e70241d8e4b2..53445a0e1eaeca087e810358a6b6602c66a75036 100644
--- a/MobileApp/package.json
+++ b/MobileApp/package.json
@@ -32,7 +32,7 @@
"react-native-screens": "~4.16.0",
"react-native-svg": "15.12.1",
"react-native-url-polyfill": "^3.0.0",
- "react-native-webview": "^13.15.0",
+ "react-native-webview": "^13.16.1",
"zustand": "^5.0.12"
},
"private": true,
diff --git a/MobileApp/src/lib/supabase.js b/MobileApp/src/lib/supabase.js
index 493e14574ebff9e4e0834a2b30c1640ad303f2a9..b41c7624f814ef6f3b4d3ecedd6fda1357d7f093 100644
--- a/MobileApp/src/lib/supabase.js
+++ b/MobileApp/src/lib/supabase.js
@@ -2,14 +2,8 @@ import 'react-native-url-polyfill/auto';
import { createClient } from '@supabase/supabase-js';
import AsyncStorage from '@react-native-async-storage/async-storage';
-const supabaseUrl = process.env.EXPO_PUBLIC_SUPABASE_URL;
-const supabaseKey = process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY;
-
-if (!supabaseUrl || !supabaseKey) {
- throw new Error(
- 'Missing Supabase mobile config. Set EXPO_PUBLIC_SUPABASE_URL and EXPO_PUBLIC_SUPABASE_ANON_KEY in MobileApp/.env or EAS secrets.'
- );
-}
+const supabaseUrl = 'https://aejuenhqciagpntcqoir.supabase.co';
+const supabaseKey = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFlanVlbmhxY2lhZ3BudGNxb2lyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzIzODQwNzgsImV4cCI6MjA4Nzk2MDA3OH0.-OxgEW5t4alPGlzV_JZDRZcLsQbbMap6jiWjfAVkMMY';
export const supabase = createClient(supabaseUrl, supabaseKey, {
auth: {
diff --git a/MobileApp/src/screens/auth/LoginScreen.js b/MobileApp/src/screens/auth/LoginScreen.js
index 28c99959a5b663cffcff1a4dce7ea92692b29526..f9181ad0be8da60d314eb24992a9d344e9b85740 100644
--- a/MobileApp/src/screens/auth/LoginScreen.js
+++ b/MobileApp/src/screens/auth/LoginScreen.js
@@ -5,7 +5,6 @@ import {
ScrollView, StatusBar, Animated,
} from 'react-native';
import { supabase } from '../../lib/supabase';
-import { backendLogin, backendLogout } from '../../lib/authBackend';
import { COLORS, SHADOWS } from '../../styles/theme';
import { Lock, Mail, Eye, EyeOff, Zap, ArrowRight, ShieldCheck } from 'lucide-react-native';
import { LinearGradient } from 'expo-linear-gradient';
@@ -53,7 +52,6 @@ const LoginScreen = () => {
}
setLoading(true);
try {
- await backendLogin(email, password);
const { data, error } = await supabase.auth.signInWithPassword({ email, password });
if (error) throw error;
diff --git a/MobileApp/src/screens/user/ProfileScreen.js b/MobileApp/src/screens/user/ProfileScreen.js
index f80d435b7637ba36231ed5b172e3d5d14d32987e..6d0129f294f266f70dc7aa20d78d7680dec08c1d 100644
--- a/MobileApp/src/screens/user/ProfileScreen.js
+++ b/MobileApp/src/screens/user/ProfileScreen.js
@@ -5,7 +5,6 @@ import {
} from 'react-native';
import { SafeAreaView } from 'react-native-safe-area-context';
import { supabase } from '../../lib/supabase';
-import { backendLogout } from '../../lib/authBackend';
import { COLORS, SHADOWS } from '../../styles/theme';
import {
User, Mail, Building2, ShieldCheck, Calendar, Ticket, Zap,
@@ -227,7 +226,6 @@ const ProfileScreen = () => {
const handleLogout = async () => {
try {
Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium);
- await backendLogout();
// Forcefully wipe all Supabase session keys from AsyncStorage first to trigger instant navigation resetting
const keys = await AsyncStorage.getAllKeys();
const supabaseKeys = keys.filter(k => k.startsWith('sb-') || k.includes('supabase'));
@@ -238,7 +236,6 @@ const ProfileScreen = () => {
} catch (e) {
console.warn("Logout error, forcing full wipe:", e);
await AsyncStorage.clear();
- await supabase.auth.signOut();
}
};
diff --git a/README.md b/README.md
index 80cc6cfa61a48f74dd15ba78e639f849d4097b3b..2bab4698c523f08a3f25758043868d901a80c484 100644
--- a/README.md
+++ b/README.md
@@ -58,9 +58,7 @@ pinned: false
## 🌟 GSSoC '26 Contributor & Community Campaign
-We are extremely proud to be part of the **GirlScript Summer of Code (GSSoC) 2026**! To ensure high-quality contributions and maximum rewards for both developers and mentors, please review our official [GSSoC Mentorship Guide & Review Standard](MENTORSHIP.md).
-
-To support the project and get real-time open-source project updates, please make sure you participate in our community campaign:
+We are extremely proud to be part of the **GirlScript Summer of Code (GSSoC) 2026**! To support the project and get real-time open-source project updates, please make sure you participate in our community campaign:
diff --git a/backend/.env.example b/backend/.env.example
index cbb9e617c5b0f9de47207c90277f8aa76bdfb2db..f7247e9925ad9b8fdd63ba3a40ae7fc0ba3ede72 100644
--- a/backend/.env.example
+++ b/backend/.env.example
@@ -1,106 +1,18 @@
-# =============================================================================
-# HELPDESK.AI Backend — Environment Variable Reference
-# =============================================================================
-# Copy this file to `backend/.env` and fill in the values appropriate for your
-# environment. NEVER commit a populated `.env` file to source control.
-#
-# All variables are read via `os.environ.get(...)` / `os.getenv(...)` in the
-# backend codebase. Defaults shown below match the values used in code.
-# =============================================================================
-
-
-# -----------------------------------------------------------------------------
-# Supabase (Database + Auth + Storage)
-# -----------------------------------------------------------------------------
-# Required for: ticket persistence, RAG knowledge base, SLA escalation,
-# auto-close cron job, notification routing, company settings seeding.
-#
-# Service-role key is required for backend (bypasses RLS). NEVER expose this
-# key to the frontend — use the anon key on the client side instead.
-SUPABASE_URL=https://YOUR-PROJECT-REF.supabase.co
-SUPABASE_SERVICE_KEY=
-# Anon key — required for /auth/login cookie bridge (issue #130). Safe for backend proxy only.
-SUPABASE_ANON_KEY=
-# Some newer services (auto_close, notification_routing, sla_service)
-# also accept SUPABASE_SERVICE_ROLE_KEY as an alias. Set both for safety.
-SUPABASE_SERVICE_ROLE_KEY=
-
-
-# -----------------------------------------------------------------------------
-# Google Gemini (LLM)
-# -----------------------------------------------------------------------------
-# Required for: auto-resolve chat, summary generation, advanced classification.
-# If unset, GeminiService will initialize in disabled mode and downstream
-# endpoints that depend on it will return graceful fallback responses.
-GEMINI_API_KEY=
+# Supabase Configuration
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_SERVICE_KEY=your-service-key
+# Startup Mode
+# Set ALLOW_DEGRADED_STARTUP=1 to allow backend startup even if duplicate/RAG models fail to load
+# Useful for offline/dev environments where model downloads may not be available
+ALLOW_DEGRADED_STARTUP=0
-# -----------------------------------------------------------------------------
-# AI Model Artifacts
-# -----------------------------------------------------------------------------
-# Path to a local sentence-transformer model directory used by RAG and
-# duplicate detection. If unset, the services will attempt to download the
-# default model on first run (requires internet access).
+# Sentence Transformers Model Path
+# Provide a local path to the sentence-transformers model to avoid downloading from HuggingFace
+# If not set, model will be downloaded from HuggingFace (requires internet)
+# Example: ./models/all-MiniLM-L6-v2 or /opt/models/all-MiniLM-L6-v2
SENTENCE_TRANSFORMER_MODEL_PATH=
-
-# -----------------------------------------------------------------------------
-# Startup / Health-Check Behaviour
-# -----------------------------------------------------------------------------
-# Controls strict startup validation. When `0` (default), the backend will
-# REFUSE to start if core classifier assets are missing — this prevents the
-# silent "Unknown" classification fallback documented in ISSUE_DEBUG_FINDINGS.
-# Set to `1` only for local development without the full model bundle.
-ALLOW_DEGRADED_STARTUP=0
-
-# When `true`, startup will hard-fail if Supabase credentials are missing.
-# Default `false` allows the backend to run in "no-persistence" mode for tests.
+# Readiness Check
+# Set REQUIRE_SUPABASE=true to include Supabase configuration in the strict readiness gate
REQUIRE_SUPABASE=false
-
-# Slack Alerts
-SLACK_WEBHOOK_URL=https://hooks.slack.com/services/xxx/yyy/zzz
-
-# -----------------------------------------------------------------------------
-# Health-Check Probe (Docker / Kubernetes)
-# -----------------------------------------------------------------------------
-HEALTHCHECK_URL=http://127.0.0.1:7860/ready
-HEALTHCHECK_TIMEOUT_SECONDS=3
-
-
-# -----------------------------------------------------------------------------
-# SLA Escalation Background Worker
-# -----------------------------------------------------------------------------
-SLA_ESCALATION_ENABLED=true
-SLA_ESCALATION_INTERVAL_SECONDS=300
-
-
-# -----------------------------------------------------------------------------
-# Auto-Close Cron Job (Issue #41)
-# -----------------------------------------------------------------------------
-AUTO_CLOSE_ENABLED=true
-AUTO_CLOSE_DAYS=7
-# Standard 5-field cron expression. Default: 02:00 UTC every day.
-AUTO_CLOSE_CRON_SCHEDULE=0 2 * * *
-
-
-# -----------------------------------------------------------------------------
-# Notification Routing Middleware (Issue #41)
-# -----------------------------------------------------------------------------
-# Accepted values: debug, info, warning
-NOTIFICATION_ROUTING_LOG_LEVEL=info
-
-
-# -----------------------------------------------------------------------------
-# Generic Environment Flag
-# -----------------------------------------------------------------------------
-# Set to `development` to enable extra debug logging in some services.
-ENV=production
-
-
-# -----------------------------------------------------------------------------
-# Redis Inference Cache (Issue #131)
-# -----------------------------------------------------------------------------
-# When true, cache DistilBERT classifications and sentence-transformer embeddings.
-USE_REDIS_CACHE=false
-REDIS_URL=redis://127.0.0.1:6379/0
-REDIS_CACHE_TTL_SECONDS=3600
diff --git a/backend/Dockerfile b/backend/Dockerfile
index 3395cd97c41ef83ceee3747f2c48cf902091a6c4..79a8bbe08fc8811d5448ecaa66ab50738a8a04a0 100644
--- a/backend/Dockerfile
+++ b/backend/Dockerfile
@@ -1,40 +1,36 @@
-# syntax=docker/dockerfile:1
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
-FROM python:3.10-slim AS builder
+LABEL version="1.1.1" rebuild_trigger="2026-03-08-2032"
-WORKDIR /build
-RUN apt-get update && apt-get install -y --no-install-recommends \
+# Set the working directory to /app
+WORKDIR /app
+
+# Install system dependencies required for EasyOCR and OpenCV
+RUN apt-get update && apt-get install -y \
+ libgl1 \
+ libglib2.0-0 \
git \
&& rm -rf /var/lib/apt/lists/*
+# Copy the requirements file into the container
COPY requirements.txt .
-RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
-
-FROM python:3.10-slim AS runtime
-LABEL org.opencontainers.image.title="helpdesk-backend"
-LABEL org.opencontainers.image.description="HELPDESK.AI FastAPI backend (multi-stage)"
+# Install dependencies (no-cache-dir keeps the docker image smaller)
+RUN pip install --no-cache-dir -r requirements.txt
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
- libgl1 \
- libglib2.0-0 \
- && rm -rf /var/lib/apt/lists/* \
- && useradd --create-home --shell /usr/sbin/nologin appuser
-
-COPY --from=builder /install /usr/local
+# Copy all the remaining files into the container as a 'backend' directory
+# This allows absolute imports like 'from backend.services...' to work perfectly
COPY . /app/backend
-ENV PYTHONPATH=/app \
- PYTHONDONTWRITEBYTECODE=1 \
- PYTHONUNBUFFERED=1
+# Tell Python where to look for modules (so it can find the 'backend' folder)
+ENV PYTHONPATH=/app
+# Expose port 7860 (Hugging Face Spaces default)
EXPOSE 7860
HEALTHCHECK --interval=30s --timeout=5s --start-period=120s --retries=3 \
CMD ["python", "backend/healthcheck.py"]
-USER appuser
-
+# Run the FastAPI server via Uvicorn
CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]
diff --git a/backend/auth/crypto.py b/backend/auth/crypto.py
index a868ffa4e927ce737c19621d5a846b38513a971c..aa355c6acf1c4fd3e593ea35ca4c9565d36af153 100644
--- a/backend/auth/crypto.py
+++ b/backend/auth/crypto.py
@@ -1,218 +1,98 @@
import os
-import base64
-import logging
import hashlib
-from typing import Any
-
-# Configure logger
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.WARNING)
-
-if not logger.handlers:
- handler = logging.StreamHandler()
- formatter = logging.Formatter("[Crypto] %(asctime)s - %(levelname)s - %(message)s")
- handler.setFormatter(formatter)
- logger.addHandler(handler)
-
-CRYPTOGRAPHY_AVAILABLE = False
-_aesgcm = None
-ENCRYPTION_ENABLED = False
-
-try:
- from cryptography.hazmat.primitives.ciphers.aead import AESGCM
- CRYPTOGRAPHY_AVAILABLE = True
-except ImportError:
- logger.warning("The 'cryptography' library is not available. Running with database encryption disabled.")
-
-# Key Parsing logic: supporting urlsafe-b64, hex, and SHA-256 stretching
-def derive_cryptographic_key(raw_key: str | None) -> bytes | None:
- if not raw_key:
- return None
-
- # 1. Try URL-safe Base64 decode
- try:
- # Pad string appropriately if needed
- padded = raw_key + "=" * ((4 - len(raw_key) % 4) % 4)
- decoded = base64.urlsafe_b64decode(padded.encode('utf-8'))
- if len(decoded) == 32:
- return decoded
- except Exception:
- pass
-
- # 2. Try hex decode
- try:
- decoded = bytes.fromhex(raw_key)
- if len(decoded) == 32:
- return decoded
- except Exception:
- pass
-
- # 3. Fall back to SHA-256 stretch
- return hashlib.sha256(raw_key.encode('utf-8')).digest()
-
-
-# Initialize Key and AESGCM instance
-if CRYPTOGRAPHY_AVAILABLE:
- SECRET_KEY_ENV_VAR = "DB_ENCRYPTION_SECRET_KEY"
- raw_secret_key = os.environ.get(SECRET_KEY_ENV_VAR)
-
- if raw_secret_key:
- try:
- key_bytes = derive_cryptographic_key(raw_secret_key)
- if key_bytes:
- _aesgcm = AESGCM(key_bytes)
- ENCRYPTION_ENABLED = True
- logger.info("Database encryption key loaded and active.")
- else:
- logger.warning("Could not derive key from DB_ENCRYPTION_SECRET_KEY. Database encryption disabled.")
- except Exception as e:
- logger.warning(f"Failed to initialize AESGCM: {e}. Database encryption disabled.")
- else:
- logger.warning("DB_ENCRYPTION_SECRET_KEY is not set in environment. Running with database encryption disabled.")
-
-# Tag prefix for identifying encrypted data
-PREFIX = "enc:v1:"
-
-def encrypt_value(value: str) -> str:
- """Encrypt a string value using AES-256-GCM. Returns 'enc:v1:
'."""
- if not ENCRYPTION_ENABLED or _aesgcm is None:
- return value
- if not isinstance(value, str):
- return value
- # Double-encryption protection: if already encrypted, return as-is
- if value.startswith(PREFIX):
- return value
-
+import base64
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+# Initialize AESGCM with 32-byte key derived from secret key
+SECRET_KEY = os.environ.get("DB_ENCRYPTION_SECRET_KEY")
+
+_cipher = None
+if SECRET_KEY:
+ # Hash secret key to ensure it is exactly 32 bytes (256 bits)
+ key_bytes = hashlib.sha256(SECRET_KEY.encode()).digest()
+ _cipher = AESGCM(key_bytes)
+else:
+ print("[WARNING] DB_ENCRYPTION_SECRET_KEY not set. Data encryption is disabled (degraded mode).")
+
+def encrypt(plain_text: str) -> str:
+ """Encrypt plain text using AES-256 GCM and return base64 encoded string."""
+ if not _cipher or not plain_text:
+ return plain_text
try:
- # Generate 12-byte secure random nonce
+ # Generate 12-byte random nonce for GCM
nonce = os.urandom(12)
- plaintext_bytes = value.encode('utf-8')
- # Encrypt (combines ciphertext and tag automatically in cryptography's AESGCM)
- ciphertext = _aesgcm.encrypt(nonce, plaintext_bytes, None)
- # Store nonce + ciphertext together
- payload = nonce + ciphertext
- encoded = base64.b64encode(payload).decode('utf-8')
- return f"{PREFIX}{encoded}"
+ encrypted_bytes = _cipher.encrypt(nonce, plain_text.encode(), None)
+ # Combine nonce and ciphertext and encode as base64
+ combined = nonce + encrypted_bytes
+ return base64.b64encode(combined).decode('utf-8')
except Exception as e:
- logger.error(f"Encryption failed: {e}")
- return value
+ print(f"[Crypto Error] Encryption failed: {e}")
+ return plain_text
-def decrypt_value(value: str) -> str:
- """Decrypt a string value that starts with 'enc:v1:'."""
- if not ENCRYPTION_ENABLED or _aesgcm is None:
- return value
- if not isinstance(value, str):
- return value
- # Graceful pass-through for legacy/plaintext rows
- if not value.startswith(PREFIX):
- return value
-
+def decrypt(cipher_text: str) -> str:
+ """Decrypt base64 encoded ciphertext using AES-256 GCM and return plain text."""
+ if not _cipher or not cipher_text:
+ return cipher_text
try:
- encoded_str = value[len(PREFIX):]
- payload = base64.b64decode(encoded_str)
- if len(payload) < 12:
- return value
- nonce = payload[:12]
- ciphertext = payload[12:]
- decrypted_bytes = _aesgcm.decrypt(nonce, ciphertext, None)
+ # Check if cipher_text looks like base64
+ try:
+ combined = base64.b64decode(cipher_text.encode('utf-8'))
+ except Exception:
+ return cipher_text # Return as-is if not valid base64
+
+ if len(combined) < 12:
+ return cipher_text # Not enough bytes for nonce
+
+ nonce = combined[:12]
+ ciphertext = combined[12:]
+ decrypted_bytes = _cipher.decrypt(nonce, ciphertext, None)
return decrypted_bytes.decode('utf-8')
except Exception as e:
- logger.error(f"Decryption failed: {e}")
- return value
+ # If decryption fails, it might be unencrypted plaintext (graceful degrade for old records)
+ return cipher_text
-# ORM Payload Processing Helpers
-TARGET_FIELDS = {"contact_email", "description", "raw_text"}
-
-def encrypt_row(row: dict) -> dict:
- if not isinstance(row, dict):
- return row
- new_row = dict(row)
- for field in TARGET_FIELDS:
- if field in new_row and new_row[field] is not None:
- new_row[field] = encrypt_value(str(new_row[field]))
- return new_row
-
-def decrypt_row(row: dict) -> dict:
- if not isinstance(row, dict):
- return row
- new_row = dict(row)
- for field in TARGET_FIELDS:
- if field in new_row and new_row[field] is not None:
- new_row[field] = decrypt_value(str(new_row[field]))
- return new_row
-
-def encrypt_payload(payload: Any) -> Any:
- if isinstance(payload, list):
- return [encrypt_row(row) for row in payload]
- elif isinstance(payload, dict):
- return encrypt_row(payload)
- return payload
-
-def decrypt_payload(payload: Any) -> Any:
- if isinstance(payload, list):
- return [decrypt_row(row) for row in payload]
- elif isinstance(payload, dict):
- return decrypt_row(payload)
- return payload
-
-# Transparent client query wrapper proxy
-class WrappedRequestBuilder:
- def __init__(self, builder: Any, table_name: str):
- object.__setattr__(self, "_builder", builder)
- object.__setattr__(self, "_table_name", table_name)
-
- def insert(self, json: Any, *args, **kwargs) -> "WrappedRequestBuilder":
- if self._table_name == "tickets":
- json = encrypt_payload(json)
- res = self._builder.insert(json, *args, **kwargs)
- return WrappedRequestBuilder(res, self._table_name)
-
- def update(self, json: Any, *args, **kwargs) -> "WrappedRequestBuilder":
- if self._table_name == "tickets":
- json = encrypt_payload(json)
- res = self._builder.update(json, *args, **kwargs)
- return WrappedRequestBuilder(res, self._table_name)
-
- def execute(self, *args, **kwargs) -> Any:
- res = self._builder.execute(*args, **kwargs)
- if self._table_name == "tickets" and res and hasattr(res, "data"):
- res.data = decrypt_payload(res.data)
- return res
-
- def __getattr__(self, name: str) -> Any:
- attr = getattr(self._builder, name)
- if callable(attr):
- def wrapper(*args, **kwargs):
- res = attr(*args, **kwargs)
- if res is self._builder:
- return self
- if hasattr(res, "execute") or hasattr(res, "table") or hasattr(res, "insert"):
- return WrappedRequestBuilder(res, self._table_name)
- return res
- return wrapper
- return attr
-
- def __setattr__(self, name: str, value: Any) -> None:
- setattr(self._builder, name, value)
-
-
-def wrap_client(client: Any) -> Any:
- """Wraps a Supabase client's table method for transparent tickets encryption."""
- if client is None:
- return None
-
- # Avoid double wrapping
- if hasattr(client, "_wrapped_by_crypto"):
- return client
-
- original_table = client.table
-
- def wrapped_table(table_name: str, *args, **kwargs) -> Any:
- builder = original_table(table_name, *args, **kwargs)
- if table_name == "tickets":
- return WrappedRequestBuilder(builder, table_name)
- return builder
-
- client.table = wrapped_table
- client._wrapped_by_crypto = True
- return client
+def apply_db_encryption_patch():
+ """Apply transparent monkeypatch to Postgrest/Supabase client execute method for 'tickets' table."""
+ try:
+ from postgrest._sync.request_builder import SyncQueryRequestBuilder
+
+ _original_execute = SyncQueryRequestBuilder.execute
+
+ def custom_execute(self):
+ path_str = getattr(self.request.path, "path", "")
+ table_name = path_str.split('/')[-1]
+
+ if table_name == "tickets":
+ payload = self.request.json
+ if isinstance(payload, dict):
+ for field in ["contact_email", "description", "raw_text"]:
+ if field in payload and payload[field] is not None:
+ payload[field] = encrypt(str(payload[field]))
+ elif isinstance(payload, list):
+ for item in payload:
+ if isinstance(item, dict):
+ for field in ["contact_email", "description", "raw_text"]:
+ if field in item and item[field] is not None:
+ item[field] = encrypt(str(item[field]))
+
+ res = _original_execute(self)
+
+ if table_name == "tickets" and res and hasattr(res, "data"):
+ data = res.data
+ if isinstance(data, dict):
+ for field in ["contact_email", "description", "raw_text"]:
+ if field in data and data[field] is not None:
+ data[field] = decrypt(str(data[field]))
+ elif isinstance(data, list):
+ for item in data:
+ if isinstance(item, dict):
+ for field in ["contact_email", "description", "raw_text"]:
+ if field in item and item[field] is not None:
+ item[field] = decrypt(str(item[field]))
+
+ return res
+
+ SyncQueryRequestBuilder.execute = custom_execute
+ print("[Crypto] Supabase database encryption patch applied successfully.")
+ except Exception as e:
+ print(f"[Crypto WARNING] Failed to apply database encryption patch: {e}")
diff --git a/backend/main.py b/backend/main.py
index 55d01b7e9107787f7238a2f76b03fd37c00b3ab2..e5e0fc6140368c6e2fbe0b95a29bcfe79a166b35 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -8,7 +8,6 @@ import os
import sys
import uuid
import json
-import re
import datetime
import traceback
import warnings
@@ -20,13 +19,13 @@ from contextlib import asynccontextmanager
warnings.filterwarnings("ignore", message="'pin_memory'")
# HF Rebuild Trigger: 2026-03-08-2030
-from fastapi import FastAPI, Depends, HTTPException, Request, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, Depends, Header, HTTPException, Request, Response
from slowapi import Limiter, _rate_limit_exceeded_handler
+from prometheus_client import generate_latest, CONTENT_TYPE_LATEST
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded
from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse, JSONResponse, Response, StreamingResponse
-from prometheus_client import CONTENT_TYPE_LATEST, generate_latest
+from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
from fastapi.encoders import jsonable_encoder
import asyncio
from pathlib import Path
@@ -37,12 +36,13 @@ from dotenv import load_dotenv
env_path = Path(__file__).parent / '.env'
load_dotenv(dotenv_path=env_path)
-# CI smoke tests allow degraded startup so the app can import without heavy ML assets.
-ALLOW_DEGRADED_STARTUP = os.environ.get("ALLOW_DEGRADED_STARTUP", "0") == "1"
-
+# Apply database encryption for PII fields
+try:
+ from backend.auth.crypto import apply_db_encryption_patch
+ apply_db_encryption_patch()
+except Exception as e:
+ print(f"[WARNING] Database encryption patch initialization failed: {e}")
-def _startup_fatal(message: str) -> None:
- print(f"[Startup-FATAL] {message}")
# Initialize Supabase Client (Service Role for backend bypass)
try:
@@ -53,8 +53,7 @@ try:
print("[ERROR] SUPABASE_URL or SUPABASE_SERVICE_KEY not set in backend/.env")
supabase = None
else:
- from backend.auth.crypto import wrap_client
- supabase = wrap_client(create_client(url, key))
+ supabase = create_client(url, key)
except (ImportError, Exception) as e:
print(f"[WARNING] Supabase initialization failed: {e}")
supabase = None
@@ -66,170 +65,17 @@ sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")
from backend.services.classifier_service import ClassifierService
from backend.services.classifier_v2 import classifier_v2
from backend.services.classifier_v3 import classifier_v3 # V3 Power Model
-from backend.services.audit_service import AuditLogService, AuditLogAccessError
-from backend.services.onnx_service import onnx_classifier
from backend.services.ner_service import NERService
from backend.services.duplicate_service import DuplicateService
-from backend.services.semantic_duplicate_service import SemanticDuplicateService
from backend.services.rag_service import RagService
-from backend.services.spam_service import SpamService
-from backend.services.sla_engine import SLAEngine, compute_sla_breach_at, get_sla_policy
-from backend.services.redis_cache import redis_cache
-from backend.auth_cookie import router as auth_cookie_router, get_current_user # noqa: F401
-
-
-# ---------------------------------------------------------------------------
-# WebSocket Connection Manager — real-time ticket dashboards
-# ---------------------------------------------------------------------------
-
-HEARTBEAT_INTERVAL = 30 # seconds between ping broadcasts
-HEARTBEAT_TIMEOUT = 10 # seconds to wait for a pong before disconnect
-
-
-class ConnectionManager:
- """Tracks active WebSocket connections grouped by ``company_id``.
-
- Thread-safe for concurrent connect/disconnect calls from multiple
- ASGI workers (single-process via ``asyncio.Lock``).
- """
-
- def __init__(self) -> None:
- self._connections: dict[str, set[WebSocket]] = {}
- self._lock = asyncio.Lock()
-
- async def connect(self, company_id: str, ws: WebSocket) -> None:
- """Accept a new WebSocket and register it under ``company_id``."""
- await ws.accept()
- async with self._lock:
- self._connections.setdefault(company_id, set()).add(ws)
-
- async def disconnect(self, company_id: str, ws: WebSocket) -> None:
- """Remove a WebSocket from the pool."""
- async with self._lock:
- connections = self._connections.get(company_id)
- if connections:
- connections.discard(ws)
- # Clean up empty company groups
- if not connections:
- del self._connections[company_id]
-
- async def broadcast(self, company_id: str, message: dict) -> int:
- """Send a JSON message to every client in a company group.
-
- Returns:
- Number of successfully sent messages.
- """
- payload = json.dumps(message, default=str)
- sent = 0
- async with self._lock:
- connections = set(self._connections.get(company_id, []))
-
- for ws in connections:
- try:
- await ws.send_text(payload)
- sent += 1
- except Exception:
- await self.disconnect(company_id, ws)
- return sent
-
- async def broadcast_all(self, message: dict) -> int:
- """Send a JSON message to **all** connected clients."""
- payload = json.dumps(message, default=str)
- sent = 0
- async with self._lock:
- all_connections = {
- ws for group in self._connections.values() for ws in group
- }
-
- for ws in all_connections:
- try:
- await ws.send_text(payload)
- sent += 1
- except Exception:
- pass
- return sent
-
- async def ping_all(self) -> None:
- """Send a ``{"type": "ping"}`` heartbeat to every connection.
-
- Connections that fail to receive the ping are removed.
- """
- async with self._lock:
- # Snapshot all connections under lock so iteration is safe
- snapshot = {
- cid: set(ws_set) for cid, ws_set in self._connections.items()
- }
-
- for cid, ws_set in snapshot.items():
- for ws in list(ws_set):
- try:
- await ws.send_json({"type": "ping"})
- except Exception:
- await self.disconnect(cid, ws)
-
- @property
- def active_count(self) -> int:
- """Total number of connected clients across all companies."""
- return sum(len(ws_set) for ws_set in self._connections.values())
-
-
-# Singleton — reused across lifespan and WebSocket route
-connection_manager = ConnectionManager()
-
-
-async def _heartbeat_loop() -> None:
- """Background task: broadcast ping every ``HEARTBEAT_INTERVAL`` seconds.
-
- Clients that fail the ping are disconnected automatically by
- ``ConnectionManager.ping_all()``.
- """
- while True:
- await asyncio.sleep(HEARTBEAT_INTERVAL)
- try:
- await connection_manager.ping_all()
- count = connection_manager.active_count
- if count:
- print(f"[WS] Heartbeat sent to {count} active connection(s)")
- except Exception as exc:
- print(f"[WS] Heartbeat error: {exc}")
-
-
-# ---------------------------------------------------------------------------
-# SLA helper functions (must be defined before save_ticket uses them)
-# ---------------------------------------------------------------------------
-
-def calculate_sla_breach_at(priority: str) -> datetime.datetime:
- """Return the UTC datetime by which the ticket must be resolved."""
- hours_map = {"critical": 2, "high": 8, "medium": 24, "low": 72}
- hours = hours_map.get(str(priority).lower().strip(), 72)
- return datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=hours)
-
-
-def calculate_sla_response_at(priority: str) -> datetime.datetime:
- """Return the UTC datetime by which the ticket must receive a first response."""
- hours_map = {"critical": 0.5, "high": 2, "medium": 6, "low": 18}
- hours = hours_map.get(str(priority).lower().strip(), 6)
- return datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=hours)
-
-
-def classify_sla_status(sla_breach_at: str | None) -> str:
- """Return 'BREACHED', 'WARNING', or 'ACTIVE' based on the breach time."""
- if not sla_breach_at:
- return "ACTIVE"
- try:
- clean_val = str(sla_breach_at).replace("Z", "+00:00")
- deadline = datetime.datetime.fromisoformat(clean_val)
- if deadline.tzinfo is None:
- deadline = deadline.replace(tzinfo=datetime.timezone.utc)
- except Exception:
- return "ACTIVE"
-
- now = datetime.datetime.now(datetime.timezone.utc)
- if deadline <= now:
- return "BREACHED"
- if deadline - now <= datetime.timedelta(hours=1):
- return "WARNING"
- return "ACTIVE"
+from backend.services.sla_service import (
+ calculate_sla_breach_at,
+ calculate_sla_response_at,
+ classify_sla_status,
+ load as load_sla_service,
+ run_sla_escalation_loop,
+)
+from backend.services.spam_detector_service import analyze_spam_phishing
# ---------------------------------------------------------------------------
@@ -278,62 +124,13 @@ def detect_semantic_duplicate(text: str, *, company_id: str | None, threshold: f
duplicate_result["parent_ticket_id"] = duplicate_result.get("duplicate_ticket_id")
duplicate_result["is_potential_duplicate"] = duplicate_result.get("is_duplicate", False)
return duplicate_result
-
-
-def classify_ticket_text(text: str) -> dict:
- """Run the local classifier cascade with ONNX as the offline fallback path."""
- cached = redis_cache.get_classification(text)
- if cached:
- return cached
-
- result = _classify_ticket_text_uncached(text)
- redis_cache.set_classification(text, result)
- return result
-
-
-def _classify_ticket_text_uncached(text: str) -> dict:
- try:
- classification_v3_res = classifier_v3.predict(text)
- if "error" not in classification_v3_res:
- cat = classification_v3_res.get("Category", {}).get("prediction", "Unknown")
- sub = classification_v3_res.get("Subcategory", {}).get("prediction", "Unknown")
- pri = classification_v3_res.get("priority", {}).get("prediction", "Medium")
- conf = classification_v3_res.get("Category", {}).get("confidence", 0.0)
-
- from backend.services.classifier_service import TEAM_MAP, AUTO_RESOLVE_SUBS
- return {
- "category": cat,
- "subcategory": sub,
- "priority": pri,
- "auto_resolve": sub in AUTO_RESOLVE_SUBS,
- "assigned_team": TEAM_MAP.get(cat, "General Support"),
- "confidence": float(conf),
- }
- except Exception:
- traceback.print_exc()
-
- try:
- onnx_result = onnx_classifier.predict(text)
- if onnx_result:
- return onnx_result
- except Exception as error:
- print(f"[ONNX] Fallback classification skipped: {error}")
-
- try:
- return classifier_service.predict(text)
- except Exception:
- traceback.print_exc()
- return {
- "category": "Unknown", "subcategory": "Unknown", "priority": "Medium",
- "auto_resolve": False, "assigned_team": "General Support", "confidence": 0.0,
- }
-
class TicketRequest(BaseModel):
text: str
image_base64: str = ""
image_text: str = "" # Keep for backward compatibility
user_id: str | None = None
company: str | None = None
+ company_id: str | None = None
image_url: str | None = None
confidence_threshold: float = 0.20
duplicate_sensitivity: float = 0.85
@@ -353,6 +150,10 @@ class TicketSaveRequest(BaseModel):
image_url: str | None = None
company: str | None = None
company_id: str | None = None
+ description_vector: list[float] | None = None
+ is_potential_duplicate: bool = False
+ parent_ticket_id: str | None = None
+ sla_response_due_at: str | None = None
sla_breach_at: str
sla_status: str | None = None
escalation_level: int = 0
@@ -368,6 +169,8 @@ class TicketSaveRequest(BaseModel):
class DuplicateInfo(BaseModel):
is_duplicate: bool
duplicate_ticket_id: str | None = None
+ parent_ticket_id: str | None = None
+ is_potential_duplicate: bool = False
similarity: float = 0.0
@@ -377,14 +180,6 @@ class EntityInfo(BaseModel):
confidence: float
-class SpamCheck(BaseModel):
- is_spam: bool = False
- risk_score: float = 0.0
- reasons: list[str] = []
- suspicious_urls: list[str] = []
- matched_keywords: list[str] = []
-
-
class TicketResponse(BaseModel):
id: str | int | None = None
ticket_id: str | None = None
@@ -397,6 +192,8 @@ class TicketResponse(BaseModel):
entities: list[EntityInfo]
duplicate_ticket: DuplicateInfo
confidence: float
+ is_potential_duplicate: bool = False
+ parent_ticket_id: str | None = None
needs_review: bool = False
reasoning: str = ""
decision_factors: list[str] = []
@@ -406,11 +203,7 @@ class TicketResponse(BaseModel):
timeline: dict = {} # Map of step_name: timestamp
env_metadata: dict = {} # IP, Hostname, Browser/OS
sla_breach_at: str | None = None
- original_text: str | None = None
- source_language: str = "en"
- source_language_name: str = "English"
- was_translated: bool = False
- spam_check: SpamCheck = SpamCheck()
+ spam_analysis: dict | None = None
version: str = "2.1.0-Neural-Diagnostic"
@@ -438,24 +231,6 @@ class TicketRecord(BaseModel):
timeline: dict = {} # Milestones: created, analyzed, triaged, routed, in_progress, resolved
-class AuditLogProfile(BaseModel):
- full_name: str | None = None
- email: str | None = None
- profile_picture: str | None = None
-
-
-class AuditLogRecord(BaseModel):
- id: str
- ticket_id: str
- company_id: str
- performed_by: str | None = None
- action: str
- old_value: dict | list | str | None = None
- new_value: dict | list | str | None = None
- created_at: str
- performed_by_profile: AuditLogProfile | None = None
-
-
# --- In-Memory Database (to be replaced with SQL later) ---
TICKETS_DB: list[TicketRecord] = []
@@ -478,9 +253,6 @@ classifier_service = ClassifierService()
ner_service = NERService()
duplicate_service = DuplicateService()
rag_service = RagService()
-spam_service = SpamService()
-sla_engine = SLAEngine(supabase_client=None) # Will be reassigned after supabase init
-semantic_dupe_service = SemanticDuplicateService(supabase_client=None) # wired in lifespan
try:
from backend.services.gemini_service import GeminiService
@@ -494,82 +266,6 @@ try:
except ImportError:
ocr_service = None
-LANGUAGE_NAMES = {
- "en": "English",
- "es": "Spanish",
- "de": "German",
- "hi": "Hindi",
- "fr": "French",
- "it": "Italian",
- "pt": "Portuguese",
- "ja": "Japanese",
- "ko": "Korean",
- "zh": "Chinese",
- "ar": "Arabic",
- "ru": "Russian",
-}
-
-def _heuristic_language_detection(text: str) -> dict:
- sample = (text or "").strip()
- if not sample:
- return {"code": "en", "name": "English"}
- ascii_chars = sum(1 for c in sample if ord(c) < 128)
- ratio = ascii_chars / max(len(sample), 1)
- if ratio > 0.97:
- return {"code": "en", "name": "English"}
- return {"code": "unknown", "name": "Unknown"}
-
-def detect_and_translate_ticket_text(text: str) -> dict:
- original_text = (text or "").strip()
- if not original_text:
- return {
- "text_for_analysis": text or "",
- "source_language": "en",
- "source_language_name": "English",
- "was_translated": False,
- "original_text": "",
- "metadata":{},
- }
-
- detected = _heuristic_language_detection(original_text)
- if gemini_service and getattr(gemini_service, "_initialized", False):
- detected = gemini_service.detect_language(original_text)
-
- source_code = str(detected.get("code", "en")).lower()
- source_name = detected.get("name") or LANGUAGE_NAMES.get(source_code, source_code.upper())
- if source_code in ("en", "eng"):
- return {
- "text_for_analysis": original_text,
- "source_language": "en",
- "source_language_name": "English",
- "was_translated": False,
- "original_text": original_text,
- "metadata":{},
- }
-
- translated_text = original_text
- if gemini_service and getattr(gemini_service, "_initialized", False):
- translated_text = gemini_service.translate_to_english(original_text, source_name)
-
- if not translated_text or translated_text.strip() == original_text:
- return {
- "text_for_analysis": original_text,
- "source_language": source_code,
- "source_language_name": source_name,
- "was_translated": False,
- "original_text": original_text,
- "metadata":{},
- }
-
- return {
- "text_for_analysis": translated_text.strip(),
- "source_language": source_code,
- "source_language_name": source_name,
- "was_translated": True,
- "original_text": original_text,
- "metadata":{},
- }
-
# ---------------------------------------------------------------------------
# Lifespan (startup / shutdown)
@@ -578,17 +274,13 @@ def detect_and_translate_ticket_text(text: str) -> dict:
async def lifespan(app: FastAPI):
"""Load all models at startup."""
print("[Startup] Loading AI models ...")
- try:
- redis_cache.connect()
- except Exception as e:
- print(f"[WARNING] Redis cache not available: {e}")
try:
classifier_service.load()
- except FileNotFoundError as e:
+ except Exception as e:
print(f"[WARNING] Classifier not loaded: {e}")
try:
ner_service.load()
- except FileNotFoundError as e:
+ except Exception as e:
print(f"[WARNING] NER not loaded: {e}")
try:
duplicate_service.load()
@@ -598,51 +290,50 @@ async def lifespan(app: FastAPI):
rag_service.load()
except Exception as e:
print(f"[WARNING] RAG service not loaded: {e}")
- try:
- onnx_classifier.load()
- except Exception as e:
- print(f"[WARNING] ONNX classifier fallback not loaded: {e}")
if gemini_service:
print(f"[Startup] Gemini Service: {'Initialized' if gemini_service._initialized else 'FAILED (Key missing or SDK error)'}")
else:
print("[Startup] Gemini Service: NOT LOADED (Import failed)")
- # Wire services with supabase client
- sla_engine.supabase = supabase
- semantic_dupe_service.supabase = supabase
-
- # Pre-load embedding model so first ticket save is fast
- try:
- semantic_dupe_service.load()
- print(f"[Startup] Semantic Duplicate Detection: {'Loaded' if semantic_dupe_service._loaded else 'Failed (model missing)'}")
- except Exception as e:
- print(f"[Startup] Semantic Duplicate Detection load error: {e}")
- print(f"[Startup] SLA Engine: {'Initialized' if supabase else 'Offline (no DB)'}")
-
- # Start background SLA checker as an async task (every 5 minutes)
- if supabase:
- from backend.sla_checker import sla_checker_loop_async
- asyncio.create_task(sla_checker_loop_async(supabase, interval_seconds=300))
- print("[Startup] SLA background checker started (interval=300s)")
-
print("[Startup] Classifier V2 Shadow: Ready.")
- print(f"[Startup] ONNX MiniLM Fallback: {'READY' if getattr(onnx_classifier, '_loaded', False) else 'DEGRADED (artifacts missing)'}")
print("[Startup] Ready.")
+ # Strict health checks: fail loudly when core model assets are unavailable.
+ # Set ALLOW_DEGRADED_STARTUP=1 to permit degraded startup for local/dev convenience.
+ try:
+ strict_mode = os.environ.get("ALLOW_DEGRADED_STARTUP", "0") != "1"
+ except Exception:
+ strict_mode = True
- # Start WebSocket heartbeat background loop
- heartbeat_task = asyncio.create_task(_heartbeat_loop())
- print("[Startup] WebSocket heartbeat loop started (interval=30s).")
+ classifier_loaded_flag = getattr(classifier_service, "_loaded", False)
+ ner_loaded_flag = getattr(ner_service, "_loaded", False)
- yield
+ if strict_mode and not classifier_loaded_flag:
+ raise RuntimeError("[Startup-FATAL] Classifier assets not loaded. Set ALLOW_DEGRADED_STARTUP=1 to bypass.")
- # Cancel background tasks on shutdown
- heartbeat_task.cancel()
+ sla_task = None
try:
- await heartbeat_task
- except asyncio.CancelledError:
- pass
- print("[Shutdown] Cleaning up ...")
+ if supabase and os.environ.get("SLA_ESCALATION_ENABLED", "true").lower() == "true":
+ notification_router = None
+ try:
+ from backend.services.notification_routing import load as load_notification_router
+ notification_router = load_notification_router()
+ except Exception as e:
+ print(f"[WARNING] Notification router not loaded for SLA service: {e}")
+ sla_service = load_sla_service(supabase, notification_router)
+ interval = int(os.environ.get("SLA_ESCALATION_INTERVAL_SECONDS", "300"))
+ sla_task = asyncio.create_task(run_sla_escalation_loop(sla_service, interval_seconds=interval))
+ print(f"[Startup] SLA escalation loop enabled ({interval}s interval).")
+
+ yield
+ finally:
+ if sla_task:
+ sla_task.cancel()
+ try:
+ await sla_task
+ except asyncio.CancelledError:
+ pass
+ print("[Shutdown] Cleaning up ...")
# ---------------------------------------------------------------------------
@@ -673,8 +364,6 @@ app.add_middleware(
allow_headers=["*"],
)
-app.include_router(auth_cookie_router)
-
# ---------------------------------------------------------------------------
# Root & Health check
@@ -761,6 +450,17 @@ async def root():
"""
+async def verify_metrics_token(x_metrics_token: str | None = Header(default=None)):
+ expected_token = os.environ.get("METRICS_TOKEN")
+ if expected_token and x_metrics_token != expected_token:
+ raise HTTPException(status_code=403, detail="Forbidden")
+
+
+@app.get("/metrics", dependencies=[Depends(verify_metrics_token)])
+def metrics():
+ return Response(content=generate_latest(), media_type=CONTENT_TYPE_LATEST)
+
+
@app.get("/health", response_model=HealthResponse)
async def health_check():
return HealthResponse(
@@ -773,18 +473,29 @@ async def health_check():
@app.get("/ready", response_model=ReadinessResponse)
async def readiness_check():
require_supabase = os.environ.get("REQUIRE_SUPABASE", "false").lower() == "true"
+ allow_degraded = os.environ.get("ALLOW_DEGRADED_STARTUP", "0") == "1"
+
checks = {
"api": True,
"classifier_loaded": classifier_service._loaded,
"ner_loaded": ner_service._loaded,
- "duplicate_index_loaded": duplicate_service._loaded,
- "rag_loaded": rag_service._loaded,
+ "duplicate_index_loaded": duplicate_service.is_available(),
+ "rag_loaded": rag_service.is_available(),
}
if require_supabase:
checks["supabase_configured"] = supabase is not None
- if all(checks.values()):
- return ReadinessResponse(status="ready", checks=checks)
+ # In degraded mode, duplicate and RAG services are optional
+ if allow_degraded:
+ required_checks = {k: v for k, v in checks.items() if k not in ["duplicate_index_loaded", "rag_loaded"]}
+ all_required_pass = all(required_checks.values())
+
+ if all_required_pass:
+ return ReadinessResponse(status="ready", checks=checks)
+ else:
+ # Strict mode: all checks must pass
+ if all(checks.values()):
+ return ReadinessResponse(status="ready", checks=checks)
return JSONResponse(
status_code=503,
@@ -912,66 +623,44 @@ async def log_correction(raw_request: Request):
# ---------------------------------------------------------------------------
# Ticket operations (Now via Supabase)
# ---------------------------------------------------------------------------
-MASTER_TICKET_ROLES = {"master_admin", "super_admin", "superadmin", "owner"}
-
-
-def _get_auth_user_id(user: dict) -> str:
- user_id = user.get("id") or user.get("sub") or user.get("user_id")
- if not user_id:
- raise HTTPException(status_code=401, detail="Invalid authenticated user")
- return str(user_id)
-
-
-def _get_authenticated_profile(user: dict) -> dict:
- user_id = _get_auth_user_id(user)
- res = (
- supabase.table("profiles")
- .select("id, company_id, company, role")
- .eq("id", user_id)
- .single()
- .execute()
- )
- if not res.data:
- raise HTTPException(status_code=403, detail="User profile not found")
- return res.data
-
-
-def _is_master_ticket_reader(profile: dict) -> bool:
- role = str(profile.get("role") or "").lower()
- return role in MASTER_TICKET_ROLES
-
-
-def _ticket_company_scope(profile: dict, requested_company_id: str | None = None) -> str | None:
- if _is_master_ticket_reader(profile):
- return requested_company_id
-
- company_id = profile.get("company_id")
- if not company_id:
- raise HTTPException(status_code=403, detail="User tenant is not configured")
- if requested_company_id and requested_company_id != company_id:
- raise HTTPException(status_code=403, detail="User not authorized for this tenant")
- return str(company_id)
-
-
@app.get("/tickets")
-async def get_tickets(
- company_id: str | None = None,
- current_user: dict = Depends(get_current_user),
-):
+async def get_tickets(company_id: str | None = None):
"""Fetch persistent tickets from Supabase."""
if not supabase:
raise HTTPException(status_code=500, detail="Database connection not initialized")
-
- profile = _get_authenticated_profile(current_user)
- company_scope = _ticket_company_scope(profile, company_id)
query = supabase.table("tickets").select("*").order("created_at", desc=True)
- if company_scope:
- query = query.eq("company_id", company_scope)
+ if company_id:
+ query = query.eq("company_id", company_id)
res = query.execute()
return res.data
+@app.get("/tickets/search")
+async def search_tickets(q: str | None = None, company_id: str | None = None, limit: int = 50, offset: int = 0):
+ """Search tickets using tenant-safe full-text search."""
+ if not supabase:
+ raise HTTPException(status_code=500, detail="Database connection not initialized")
+
+ if not q:
+ raise HTTPException(status_code=400, detail="Search query is required")
+ if not company_id:
+ raise HTTPException(status_code=400, detail="company_id is required for tenant-safe search")
+
+ try:
+ result = supabase.rpc(
+ "search_tickets",
+ {
+ "query_text": q,
+ "company_id": company_id,
+ "limit_rows": limit,
+ "offset_rows": offset,
+ },
+ ).execute()
+ return result.data or []
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Search failed: {e}")
+
@app.post("/tickets/save")
async def save_ticket(request_body: TicketSaveRequest):
"""
@@ -982,80 +671,64 @@ async def save_ticket(request_body: TicketSaveRequest):
raise HTTPException(status_code=500, detail="Supabase connection not initialized.")
logger = logging.getLogger(__name__)
- final_data = request_body.model_dump()
- original_subject = final_data.get("subject", "") or ""
- original_description = final_data.get("description", "") or ""
-
- # Detect language and translate subject/description into English before downstream routing/indexing.
- translation_probe_text = (original_description.strip() or original_subject.strip())
- translation_ctx = detect_and_translate_ticket_text(translation_probe_text)
- metadata = final_data.get("metadata") or {}
- if translation_ctx["was_translated"]:
- translated_subject = gemini_service.translate_to_english(original_subject, translation_ctx["source_language_name"]) if original_subject else original_subject
- translated_description = gemini_service.translate_to_english(original_description, translation_ctx["source_language_name"]) if original_description else original_description
- final_data["subject"] = translated_subject or original_subject
- final_data["description"] = translated_description or original_description
- metadata["original_text"] = {
- "subject": original_subject,
- "description": original_description,
- }
- metadata["translation"] = {
- "translated": bool(translation_ctx["was_translated"]),
- "source_language": translation_ctx["source_language"],
- "source_language_name": translation_ctx["source_language_name"],
- }
- final_data["metadata"] = metadata
-
- # Backfill SLA deadlines/status when the client omits or sends empty values.
- priority_key = str(final_data.get("priority") or "medium").lower().strip()
- now_utc = datetime.datetime.now(datetime.timezone.utc)
-
- if not str(final_data.get("sla_breach_at") or "").strip():
- final_data["sla_breach_at"] = compute_sla_breach_at(priority_key, now_utc)
-
- if not str(final_data.get("sla_response_due_at") or "").strip():
- policy = get_sla_policy(priority_key)
- response_hours = max(1, int(round(float(policy["max_hours"]) * 0.25)))
- response_due_at = now_utc + datetime.timedelta(hours=response_hours)
- final_data["sla_response_due_at"] = response_due_at.isoformat()
-
- if not str(final_data.get("sla_status") or "").strip():
- final_data["sla_status"] = "ACTIVE"
- # Resolve tenant linkage from user profile with authorization validation.
- profile = {}
- if request_body.user_id:
- try:
- profile_res = (
- supabase.table("profiles")
- .select("company_id, company")
- .eq("id", request_body.user_id)
- .single()
- .execute()
- )
- profile = profile_res.data or {}
- if not profile:
- raise HTTPException(status_code=404, detail="User profile not found")
- except HTTPException:
- raise
- except Exception as profile_error:
- logger.error(f"Tenant resolution error for user {request_body.user_id}: {profile_error}")
- raise HTTPException(status_code=503, detail="Failed to resolve tenant linkage") from profile_error
-
- # Validate tenant consistency and authorization.
- profile_company_id = profile.get("company_id")
- if final_data.get("company_id"):
- # User provided company_id: verify it matches their profile.
- if profile_company_id and final_data["company_id"] != profile_company_id:
- logger.warning(f"Tenant mismatch: user {request_body.user_id} attempted {final_data['company_id']}, assigned to {profile_company_id}")
- raise HTTPException(status_code=403, detail="User not authorized for this tenant")
- elif profile_company_id:
- # Backfill company_id from profile.
- final_data["company_id"] = profile_company_id
- elif request_body.user_id:
- # User has no tenant assignment.
- raise HTTPException(status_code=400, detail="User has no tenant assignment")
-
try:
+ final_data = request_body.dict()
+
+ # Resolve tenant linkage from user profile with authorization validation.
+ profile = {}
+ if request_body.user_id:
+ try:
+ profile_res = (
+ supabase.table("profiles")
+ .select("company_id, company")
+ .eq("id", request_body.user_id)
+ .single()
+ .execute()
+ )
+ profile = profile_res.data or {}
+ if not profile:
+ raise HTTPException(status_code=404, detail="User profile not found")
+
+ # SELF-HEALING: If company_id is null in database but company name exists, resolve it!
+ if not profile.get("company_id") and profile.get("company"):
+ try:
+ comp_name = profile.get("company").strip()
+ comp_res = (
+ supabase.table("companies")
+ .select("id")
+ .ilike("name", comp_name)
+ .execute()
+ )
+ if comp_res.data:
+ resolved_company_id = comp_res.data[0]["id"]
+ # Backfill the profile table in real-time
+ supabase.table("profiles").update({"company_id": resolved_company_id}).eq("id", request_body.user_id).execute()
+ profile["company_id"] = resolved_company_id
+ logger.info(f"[SELF-HEALING] Backfilled company_id={resolved_company_id} for user={request_body.user_id}")
+ except Exception as healing_err:
+ logger.warning(f"[SELF-HEALING WARNING] Failed to backfill company_id: {healing_err}")
+ except HTTPException:
+ raise
+ except Exception as profile_error:
+ user_hash = hashlib.sha256(str(request_body.user_id).encode()).hexdigest()[:8]
+ logger.error(f"Tenant resolution error for user {user_hash}: {profile_error}")
+ raise HTTPException(status_code=503, detail="Failed to resolve tenant linkage") from profile_error
+
+ # Validate tenant consistency and authorization.
+ profile_company_id = profile.get("company_id")
+ if final_data.get("company_id"):
+ # User provided company_id: verify it matches their profile.
+ if profile_company_id and final_data["company_id"] != profile_company_id:
+ user_hash = hashlib.sha256(str(request_body.user_id).encode()).hexdigest()[:8]
+ logger.warning(f"Tenant mismatch: user {user_hash} attempted {final_data['company_id']}, assigned to {profile_company_id}")
+ raise HTTPException(status_code=403, detail="User not authorized for this tenant")
+ elif profile_company_id:
+ # Backfill company_id from profile.
+ final_data["company_id"] = profile_company_id
+ elif request_body.user_id:
+ # User has no tenant assignment.
+ raise HTTPException(status_code=400, detail="User has no tenant assignment")
+
# Backfill company name if missing.
if not final_data.get("company") and profile.get("company"):
final_data["company"] = profile["company"]
@@ -1068,31 +741,32 @@ async def save_ticket(request_body: TicketSaveRequest):
final_data["sla_status"] = final_data.get("sla_status") or classify_sla_status(final_data.get("sla_breach_at"))
final_data["escalation_level"] = int(final_data.get("escalation_level") or 0)
+ import hashlib
user_hash = hashlib.sha256(str(request_body.user_id).encode()).hexdigest()[:8]
logger.info(f"Tenant linkage: user_hash={user_hash}, company_id={final_data.get('company_id')}")
duplicate_text = (request_body.description or "").strip() or (request_body.subject or "").strip()
- duplicate_threshold = get_duplicate_threshold(final_data.get("company_id"), 0.85) # noqa: F841
+ duplicate_threshold = get_duplicate_threshold(final_data.get("company_id"), 0.85)
+ duplicate_result = {
+ "is_duplicate": False,
+ "duplicate_ticket_id": None,
+ "parent_ticket_id": None,
+ "is_potential_duplicate": False,
+ "similarity": 0.0,
+ }
+ if duplicate_text:
+ duplicate_result = detect_semantic_duplicate(
+ duplicate_text,
+ company_id=final_data.get("company_id"),
+ threshold=duplicate_threshold,
+ )
+ final_data["description_vector"] = duplicate_service.generate_embedding(duplicate_text)
+ else:
+ final_data["description_vector"] = None
- # Semantic duplicate check BEFORE inserting the ticket
- # This allows us to warn the user before confirming
- duplicate_check_result = None
- try:
- dupe_text = (request_body.description or request_body.subject or "").strip()
- if dupe_text:
- duplicate_check_result = await semantic_dupe_service.check_duplicate(
- text=dupe_text,
- company_id=final_data.get("company_id"),
- )
- if duplicate_check_result["is_duplicate"]:
- logger.info(
- f"[DUPLICATE] Ticket flagged as potential duplicate of "
- f"{duplicate_check_result['duplicate_ticket_id']} "
- f"(similarity: {duplicate_check_result['similarity']})"
- )
- except Exception as e:
- logger.warning(f"[DUPLICATE] Semantic check error (non-fatal): {e}")
+ final_data["is_potential_duplicate"] = duplicate_result.get("is_potential_duplicate", False)
+ final_data["parent_ticket_id"] = duplicate_result.get("parent_ticket_id")
# --- Sanitize payload to only include valid Supabase DB columns ---
# Extra AI telemetry and non-existent schema fields are merged into the metadata JSONB column
@@ -1100,14 +774,14 @@ async def save_ticket(request_body: TicketSaveRequest):
VALID_TICKET_COLUMNS = {
"user_id", "subject", "description", "category", "subcategory",
"priority", "assigned_team", "status", "auto_resolve", "is_duplicate",
- "confidence", "image_url", "company", "company_id",
- "sla_breach_at", "sla_response_due_at", "sla_status", "escalation_level", "metadata",
+ "confidence", "image_url", "company", "company_id", "sla_breach_at", "metadata",
}
# Merge any extra telemetry and SLA/duplicate fields into metadata before filtering
existing_metadata = final_data.get("metadata") or {}
extra_keys = (
"entities", "solution_steps", "ocr_text", "needs_review", "routing_confidence",
- "is_potential_duplicate", "parent_ticket_id"
+ "is_potential_duplicate", "parent_ticket_id", "sla_response_due_at", "sla_status", "escalation_level",
+ "spam_analysis"
)
for extra_key in extra_keys:
if extra_key in final_data and final_data[extra_key] not in (None, "", [], {}):
@@ -1124,29 +798,19 @@ async def save_ticket(request_body: TicketSaveRequest):
ticket_id = res.data[0]["id"]
- # If duplicate detected, link parent ticket
- if duplicate_check_result and duplicate_check_result["is_duplicate"]:
- try:
- supabase.table("tickets").update({
- "is_potential_duplicate": True,
- "parent_ticket_id": duplicate_check_result["duplicate_ticket_id"],
- }).eq("id", ticket_id).execute()
- except Exception as e:
- logger.warning(f"[DUPLICATE] Failed to link parent ticket: {e}")
-
- # Index the new ticket's embedding for future duplicate checks
- embedding_indexed = False
- description_text = (request_body.description or "").strip()
- subject_text = (request_body.subject or "").strip()
- duplicate_text = description_text or subject_text
+ duplicate_indexed = True
+ duplicate_index_warning = None
if duplicate_text:
try:
- # Both: old in-memory index (for backward compat) and new pgvector index
duplicate_service.add_ticket(str(ticket_id), duplicate_text)
- asyncio.create_task(semantic_dupe_service.index_ticket(ticket_id, duplicate_text))
- embedding_indexed = True
except Exception as index_error:
- logger.warning(f"[INDEX] Failed to index ticket {ticket_id}: {index_error}")
+ duplicate_indexed = False
+ duplicate_index_warning = "Duplicate index update failed."
+ print(f"[WARNING] {duplicate_index_warning} ticket_id={ticket_id} error={index_error}")
+ else:
+ duplicate_indexed = False
+ duplicate_index_warning = "Duplicate index update skipped: no description or subject text was provided."
+ print(f"[WARNING] {duplicate_index_warning}")
# Add initial system diagnostic message
msg = "Our Neural Engine has successfully triaged your issue and routed it to the designated team."
@@ -1164,157 +828,30 @@ async def save_ticket(request_body: TicketSaveRequest):
response = {
"status": "success",
"ticket_id": ticket_id,
- "duplicate_indexed": embedding_indexed,
+ "duplicate_indexed": duplicate_indexed,
+ "is_potential_duplicate": final_data["is_potential_duplicate"],
+ "parent_ticket_id": final_data["parent_ticket_id"],
}
- if duplicate_check_result and duplicate_check_result["is_duplicate"]:
- response["duplicate_warning"] = True
- response["parent_ticket_id"] = duplicate_check_result["duplicate_ticket_id"]
- response["parent_subject"] = duplicate_check_result.get("parent_subject")
- response["similarity"] = duplicate_check_result["similarity"]
- response["candidates"] = duplicate_check_result.get("candidates", [])
-
- # Broadcast the new/updated ticket to all WebSocket clients for this company
- company_id = final_data.get("company_id")
- if company_id:
- asyncio.create_task(
- connection_manager.broadcast(
- company_id,
- {
- "type": "ticket_update",
- "event": "created",
- "ticket": insert_data,
- "ticket_id": str(ticket_id),
- },
- )
- )
+ if duplicate_index_warning:
+ response["duplicate_index_warning"] = duplicate_index_warning
return response
except Exception as e:
traceback.print_exc()
raise HTTPException(status_code=500, detail=str(e))
-@app.websocket("/ws/{company_id}")
-async def websocket_endpoint(ws: WebSocket, company_id: str):
- """Real-time WebSocket feed for a company's ticket dashboard.
-
- Protocol:
- - Server sends ``{"type": "ping"}`` every 30s (heartbeat).
- - Client must respond with ``{"type": "pong"}`` within 10s.
- - Server pushes ``{"type": "ticket_update", ...}`` on changes.
-
- Usage (frontend):
- const socket = new WebSocket("ws://host:7860/ws/{company_id}");
- socket.onmessage = (event) => { const msg = JSON.parse(event.data); };
- """
- if not company_id or not company_id.strip():
- await ws.close(code=4000, reason="Missing company_id")
- return
-
- company_id = company_id.strip()
- await connection_manager.connect(company_id, ws)
- print(f"[WS] Client connected — company_id={company_id}")
-
- try:
- while True:
- raw = await ws.receive_text()
- if not raw.strip():
- continue
- try:
- data = json.loads(raw)
- except json.JSONDecodeError:
- continue # ignore malformed frames
-
- # Handle pong response
- if data.get("type") == "pong":
- continue
-
- except WebSocketDisconnect:
- pass
- except Exception as exc:
- print(f"[WS] Connection error for company_id={company_id}: {exc}")
- finally:
- await connection_manager.disconnect(company_id, ws)
- print(f"[WS] Client disconnected — company_id={company_id}")
-
-
@app.get("/tickets/{ticket_id}")
-async def get_ticket_by_id(
- request: Request,
- ticket_id: str,
- current_user: dict = Depends(get_current_user),
-):
+async def get_ticket_by_id(ticket_id: str):
"""Fetch single persistent ticket."""
if not supabase:
raise HTTPException(status_code=500, detail="Database connection not initialized")
-
- # Guard route overlap where '/tickets/search' may be matched here first.
- if ticket_id == "search":
- return await search_tickets(
- q=request.query_params.get("q", ""),
- company_id=request.query_params.get("company_id"),
- current_user=current_user,
- )
-
- profile = _get_authenticated_profile(current_user)
- company_scope = _ticket_company_scope(profile)
+
res = supabase.table("tickets").select("*").eq("id", ticket_id).single().execute()
if not res.data:
raise HTTPException(status_code=404, detail="Ticket not found")
- if company_scope and res.data.get("company_id") != company_scope:
- raise HTTPException(status_code=403, detail="User not authorized for this tenant")
return res.data
-@app.get("/tickets/{ticket_id}/audit_logs", response_model=list[AuditLogRecord])
-async def get_ticket_audit_logs(ticket_id: str, company_id: str):
- """Return a company-scoped chronological audit trail for a ticket."""
- if not supabase:
- raise HTTPException(status_code=500, detail="Database connection not initialized")
-
- try:
- service = AuditLogService(supabase)
- return service.get_ticket_audit_logs(ticket_id, company_id)
- except AuditLogAccessError as err:
- raise HTTPException(status_code=err.status_code, detail=err.detail)
-
-
-@app.get("/tickets/search")
-async def search_tickets(
- q: str,
- company_id: str | None = None,
- current_user: dict = Depends(get_current_user),
-):
- """Search tickets by query text, optionally scoped by company_id."""
- if not supabase:
- raise HTTPException(status_code=500, detail="Database connection not initialized")
- query_text = (q or "").strip()
- if not query_text:
- raise HTTPException(status_code=400, detail="Query text is required")
-
- profile = _get_authenticated_profile(current_user)
- company_scope = _ticket_company_scope(profile, company_id)
-
- try:
- rpc_res = supabase.rpc(
- "search_tickets",
- {"query_text": query_text, "company_id": company_scope},
- ).execute()
- return rpc_res.data or []
- except Exception:
- # Fallback for environments without RPC function support.
- fallback = supabase.table("tickets").select("*").order("created_at", desc=True).execute()
- rows = fallback.data or []
- lowered = query_text.lower()
- filtered = [
- row for row in rows
- if lowered in str(row.get("subject", "")).lower()
- or lowered in str(row.get("description", "")).lower()
- ]
- if company_scope:
- filtered = [row for row in filtered if row.get("company_id") == company_scope]
- return filtered
-
-
@app.post("/tickets", response_model=TicketRecord)
async def create_ticket(ticket: TicketRecord):
"""Save a new ticket into the system."""
@@ -1353,6 +890,11 @@ async def analyze_ticket(request_body: TicketRequest, request: Request):
Main endpoint for analyzing a new ticket using the cascade of local AI models.
"""
text = request_body.text
+
+ settings = get_system_settings(request_body.company_id)
+ confidence_threshold = settings["ai_confidence_threshold"]
+ duplicate_sensitivity = settings["duplicate_sensitivity"]
+ enable_auto_resolve = settings["enable_auto_resolve"]
# Grab client metadata
client_ip = request.client.host if request.client else "unknown"
@@ -1374,9 +916,8 @@ async def analyze_ticket(request_body: TicketRequest, request: Request):
text = f"{text} {local_ocr_text}".strip()
print(f"[AI] OCR added {len(local_ocr_text)} chars to context.")
- # Pass OCR-enriched text downstream so the analyze_only endpoint uses it.
- enriched = request_body.model_copy(update={"text": text, "image_text": local_ocr_text})
- return await analyze_only(enriched)
+ # Initalize Timeline
+ return await analyze_only(request_body)
@app.post("/ai/analyze")
async def analyze_only(request_body: TicketRequest):
@@ -1386,8 +927,6 @@ async def analyze_only(request_body: TicketRequest):
and duplicate check before committing to a ticket creation.
"""
text = request_body.text
- translation_ctx = detect_and_translate_ticket_text(text)
- text = translation_ctx["text_for_analysis"]
print(f"[AI] Starting Analysis (READ-ONLY) for: {text[:50]}...")
settings = get_system_settings(request_body.company)
confidence_threshold = settings["ai_confidence_threshold"]
@@ -1429,11 +968,9 @@ async def analyze_only(request_body: TicketRequest):
highlights=[],
timeline={"received": _dt.datetime.utcnow().isoformat() + "Z"},
env_metadata={},
+ is_potential_duplicate=False,
+ parent_ticket_id=None,
sla_breach_at=_sla_breach.isoformat().replace("+00:00", "Z"),
- original_text=request_body.text,
- source_language=translation_ctx["source_language"],
- source_language_name=translation_ctx["source_language_name"],
- was_translated=translation_ctx["was_translated"],
)
# --- Context & Environment ---
@@ -1465,18 +1002,54 @@ async def analyze_only(request_body: TicketRequest):
summary = text[:100] + ("…" if len(text) > 100 else "")
- # --- Spam / Phishing Detection (runs before classification) ---
+ # --- Spam & Phishing Detection Layer ---
+ spam_result = analyze_spam_phishing(text, gemini_analysis.get("ocr_text", ""))
+
+ # --- Classification ---
try:
- spam_result = spam_service.check(text, gemini_analysis.get("ocr_text", ""))
+ classification_v3_res = classifier_v3.predict(text)
+ if "error" in classification_v3_res:
+ # Fallback to V1
+ classification = classifier_service.predict(text)
+ else:
+ # Parse V3 output
+ cat = classification_v3_res.get("Category", {}).get("prediction", "Unknown")
+ sub = classification_v3_res.get("Subcategory", {}).get("prediction", "Unknown")
+ pri = classification_v3_res.get("priority", {}).get("prediction", "Medium")
+ conf = classification_v3_res.get("Category", {}).get("confidence", 0.0)
+
+ from backend.services.classifier_service import TEAM_MAP, AUTO_RESOLVE_SUBS
+ assigned_team = TEAM_MAP.get(cat, "General Support")
+ auto_resolve = sub in AUTO_RESOLVE_SUBS
+
+ classification = {
+ "category": cat,
+ "subcategory": sub,
+ "priority": pri,
+ "auto_resolve": auto_resolve,
+ "assigned_team": assigned_team,
+ "confidence": float(conf)
+ }
except Exception as e:
- print(f"[SPAM ERROR] {e}")
- spam_result = {
- "is_spam": False, "risk_score": 0.0, "reasons": [],
- "suspicious_urls": [], "matched_keywords": [],
+ traceback.print_exc()
+ classification = {
+ "category": "Unknown", "subcategory": "Unknown", "priority": "Medium",
+ "auto_resolve": False, "assigned_team": "General Support", "confidence": 0.0,
}
- # --- Classification ---
- classification = classify_ticket_text(text)
+ # Apply Spam overrides if spam/phishing is detected
+ if spam_result["is_spam"]:
+ classification["category"] = "Spam"
+ if spam_result["risk_level"] == "high":
+ classification["subcategory"] = "Suspicious Phishing"
+ elif spam_result["risk_level"] == "medium":
+ classification["subcategory"] = "Spam Inquiry"
+ else:
+ classification["subcategory"] = "Low-Risk Spam"
+ classification["priority"] = "Low"
+ classification["assigned_team"] = "Security Unit"
+ classification["auto_resolve"] = False
+ classification["confidence"] = max(classification["confidence"], 0.95)
timeline["ai_analyzed"] = get_now_ist()
timeline["triaged"] = get_now_ist()
@@ -1490,10 +1063,21 @@ async def analyze_only(request_body: TicketRequest):
timeline["metadata_harvested"] = get_now_ist()
# --- Duplicate detection ---
+ duplicate_threshold = get_duplicate_threshold(request_body.company_id, duplicate_sensitivity)
try:
- dup_result = duplicate_service.check_duplicate(text, threshold=request_body.duplicate_sensitivity)
+ dup_result = detect_semantic_duplicate(
+ text,
+ company_id=request_body.company_id,
+ threshold=duplicate_threshold,
+ )
except Exception:
- dup_result = {"is_duplicate": False, "duplicate_ticket_id": None, "similarity": 0.0}
+ dup_result = {
+ "is_duplicate": False,
+ "duplicate_ticket_id": None,
+ "parent_ticket_id": None,
+ "is_potential_duplicate": False,
+ "similarity": 0.0,
+ }
# --- RAG Knowledge Base Check ---
rag_match = None
@@ -1509,26 +1093,30 @@ async def analyze_only(request_body: TicketRequest):
# --- Reasoning ---
decision_factors = []
- if classification["confidence"] > request_body.confidence_threshold:
- decision_factors.append(f"High confidence match for '{classification['subcategory']}'")
- if entities:
- decision_factors.append(f"Detected entities: {', '.join([e['text'] for e in entities[:2]])}")
- if dup_result["is_duplicate"]:
- decision_factors.append(f"Found similar incident ({int(dup_result['similarity']*100)}%)")
- if rag_match:
- decision_factors.append(f"Found solution article: '{rag_match['title']}'")
if spam_result["is_spam"]:
- decision_factors.append(
- f"Flagged as spam/phishing (risk {spam_result['risk_score']:.2f})"
- )
- classification["assigned_team"] = "Spam / Suspicious"
- classification["auto_resolve"] = False
+ decision_factors.append(f"Spam/Phishing detected (Risk: {spam_result['risk_level'].upper()})")
+ reasoning = f"Flagged as potential spam/phishing. Reasons: {', '.join(spam_result['reasons'])}"
+ else:
+ if classification["confidence"] > confidence_threshold:
+ decision_factors.append(f"High confidence match for '{classification['subcategory']}'")
+ if entities:
+ decision_factors.append(f"Detected entities: {', '.join([e['text'] for e in entities[:2]])}")
+ if dup_result["is_duplicate"]:
+ decision_factors.append(f"Found similar incident ({int(dup_result['similarity']*100)}%)")
+ if rag_match:
+ decision_factors.append(f"Found solution article: '{rag_match['title']}'")
- reasoning = f"Categorized as '{classification['category']}' - {classification['subcategory']}."
- if classification["auto_resolve"]:
- reasoning += " Flagged for AI auto-resolution via Knowledge Base." if rag_match else " Flagged for auto-resolution."
- if spam_result["is_spam"]:
- reasoning += " Ticket flagged as spam/phishing and quarantined from agent inbox."
+ reasoning = f"Categorized as '{classification['category']}' - {classification['subcategory']}."
+ if (
+ enable_auto_resolve
+ and classification["confidence"] >= confidence_threshold
+ and classification["auto_resolve"]
+ ):
+ classification["auto_resolve"] = True
+ else:
+ classification["auto_resolve"] = False
+ if classification["auto_resolve"]:
+ reasoning += " Flagged for AI auto-resolution via Knowledge Base." if rag_match else " Flagged for auto-resolution."
timeline["routed"] = get_now_ist()
@@ -1536,10 +1124,8 @@ async def analyze_only(request_body: TicketRequest):
if gemini_service and gemini_service._initialized:
summary = gemini_service.get_summary(text)
- # Convert priority to SLA breached timestamp (for preview)
- hours_map = {"Critical": 2, "High": 8, "Medium": 24, "Low": 72}
- sla_hours = hours_map.get(classification["priority"], 72)
- sla_breach_dt = datetime.datetime.utcnow() + datetime.timedelta(hours=sla_hours)
+ # Convert priority to the SLA resolution target timestamp for preview.
+ sla_breach_dt = calculate_sla_breach_at(classification["priority"])
return TicketResponse(
ticket_id=str(uuid.uuid4()), # Temporary ID
@@ -1552,22 +1138,18 @@ async def analyze_only(request_body: TicketRequest):
entities=[EntityInfo(**e) for e in entities],
duplicate_ticket=DuplicateInfo(**dup_result),
confidence=classification["confidence"],
- needs_review=classification["confidence"] < 0.20,
+ needs_review=classification["confidence"] < confidence_threshold,
reasoning=reasoning,
decision_factors=decision_factors,
image_description=gemini_analysis["image_description"],
ocr_text=gemini_analysis["ocr_text"],
- highlights=[e.get("text", "") for e in entities], # Use entity texts as highlights for now
+ highlights=entities, # Use entities as highlights for now
timeline=timeline,
env_metadata=env_metadata,
- spam_check=SpamCheck(**spam_result),
+ spam_analysis=spam_result,
is_potential_duplicate=dup_result.get("is_potential_duplicate", False),
parent_ticket_id=dup_result.get("parent_ticket_id"),
- sla_breach_at=sla_breach_dt.isoformat().replace("+00:00", "Z"),
- original_text=translation_ctx["original_text"],
- source_language=translation_ctx["source_language"],
- source_language_name=translation_ctx["source_language_name"],
- was_translated=translation_ctx["was_translated"],
+ sla_breach_at=sla_breach_dt.isoformat().replace("+00:00", "Z")
)
@app.post("/ai/analyze_stream")
@@ -1586,7 +1168,11 @@ async def analyze_stream(request_body: TicketRequest):
"model_version": "3.0.0-PRO",
"api_endpoint": "/ai/analyze_stream"
}
- timeline = {"received": get_now_ist()}
+ timeline = {"received": get_now_ist()}
+ settings = get_system_settings(request_body.company_id)
+ confidence_threshold = settings["ai_confidence_threshold"]
+ duplicate_sensitivity = settings["duplicate_sensitivity"]
+ enable_auto_resolve = settings["enable_auto_resolve"]
# 1. Reading
yield f"data: {json.dumps({'step': 'Reading your message', 'status': 'in_progress'})}\n\n"
@@ -1602,15 +1188,6 @@ async def analyze_stream(request_body: TicketRequest):
summary = text[:100] + ("…" if len(text) > 100 else "")
- # Spam / Phishing check (silent step — does not get its own SSE event)
- try:
- spam_result = spam_service.check(text, gemini_analysis.get("ocr_text", ""))
- except Exception:
- spam_result = {
- "is_spam": False, "risk_score": 0.0, "reasons": [],
- "suspicious_urls": [], "matched_keywords": [],
- }
-
# 2. NER
yield f"data: {json.dumps({'step': 'Extracting technical entities', 'status': 'in_progress'})}\n\n"
await asyncio.sleep(0.2)
@@ -1623,7 +1200,33 @@ async def analyze_stream(request_body: TicketRequest):
# 3. Classification
yield f"data: {json.dumps({'step': 'Detecting category and priority', 'status': 'in_progress'})}\n\n"
await asyncio.sleep(0.2)
- classification = classify_ticket_text(text)
+ try:
+ classification_v3_res = classifier_v3.predict(text)
+ if "error" in classification_v3_res:
+ classification = classifier_service.predict(text)
+ else:
+ cat = classification_v3_res.get("Category", {}).get("prediction", "Unknown")
+ sub = classification_v3_res.get("Subcategory", {}).get("prediction", "Unknown")
+ pri = classification_v3_res.get("priority", {}).get("prediction", "Medium")
+ conf = classification_v3_res.get("Category", {}).get("confidence", 0.0)
+
+ from backend.services.classifier_service import TEAM_MAP, AUTO_RESOLVE_SUBS
+ assigned_team = TEAM_MAP.get(cat, "General Support")
+ auto_resolve = sub in AUTO_RESOLVE_SUBS
+
+ classification = {
+ "category": cat,
+ "subcategory": sub,
+ "priority": pri,
+ "auto_resolve": auto_resolve,
+ "assigned_team": assigned_team,
+ "confidence": float(conf)
+ }
+ except Exception as e:
+ classification = {
+ "category": "Unknown", "subcategory": "Unknown", "priority": "Medium",
+ "auto_resolve": False, "assigned_team": "General Support", "confidence": 0.0,
+ }
timeline["ai_analyzed"] = get_now_ist()
timeline["triaged"] = get_now_ist()
@@ -1631,9 +1234,20 @@ async def analyze_stream(request_body: TicketRequest):
yield f"data: {json.dumps({'step': 'Checking duplicate issues', 'status': 'in_progress'})}\n\n"
await asyncio.sleep(0.2)
try:
- dup_result = duplicate_service.check_duplicate(text, threshold=request_body.duplicate_sensitivity)
+ duplicate_threshold = get_duplicate_threshold(request_body.company_id, duplicate_sensitivity)
+ dup_result = detect_semantic_duplicate(
+ text,
+ company_id=request_body.company_id,
+ threshold=duplicate_threshold,
+ )
except Exception:
- dup_result = {"is_duplicate": False, "duplicate_ticket_id": None, "similarity": 0.0}
+ dup_result = {
+ "is_duplicate": False,
+ "duplicate_ticket_id": None,
+ "parent_ticket_id": None,
+ "is_potential_duplicate": False,
+ "similarity": 0.0,
+ }
# 5. RAG / Solutions
yield f"data: {json.dumps({'step': 'Finding possible solutions', 'status': 'in_progress'})}\n\n"
@@ -1649,7 +1263,7 @@ async def analyze_stream(request_body: TicketRequest):
pass
decision_factors = []
- if classification["confidence"] > request_body.confidence_threshold:
+ if classification["confidence"] > confidence_threshold:
decision_factors.append(f"High confidence match for '{classification['subcategory']}'")
if entities:
decision_factors.append(f"Detected entities: {', '.join([e['text'] for e in entities[:2]])}")
@@ -1657,27 +1271,19 @@ async def analyze_stream(request_body: TicketRequest):
decision_factors.append(f"Found similar incident ({int(dup_result['similarity']*100)}%)")
if rag_match:
decision_factors.append(f"Found solution article: '{rag_match['title']}'")
- if spam_result["is_spam"]:
- decision_factors.append(
- f"Flagged as spam/phishing (risk {spam_result['risk_score']:.2f})"
- )
- classification["assigned_team"] = "Spam / Suspicious"
- classification["auto_resolve"] = False
+ if not enable_auto_resolve:
+ classification["auto_resolve"] = False
reasoning = f"Categorized as '{classification['category']}' - {classification['subcategory']}."
if classification["auto_resolve"]:
reasoning += " Flagged for AI auto-resolution via Knowledge Base." if rag_match else " Flagged for auto-resolution."
- if spam_result["is_spam"]:
- reasoning += " Ticket flagged as spam/phishing and quarantined from agent inbox."
timeline["routed"] = get_now_ist()
if gemini_service and gemini_service._initialized:
summary = gemini_service.get_summary(text)
- hours_map = {"Critical": 2, "High": 8, "Medium": 24, "Low": 72}
- sla_hours = hours_map.get(classification["priority"], 72)
- sla_breach_dt = datetime.datetime.utcnow() + datetime.timedelta(hours=sla_hours)
+ sla_breach_dt = calculate_sla_breach_at(classification["priority"])
ticket_response_dict = {
"ticket_id": str(uuid.uuid4()),
@@ -1690,16 +1296,17 @@ async def analyze_stream(request_body: TicketRequest):
"entities": [e for e in entities],
"duplicate_ticket": dup_result,
"confidence": classification["confidence"],
- "needs_review": classification["confidence"] < 0.20,
+ "needs_review": classification["confidence"] < confidence_threshold,
"reasoning": reasoning,
"decision_factors": decision_factors,
"image_description": gemini_analysis["image_description"],
"ocr_text": gemini_analysis["ocr_text"],
- "highlights": [e.get("text", "") for e in entities],
+ "highlights": entities,
"timeline": timeline,
"env_metadata": env_metadata,
- "spam_check": spam_result,
- "sla_breach_at": sla_breach_dt.isoformat() + "Z"
+ "is_potential_duplicate": dup_result.get("is_potential_duplicate", False),
+ "parent_ticket_id": dup_result.get("parent_ticket_id"),
+ "sla_breach_at": sla_breach_dt.isoformat().replace("+00:00", "Z")
}
# 6. Final Result
@@ -1731,266 +1338,3 @@ async def analyze_ticket_v2(request: TicketRequest):
}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
-
-
-# ---------------------------------------------------------------------------
-# SLA Engine Endpoints
-# ---------------------------------------------------------------------------
-
-class SLAStatsResponse(BaseModel):
- total: int = 0
- active: int = 0
- breached: int = 0
- warning: int = 0
- met: int = 0
- breach_rate: float = 0.0
- by_priority: dict = {}
-
-
-@app.get("/sla/stats", response_model=SLAStatsResponse)
-async def sla_stats():
- """Get aggregated SLA dashboard statistics across all tickets."""
- if not supabase:
- raise HTTPException(status_code=503, detail="Database not connected")
- stats = await sla_engine.get_dashboard_stats()
- if "error" in stats:
- raise HTTPException(status_code=500, detail=stats["error"])
- return stats
-
-
-class SLATicketInfo(BaseModel):
- id: str
- ticket_id: str | None = None
- subject: str | None = None
- summary: str | None = None
- priority: str = "medium"
- status: str | None = None
- assigned_team: str | None = None
- sla_status: str = "active"
- escalation_level: int = 0
- remaining_seconds: int = 0
- created_at: str | None = None
- sla_breach_at: str | None = None
- sla_warning_at: str | None = None
- last_escalated_at: str | None = None
-
-
-@app.get("/sla/tickets")
-async def sla_tickets(
- status: str | None = None,
- priority: str | None = None,
- limit: int = 100,
- offset: int = 0,
-):
- """
- List tickets with SLA status. Filter by sla_status and/or priority.
- """
- if not supabase:
- raise HTTPException(status_code=503, detail="Database not connected")
-
- query = (
- supabase.table("tickets")
- .select("id, ticket_id, subject, summary, priority, status, assigned_team, sla_status, escalation_level, remaining_seconds, created_at, sla_breach_at, sla_warning_at, last_escalated_at")
- .order("created_at", desc=True)
- )
-
- if status and status != "all":
- query = query.eq("sla_status", status)
- if priority and priority != "all":
- query = query.eq("priority", priority.capitalize())
-
- query = query.range(offset, offset + limit - 1)
- res = query.execute()
- return {"tickets": res.data or [], "total": len(res.data or [])}
-
-
-class EscalationLogEntry(BaseModel):
- id: str
- ticket_id: str | None = None
- ticket_subject: str = ""
- priority: str = "medium"
- sla_status: str = ""
- escalation_level: int = 0
- remaining_seconds: int = 0
- assigned_team: str = ""
- notification_channels: list = []
- triggered_at: str | None = None
- resolved_at: str | None = None
- notes: str = ""
-
-
-@app.get("/sla/escalations")
-async def sla_escalations(limit: int = 50, offset: int = 0):
- """Fetch escalation log history."""
- if not supabase:
- raise HTTPException(status_code=503, detail="Database not connected")
-
- try:
- res = (
- supabase.table("escalation_logs")
- .select("*")
- .order("triggered_at", desc=True)
- .range(offset, offset + limit - 1)
- .execute()
- )
- return {"escalations": res.data or [], "total": len(res.data or [])}
- except Exception as e:
- # Table might not exist yet
- print(f"[SLA] Escalation logs query failed: {e}")
- return {"escalations": [], "total": 0}
-
-
-class SLAPolicyInfo(BaseModel):
- id: str
- priority: str
- max_hours: int
- warning_pct: float
- auto_escalate: bool
- l2_after_minutes: int
- l3_after_minutes: int
-
-
-@app.get("/sla/policies")
-async def sla_policies():
- """Get configured SLA policies."""
- if not supabase:
- # Return defaults from code
- policies = []
- policy_source = sla_engine.SLA_POLICIES if hasattr(sla_engine, "SLA_POLICIES") else {}
- for pri, cfg in policy_source.items():
- policies.append({
- "priority": pri,
- "max_hours": cfg["max_hours"],
- "warning_pct": cfg["warning_pct"],
- "auto_escalate": cfg.get("auto_escalate_on_breach", False),
- "l2_after_minutes": cfg.get("l2_escalation_mins", 0),
- "l3_after_minutes": cfg.get("l3_escalation_mins", 0),
- })
- return {"policies": policies}
-
- try:
- res = supabase.table("sla_policies").select("*").execute()
- return {"policies": res.data or []}
- except Exception as e:
- print(f"[SLA] Policies query failed: {e}")
- return {"policies": []}
-
-
-@app.post("/sla/check")
-async def trigger_sla_check():
- """Manually trigger an SLA evaluation cycle (admin)."""
- if not supabase:
- raise HTTPException(status_code=503, detail="Database not connected")
-
- asyncio.create_task(sla_engine.check_all_active_tickets())
- return {"status": "triggered", "message": "SLA check cycle started in background"}
-
-
-# ---------------------------------------------------------------------------
-# Semantic Duplicate Detection Endpoints
-# ---------------------------------------------------------------------------
-
-@app.post("/ai/check_duplicate")
-async def check_duplicate_endpoint(
- body: TicketRequest,
- company_id: str | None = None,
-):
- """
- Check a ticket text for potential duplicates using semantic vector search.
- Returns top candidates with similarity scores.
- """
- text = (body.text or "").strip()
- if not text:
- raise HTTPException(status_code=400, detail="No text provided")
-
- threshold = body.duplicate_sensitivity if hasattr(body, 'duplicate_sensitivity') else None
- result = await semantic_dupe_service.check_duplicate(
- text=text,
- company_id=company_id or body.company,
- threshold=threshold,
- )
- return result
-
-
-@app.post("/ai/reindex_embeddings")
-async def reindex_embeddings():
- """Re-generate vector embeddings for all tickets."""
- result = await semantic_dupe_service.reindex_all()
- return result
-
-
-@app.get("/system/settings")
-async def get_system_settings_endpoint():
- """Fetch all system settings."""
- _logger = logging.getLogger(__name__)
- if not supabase:
- raise HTTPException(status_code=503, detail="Database not connected")
- try:
- res = supabase.table("system_settings").select("*").execute()
- settings = {}
- for row in res.data or []:
- settings[row["key"]] = row["value"]
- return settings
- except Exception as e:
- _logger.warning(f"[SETTINGS] Query failed: {e}")
- return {}
-
-
-@app.patch("/system/settings")
-async def update_system_settings(body: dict):
- """Update a specific system setting."""
- if not supabase:
- raise HTTPException(status_code=503, detail="Database not connected")
- key = body.get("key")
- value = body.get("value")
- if not key or value is None:
- raise HTTPException(status_code=400, detail="key and value required")
- try:
- supabase.table("system_settings").upsert({
- "key": key,
- "value": value,
- "updated_at": datetime.datetime.utcnow().isoformat() + "Z",
- }).execute()
- return {"status": "updated", "key": key}
- except Exception as e:
- raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/sla/tickets/{ticket_id}")
-async def sla_ticket_detail(ticket_id: str):
- """Get detailed SLA info for a specific ticket."""
- if not supabase:
- raise HTTPException(status_code=503, detail="Database not connected")
-
- # Fetch ticket
- res = supabase.table("tickets").select("*").eq("id", ticket_id).single().execute()
- if not res.data:
- raise HTTPException(status_code=404, detail="Ticket not found")
-
- ticket = res.data
- result = sla_engine.evaluate_ticket(ticket)
-
- # Fetch escalation history for this ticket
- try:
- esc_res = (
- supabase.table("escalation_logs")
- .select("*")
- .eq("ticket_id", ticket_id)
- .order("triggered_at", desc=True)
- .execute()
- )
- escalations = esc_res.data or []
- except Exception:
- escalations = []
-
- return {
- "ticket": ticket,
- "sla_evaluation": result,
- "escalations": escalations,
- }
-
-
-@app.get("/metrics")
-async def metrics():
- """Prometheus scrape endpoint — exposes AI inference latency, request counts, and tokens."""
- return Response(content=generate_latest(), media_type=CONTENT_TYPE_LATEST)
diff --git a/backend/requirements.txt b/backend/requirements.txt
index f2014c0ba584d1a7043fb66ef5d4a7f5e78acca9..027a7ecfa63483eb6b341c26c4b095262fa00321 100644
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@@ -4,8 +4,6 @@ datasets>=2.14.0
pandas>=2.0.0
scikit-learn>=1.3.0
sentence-transformers>=2.2.0
-onnxruntime>=1.17.0
-tokenizers>=0.15.0
fastapi>=0.104.0
uvicorn>=0.24.0
openpyxl>=3.1.0
@@ -17,11 +15,4 @@ easyocr
slowapi>=0.1.9
supabase==2.22.4
storage3==2.22.4
-redis>=5.0.0
-pytest
-pytest-asyncio
-httpx
-cryptography>=42.0.0
-websockets>=12.0
-prometheus-client>=0.19.0
-
+prometheus-client>=0.17.0
diff --git a/backend/services/classifier_service.py b/backend/services/classifier_service.py
index 2dc131b47ba167713f4c087b259f4266f26f5f96..724c96394e0bd562e17b554e37c585564aca81cc 100644
--- a/backend/services/classifier_service.py
+++ b/backend/services/classifier_service.py
@@ -6,32 +6,29 @@ Priority and other fields are derived from the category mapping.
import os
import json
-try:
- import torch
- import torch.nn.functional as F
- from transformers import DistilBertTokenizerFast, DistilBertForSequenceClassification
- _HAS_TORCH = True
-except Exception: # pragma: no cover - optional CI/runtime dependency
- torch = None
- F = None
- DistilBertTokenizerFast = None
- DistilBertForSequenceClassification = None
- _HAS_TORCH = False
+import torch
+import torch.nn.functional as F
+from transformers import DistilBertTokenizerFast, DistilBertForSequenceClassification
+import time
+from prometheus_client import Counter, Histogram
+
+# Prometheus metrics for tracking model performance
+MODEL_PREDICTIONS_TOTAL = Counter(
+ "model_predictions_total",
+ "Total count of DistilBERT predictions",
+ ["status"]
+)
+
+MODEL_PREDICTION_LATENCY = Histogram(
+ "model_prediction_latency_seconds",
+ "Latency of DistilBERT prediction in seconds",
+ buckets=(0.05, 0.1, 0.25, 0.5, 0.75, 1.0, 2.5, 5.0, 10.0)
+)
SAVE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "models", "classifier")
-DEVICE = torch.device("cuda" if torch and torch.cuda.is_available() else "cpu") if _HAS_TORCH else None
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
MAX_LEN = 128
-try:
- from backend.services.metrics_service import (
- CLASSIFIER_LATENCY,
- CLASSIFIER_REQUESTS,
- CLASSIFIER_TOKENS,
- )
- _METRICS_ENABLED = True
-except Exception:
- _METRICS_ENABLED = False
-
# Priority mapping based on sub-category severity
PRIORITY_MAP = {
"Blue Screen": "Critical", "Overheating": "Critical", "Data Loss": "Critical",
@@ -75,19 +72,26 @@ class ClassifierService:
if self._loaded:
return
- if not _HAS_TORCH:
- # Degraded environment: ML runtime not available. Delay failure until predict is called.
- print("[INFO] ML runtime not available; classifier will remain unloaded until dependencies are installed.")
- return
-
abs_dir = os.path.abspath(SAVE_DIR)
+ safetensors_path = os.path.join(abs_dir, "model.safetensors")
- if not os.path.exists(os.path.join(abs_dir, "model.safetensors")):
+ if not os.path.exists(safetensors_path):
raise FileNotFoundError(
f"Classifier model not found at {abs_dir}. "
"Please ensure model files are present."
)
+ with open(safetensors_path, "rb") as f:
+ header = f.read(512)
+ if (
+ b"version https://git-lfs.github.com/spec" in header
+ or b"oid sha256:" in header
+ ):
+ raise FileNotFoundError(
+ f"Classifier model at {abs_dir} is a Git LFS placeholder, not the actual model. "
+ "Please pull the LFS assets."
+ )
+
# Load label mappings
with open(os.path.join(abs_dir, "id2label.json"), "r") as f:
self.id2label = json.load(f)
@@ -109,76 +113,74 @@ class ClassifierService:
"""
Predict category, subcategory, priority, auto_resolve, assigned_team, and confidence.
"""
- self.load()
-
- encoding = self.tokenizer(
- text,
- truncation=True,
- padding="max_length",
- max_length=MAX_LEN,
- return_tensors="pt",
- )
- input_ids = encoding["input_ids"].to(DEVICE)
- attention_mask = encoding["attention_mask"].to(DEVICE)
-
- import time
- _t0 = time.perf_counter()
+ start_time = time.time()
try:
+ self.load()
+
+ encoding = self.tokenizer(
+ text,
+ truncation=True,
+ padding="max_length",
+ max_length=MAX_LEN,
+ return_tensors="pt",
+ )
+ input_ids = encoding["input_ids"].to(DEVICE)
+ attention_mask = encoding["attention_mask"].to(DEVICE)
+
with torch.no_grad():
outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
logits = outputs.logits
probs = F.softmax(logits, dim=1)
confidence, pred_idx = torch.max(probs, dim=1)
- except Exception:
- if _METRICS_ENABLED:
- CLASSIFIER_REQUESTS.labels(model="distilbert", status="error").inc()
- raise
- if _METRICS_ENABLED:
- CLASSIFIER_LATENCY.labels(model="distilbert").observe(time.perf_counter() - _t0)
- CLASSIFIER_REQUESTS.labels(model="distilbert", status="ok").inc()
- CLASSIFIER_TOKENS.labels(model="distilbert").inc(int(attention_mask.sum().item()))
-
- pred_idx = pred_idx.item()
- confidence = round(confidence.item(), 4)
-
- # Decode the combined label "Category | SubCategory"
- combined_label = self.id2label.get(str(pred_idx), "Unknown | Unknown")
- parts = combined_label.split(" | ", 1)
- category = parts[0].strip() if len(parts) > 0 else "Unknown"
- subcategory = parts[1].strip() if len(parts) > 1 else "Unknown"
-
- # Derive priority
- priority = PRIORITY_MAP.get(subcategory, "Medium")
-
- # Derive assigned team
- assigned_team = TEAM_MAP.get(category, "General Support")
-
- # Derive auto_resolve
- auto_resolve = subcategory in AUTO_RESOLVE_SUBS
-
- # --- Regex Override Layer (Boost for Technical Keywords) ---
- tech_keywords = {
- "Network": ["IP address", "hostname", "connection", "network", "bandwidth", "DNS", "firewall", "VPN", "Connectivity", "Latency", "Routing", "Spikes"],
- "Software": ["crash", "load", "website", "application", "error", "bug", "failing", "software", "SQL", "Cluster", "Database", "Production", "Latency"],
- "Access": ["login", "password", "access", "authentication", "account", "permission", "MFA", "OAuth"]
- }
-
- lower_text = text.lower()
- for cat, keywords in tech_keywords.items():
- if any(k.lower() in lower_text for k in keywords):
- # If current prediction is generic, or we have a high-value technical keyword
- if category == "General" or confidence < 0.9:
- category = cat
- assigned_team = TEAM_MAP.get(cat, "General Support")
- # Boost confidence significantly for verified technical signals
- confidence = max(confidence, 0.92)
- break
-
- return {
- "category": category,
- "subcategory": subcategory,
- "priority": priority,
- "auto_resolve": auto_resolve,
- "assigned_team": assigned_team,
- "confidence": confidence,
- }
+
+ pred_idx = pred_idx.item()
+ confidence = round(confidence.item(), 4)
+
+ # Decode the combined label "Category | SubCategory"
+ combined_label = self.id2label.get(str(pred_idx), "Unknown | Unknown")
+ parts = combined_label.split(" | ", 1)
+ category = parts[0].strip() if len(parts) > 0 else "Unknown"
+ subcategory = parts[1].strip() if len(parts) > 1 else "Unknown"
+
+ # Derive priority
+ priority = PRIORITY_MAP.get(subcategory, "Medium")
+
+ # Derive assigned team
+ assigned_team = TEAM_MAP.get(category, "General Support")
+
+ # Derive auto_resolve
+ auto_resolve = subcategory in AUTO_RESOLVE_SUBS
+
+ # --- Regex Override Layer (Boost for Technical Keywords) ---
+ tech_keywords = {
+ "Network": ["IP address", "hostname", "connection", "network", "bandwidth", "DNS", "firewall", "VPN", "Connectivity", "Latency", "Routing", "Spikes"],
+ "Software": ["crash", "load", "website", "application", "error", "bug", "failing", "software", "SQL", "Cluster", "Database", "Production", "Latency"],
+ "Access": ["login", "password", "access", "authentication", "account", "permission", "MFA", "OAuth"]
+ }
+
+ lower_text = text.lower()
+ for cat, keywords in tech_keywords.items():
+ if any(k.lower() in lower_text for k in keywords):
+ # If current prediction is generic, or we have a high-value technical keyword
+ if category == "General" or confidence < 0.9:
+ category = cat
+ assigned_team = TEAM_MAP.get(cat, "General Support")
+ # Boost confidence significantly for verified technical signals
+ confidence = max(confidence, 0.92)
+ break
+
+ MODEL_PREDICTIONS_TOTAL.labels(status="success").inc()
+ return {
+ "category": category,
+ "subcategory": subcategory,
+ "priority": priority,
+ "auto_resolve": auto_resolve,
+ "assigned_team": assigned_team,
+ "confidence": confidence,
+ }
+ except Exception as e:
+ MODEL_PREDICTIONS_TOTAL.labels(status="failure").inc()
+ raise e
+ finally:
+ duration = time.time() - start_time
+ MODEL_PREDICTION_LATENCY.observe(duration)
diff --git a/backend/services/classifier_v2.py b/backend/services/classifier_v2.py
index c6955edc8c87a7ce86431a62c8d8bdb395fd95e0..6fcfca6f5e2a36ed7111513477a159a95a347d70 100644
--- a/backend/services/classifier_v2.py
+++ b/backend/services/classifier_v2.py
@@ -1,109 +1,89 @@
import os
+import torch
+import torch.nn as nn
import pickle
import json
-try:
- import torch
- import torch.nn as nn
- from transformers import DistilBertTokenizerFast, DistilBertModel
- _HAS_TORCH = True
-except Exception: # pragma: no cover - optional runtime dependency
- torch = None
- nn = None
- DistilBertTokenizerFast = None
- DistilBertModel = None
- _HAS_TORCH = False
+from transformers import DistilBertTokenizerFast, DistilBertModel
# Paths
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
MODEL_DIR = os.path.join(BASE_DIR, "models", "classifier-v2")
# We must use the exact same class definition as trainer_v2
-if _HAS_TORCH:
- class MultiOutputClassifierV2(nn.Module):
- def __init__(self, num_labels_per_output: dict):
- super().__init__()
- self.bert = DistilBertModel.from_pretrained("distilbert-base-uncased")
- hidden = self.bert.config.hidden_size
- self.dropout = nn.Dropout(0.2)
- self.heads = nn.ModuleDict()
- for name, n_labels in num_labels_per_output.items():
- self.heads[name] = nn.Linear(hidden, n_labels)
+class MultiOutputClassifierV2(nn.Module):
+ def __init__(self, num_labels_per_output: dict):
+ super().__init__()
+ self.bert = DistilBertModel.from_pretrained("distilbert-base-uncased")
+ hidden = self.bert.config.hidden_size
+ self.dropout = nn.Dropout(0.2)
+ self.heads = nn.ModuleDict()
+ for name, n_labels in num_labels_per_output.items():
+ self.heads[name] = nn.Linear(hidden, n_labels)
- def forward(self, input_ids, attention_mask):
- outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
- cls_output = outputs.last_hidden_state[:, 0]
- cls_output = self.dropout(cls_output)
- logits = {name: head(cls_output) for name, head in self.heads.items()}
- return logits
+ def forward(self, input_ids, attention_mask):
+ outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+ cls_output = outputs.last_hidden_state[:, 0]
+ cls_output = self.dropout(cls_output)
+ logits = {name: head(cls_output) for name, head in self.heads.items()}
+ return logits
- class ClassifierServiceV2:
- def __init__(self):
- self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
- # 1. Load Config
- config_path = os.path.join(MODEL_DIR, "model_config.json")
- if not os.path.exists(config_path):
- self.model = None
- print(f"[WARN] V2 Model config not found at {config_path}")
- return
+class ClassifierServiceV2:
+ def __init__(self):
+ self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+ # 1. Load Config
+ config_path = os.path.join(MODEL_DIR, "model_config.json")
+ if not os.path.exists(config_path):
+ self.model = None
+ print(f"[WARN] V2 Model config not found at {config_path}")
+ return
- with open(config_path, "r") as f:
- self.num_labels = json.load(f)
+ with open(config_path, "r") as f:
+ self.num_labels = json.load(f)
- # 2. Load Encoders
- with open(os.path.join(MODEL_DIR, "label_encoders.pkl"), "rb") as f:
- self.label_encoders = pickle.load(f)
+ # 2. Load Encoders
+ with open(os.path.join(MODEL_DIR, "label_encoders.pkl"), "rb") as f:
+ self.label_encoders = pickle.load(f)
- # 3. Load Model
- self.model = MultiOutputClassifierV2(self.num_labels).to(self.device)
- model_path = os.path.join(MODEL_DIR, "model.pt")
- self.model.load_state_dict(torch.load(model_path, map_location=self.device))
- self.model.eval()
+ # 3. Load Model
+ self.model = MultiOutputClassifierV2(self.num_labels).to(self.device)
+ model_path = os.path.join(MODEL_DIR, "model.pt")
+ self.model.load_state_dict(torch.load(model_path, map_location=self.device))
+ self.model.eval()
- # 4. Load Tokenizer
- self.tokenizer = DistilBertTokenizerFast.from_pretrained(MODEL_DIR)
- print("[SUCCESS] Classifier Service V2 (Shadow) Loaded Successfully.")
+ # 4. Load Tokenizer
+ self.tokenizer = DistilBertTokenizerFast.from_pretrained(MODEL_DIR)
+ print("[SUCCESS] Classifier Service V2 (Shadow) Loaded Successfully.")
- def predict(self, text: str):
- if self.model is None:
- return {"error": "V2 Model not initialized"}
+ def predict(self, text: str):
+ if self.model is None:
+ return {"error": "V2 Model not initialized"}
- inputs = self.tokenizer(
- text,
- return_tensors="pt",
- truncation=True,
- padding=True,
- max_length=256 # V2 uses 256
- ).to(self.device)
+ inputs = self.tokenizer(
+ text,
+ return_tensors="pt",
+ truncation=True,
+ padding=True,
+ max_length=256 # V2 uses 256
+ ).to(self.device)
- with torch.no_grad():
- logits = self.model(inputs["input_ids"], inputs["attention_mask"])
-
- results = {}
- for col, le in self.label_encoders.items():
- probs = torch.softmax(logits[col], dim=1)
- conf, pred_idx = torch.max(probs, dim=1)
- results[col] = {
- "prediction": le.inverse_transform([pred_idx.item()])[0],
- "confidence": float(conf.item())
- }
+ with torch.no_grad():
+ logits = self.model(inputs["input_ids"], inputs["attention_mask"])
- # Map V2 'Priority' (capitalized) to generic response
- if "Priority" in results:
- results["priority"] = results.pop("Priority")
-
- return results
-
- # Singleton instance
- classifier_v2 = ClassifierServiceV2()
-else:
- class ClassifierServiceV2:
- def __init__(self):
- self.model = None
- self.tokenizer = None
- self.label_encoders = {}
+ results = {}
+ for col, le in self.label_encoders.items():
+ probs = torch.softmax(logits[col], dim=1)
+ conf, pred_idx = torch.max(probs, dim=1)
+ results[col] = {
+ "prediction": le.inverse_transform([pred_idx.item()])[0],
+ "confidence": float(conf.item())
+ }
+
+ # Map V2 'Priority' (capitalized) to generic response
+ if "Priority" in results:
+ results["priority"] = results.pop("Priority")
- def predict(self, text: str):
- return {"error": "V2 model not available in this environment"}
+ return results
- classifier_v2 = ClassifierServiceV2()
+# Singleton instance
+classifier_v2 = ClassifierServiceV2()
diff --git a/backend/services/classifier_v3.py b/backend/services/classifier_v3.py
index 55b1981402386d37722b642b4fd57bf11366f8fc..49703314f2effe93adc3720117e7c707c2edef0f 100644
--- a/backend/services/classifier_v3.py
+++ b/backend/services/classifier_v3.py
@@ -1,95 +1,75 @@
import os
+import torch
+import torch.nn as nn
import pickle
import json
-try:
- import torch
- import torch.nn as nn
- from transformers import BertTokenizerFast, BertModel
- _HAS_TORCH = True
-except Exception: # pragma: no cover - optional runtime dependency
- torch = None
- nn = None
- BertTokenizerFast = None
- BertModel = None
- _HAS_TORCH = False
+from transformers import BertTokenizerFast, BertModel
# Paths
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
MODEL_DIR = os.path.join(BASE_DIR, "models", "classifier-v3")
-if _HAS_TORCH:
- class MultiOutputClassifierV3(nn.Module):
- def __init__(self, num_labels_per_output: dict):
- super().__init__()
- self.bert = BertModel.from_pretrained("bert-base-uncased")
- hidden = self.bert.config.hidden_size
- self.dropout = nn.Dropout(0.3)
- self.heads = nn.ModuleDict()
- for name, n_labels in num_labels_per_output.items():
- self.heads[name] = nn.Sequential(
- nn.Linear(hidden, 256),
- nn.ReLU(),
- nn.Dropout(0.1),
- nn.Linear(256, n_labels)
- )
+class MultiOutputClassifierV3(nn.Module):
+ def __init__(self, num_labels_per_output: dict):
+ super().__init__()
+ self.bert = BertModel.from_pretrained("bert-base-uncased")
+ hidden = self.bert.config.hidden_size
+ self.dropout = nn.Dropout(0.3)
+ self.heads = nn.ModuleDict()
+ for name, n_labels in num_labels_per_output.items():
+ self.heads[name] = nn.Sequential(
+ nn.Linear(hidden, 256),
+ nn.ReLU(),
+ nn.Dropout(0.1),
+ nn.Linear(256, n_labels)
+ )
- def forward(self, input_ids, attention_mask):
- outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
- pooled_output = outputs.pooler_output
- pooled_output = self.dropout(pooled_output)
- logits = {name: head(pooled_output) for name, head in self.heads.items()}
- return logits
+ def forward(self, input_ids, attention_mask):
+ outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+ pooled_output = outputs.pooler_output
+ pooled_output = self.dropout(pooled_output)
+ logits = {name: head(pooled_output) for name, head in self.heads.items()}
+ return logits
- class ClassifierServiceV3:
- def __init__(self):
- self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
- self.model = None
-
- config_path = os.path.join(MODEL_DIR, "model_config.json")
- if not os.path.exists(config_path):
- print(f"[V3 Service] Model not found yet at {MODEL_DIR}")
- return
+class ClassifierServiceV3:
+ def __init__(self):
+ self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+ self.model = None
+
+ config_path = os.path.join(MODEL_DIR, "model_config.json")
+ if not os.path.exists(config_path):
+ print(f"[V3 Service] Model not found yet at {MODEL_DIR}")
+ return
- with open(config_path, "r") as f:
- self.num_labels = json.load(f)
+ with open(config_path, "r") as f:
+ self.num_labels = json.load(f)
- with open(os.path.join(MODEL_DIR, "label_encoders.pkl"), "rb") as f:
- self.label_encoders = pickle.load(f)
+ with open(os.path.join(MODEL_DIR, "label_encoders.pkl"), "rb") as f:
+ self.label_encoders = pickle.load(f)
- self.model = MultiOutputClassifierV3(self.num_labels).to(self.device)
- self.model.load_state_dict(torch.load(os.path.join(MODEL_DIR, "model.pt"), map_location=self.device))
- self.model.eval()
+ self.model = MultiOutputClassifierV3(self.num_labels).to(self.device)
+ self.model.load_state_dict(torch.load(os.path.join(MODEL_DIR, "model.pt"), map_location=self.device))
+ self.model.eval()
- self.tokenizer = BertTokenizerFast.from_pretrained(MODEL_DIR)
- print("[INFO] Classifier Service V3 (Power Model) Loaded.")
+ self.tokenizer = BertTokenizerFast.from_pretrained(MODEL_DIR)
+ print("[INFO] Classifier Service V3 (Power Model) Loaded.")
- def predict(self, text: str):
- if self.model is None: return {"error": "V3 Model not loaded"}
- inputs = self.tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=256).to(self.device)
- with torch.no_grad():
- logits = self.model(inputs["input_ids"], inputs["attention_mask"])
-
- results = {}
- for col, le in self.label_encoders.items():
- probs = torch.softmax(logits[col], dim=1)
- conf, pred_idx = torch.max(probs, dim=1)
- results[col] = {
- "prediction": le.inverse_transform([pred_idx.item()])[0],
- "confidence": float(conf.item())
- }
+ def predict(self, text: str):
+ if self.model is None: return {"error": "V3 Model not loaded"}
+ inputs = self.tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=256).to(self.device)
+ with torch.no_grad():
+ logits = self.model(inputs["input_ids"], inputs["attention_mask"])
- if "Priority" in results: results["priority"] = results.pop("Priority")
- return results
-
- classifier_v3 = ClassifierServiceV3()
-else:
- class ClassifierServiceV3:
- def __init__(self):
- self.model = None
- self.tokenizer = None
- self.label_encoders = {}
-
- def predict(self, text: str):
- return {"error": "V3 model not available in this environment"}
+ results = {}
+ for col, le in self.label_encoders.items():
+ probs = torch.softmax(logits[col], dim=1)
+ conf, pred_idx = torch.max(probs, dim=1)
+ results[col] = {
+ "prediction": le.inverse_transform([pred_idx.item()])[0],
+ "confidence": float(conf.item())
+ }
+
+ if "Priority" in results: results["priority"] = results.pop("Priority")
+ return results
- classifier_v3 = ClassifierServiceV3()
+classifier_v3 = ClassifierServiceV3()
diff --git a/backend/services/duplicate_service.py b/backend/services/duplicate_service.py
index 75732b46922951a3917b9c58a1e6c107cf1d3210..6a15487323cc905301cef9ec43eac58ee5fbd498 100644
--- a/backend/services/duplicate_service.py
+++ b/backend/services/duplicate_service.py
@@ -7,13 +7,7 @@ import uuid
import os
from typing import Any
-try:
- from sentence_transformers import SentenceTransformer, util
- _HAS_SENTENCE = True
-except Exception: # pragma: no cover - optional runtime dependency
- SentenceTransformer = None
- util = None
- _HAS_SENTENCE = False
+from sentence_transformers import SentenceTransformer, util
SIMILARITY_THRESHOLD = 0.70
@@ -38,17 +32,6 @@ class DuplicateService:
return
print("[DuplicateService] Loading model...")
- if not _HAS_SENTENCE:
- allow_degraded = os.environ.get("ALLOW_DEGRADED_STARTUP", "0") == "1"
- self._load_failed = True
- print("[DuplicateService] sentence-transformers not installed")
- if allow_degraded:
- print("[DuplicateService] DEGRADED: Continuing without model (ALLOW_DEGRADED_STARTUP=1)")
- self.model = None
- self._loaded = False
- return
- else:
- raise ImportError("sentence-transformers is required for DuplicateService")
try:
# Check if a local model path is provided
model_path = os.environ.get("SENTENCE_TRANSFORMER_MODEL_PATH")
@@ -118,20 +101,12 @@ class DuplicateService:
def generate_embedding(self, text: str) -> list[float] | None:
"""Generate a 384-d embedding for the provided ticket text."""
- from backend.services.redis_cache import redis_cache
-
- cached = redis_cache.get_embedding(text)
- if cached is not None:
- return cached
-
self.load()
if not self.is_available():
return None
embedding = self.model.encode(text, convert_to_tensor=False, normalize_embeddings=True)
- values = [float(value) for value in embedding.tolist()]
- redis_cache.set_embedding(text, values)
- return values
+ return [float(value) for value in embedding.tolist()]
def _build_result(
self,
diff --git a/backend/services/gemini_service.py b/backend/services/gemini_service.py
index 9bf257336ecea31a65866ed38ca220659c93dfe1..882aeac8e8c5854ad50ea843a4ff6f3d8c691f16 100644
--- a/backend/services/gemini_service.py
+++ b/backend/services/gemini_service.py
@@ -2,20 +2,11 @@ import os
import base64
import io
import re
-import json
+from PIL import Image
+from google import genai
from dotenv import load_dotenv
from pathlib import Path
-try:
- from PIL import Image
- from google import genai
- _HAS_GEMINI_DEPS = True
-except ImportError:
- Image = None
- genai = None
- _HAS_GEMINI_DEPS = False
-
-
# Load environment variables from backend/.env
env_path = Path(__file__).parent.parent / '.env'
load_dotenv(dotenv_path=env_path)
@@ -26,7 +17,7 @@ class GeminiService:
self._initialized = False
self.model_name = 'gemini-2.5-flash'
- if self.api_key and _HAS_GEMINI_DEPS:
+ if self.api_key:
try:
self.client = genai.Client(api_key=self.api_key)
self._initialized = True
@@ -34,18 +25,15 @@ class GeminiService:
except Exception as e:
print(f"[GeminiService] Initialization Error: {e}")
else:
- if not _HAS_GEMINI_DEPS:
- print("[GeminiService] WARNING: PIL or google-genai package is not installed. Gemini service is disabled.")
- else:
- print("[GeminiService] WARNING: GEMINI_API_KEY not found in environment.")
+ print("[GeminiService] WARNING: GEMINI_API_KEY not found in environment.")
- def analyze_image(self, image_base64: str, context_text: str = None) -> dict:
+ def analyze_image(self, image_base64: str) -> dict:
"""
Perform OCR and image analysis using Gemini logic.
"""
- if not self._initialized or not _HAS_GEMINI_DEPS:
+ if not self._initialized:
return {
- "image_description": "[Gemini Service Offline] Could not analyze image.",
+ "image_description": "[Gemini API Key Missing] Could not analyze image.",
"ocr_text": "",
"detected_problem": ""
}
@@ -58,10 +46,6 @@ class GeminiService:
prompt = (
"Analyze this screenshot from a user reporting a technical issue. "
- )
- if context_text:
- prompt += f"Context/description provided by user: '{context_text}'\n"
- prompt += (
"1. Provide a concise description of what is shown in the image. "
"2. Perform OCR and extract any error messages or key text. "
"3. Identify the main technical problem depicted. "
@@ -238,65 +222,3 @@ class GeminiService:
except Exception as e:
print(f"[GeminiService] Bug Analysis Error: {e}")
return f"Diagnostic analysis failed: {str(e)}"
-
- def detect_language(self, text: str) -> dict:
- """
- Detect language for the given text. Returns ISO-ish language code and English language name.
- """
- if not text or not text.strip():
- return {"code": "en", "name": "English"}
- if not self._initialized:
- return {"code": "en", "name": "English"}
-
- try:
- prompt = (
- "Detect the natural language of the following user message. "
- "Return strict JSON only with keys: code, name. "
- "Example: {\"code\":\"es\",\"name\":\"Spanish\"}.\n\n"
- f"Text:\n{text}"
- )
- response = self.client.models.generate_content(
- model=self.model_name,
- contents=prompt
- )
- raw = (response.text or "").strip()
- match = re.search(r"\{.*\}", raw, re.DOTALL)
- parsed = json.loads(match.group(0) if match else raw)
- code = str(parsed.get("code", "en")).lower()
- name = str(parsed.get("name", "English"))
- if not code:
- code = "en"
- if not name:
- name = "English"
- return {"code": code, "name": name}
- except Exception as e:
- print(f"[GeminiService] Language detection error: {e}")
- return {"code": "en", "name": "English"}
-
- def translate_to_english(self, text: str, source_language: str | None = None) -> str:
- """
- Translate user text to English while preserving technical terms.
- """
- if not text or not text.strip():
- return text
- if not self._initialized:
- return text
-
- try:
- lang_hint = f"Source language: {source_language}. " if source_language else ""
- prompt = (
- "Translate the following support ticket text to natural, concise English. "
- "Preserve technical terms, error codes, product names, and formatting. "
- "Return only translated text with no prefix or explanation. "
- f"{lang_hint}\n\n"
- f"Text:\n{text}"
- )
- response = self.client.models.generate_content(
- model=self.model_name,
- contents=prompt
- )
- translated = (response.text or "").strip()
- return translated or text
- except Exception as e:
- print(f"[GeminiService] Translation error: {e}")
- return text
diff --git a/backend/services/ner_service.py b/backend/services/ner_service.py
index 1e98d384d6ef6737c2298faec1ba42fc001e221f..931ac6bb5857179d476090e238aa3deb3bca5162 100644
--- a/backend/services/ner_service.py
+++ b/backend/services/ner_service.py
@@ -5,20 +5,12 @@ Labels follow pattern: B-B-ENTITY_TYPE, I-B-ENTITY_TYPE, O
import os
import json
-try:
- import torch
- import torch.nn.functional as F
- from transformers import DistilBertTokenizerFast, DistilBertForTokenClassification
- _HAS_TORCH = True
-except Exception: # pragma: no cover - optional runtime dependency
- torch = None
- F = None
- DistilBertTokenizerFast = None
- DistilBertForTokenClassification = None
- _HAS_TORCH = False
+import torch
+import torch.nn.functional as F
+from transformers import DistilBertTokenizerFast, DistilBertForTokenClassification
SAVE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "models", "ner")
-DEVICE = torch.device("cuda" if torch and torch.cuda.is_available() else "cpu") if _HAS_TORCH else None
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
MAX_LEN = 128
import re
@@ -49,10 +41,6 @@ class NERService:
if self._loaded:
return
- if not _HAS_TORCH:
- print("[INFO] NER runtime not available; NER model will remain unloaded until dependencies are installed.")
- return
-
abs_dir = os.path.abspath(SAVE_DIR)
if not os.path.exists(os.path.join(abs_dir, "model.safetensors")):
diff --git a/backend/services/rag_service.py b/backend/services/rag_service.py
index 5099234809843d18c77008729d18b55ee1edea06..089231489e082dd097ba59b08eb6d377c7e7f036 100644
--- a/backend/services/rag_service.py
+++ b/backend/services/rag_service.py
@@ -1,10 +1,5 @@
import os
-try:
- from sentence_transformers import SentenceTransformer
- _HAS_SENTENCE = True
-except Exception: # pragma: no cover - optional runtime dependency
- SentenceTransformer = None
- _HAS_SENTENCE = False
+from sentence_transformers import SentenceTransformer
from supabase import create_client, Client
from dotenv import load_dotenv
@@ -32,17 +27,6 @@ class RagService:
return
print("[RAG] Loading SentenceTransformer for Knowledge Base...")
- if not _HAS_SENTENCE:
- allow_degraded = os.environ.get("ALLOW_DEGRADED_STARTUP", "0") == "1"
- self._load_failed = True
- print("[RAG] sentence-transformers not installed")
- if allow_degraded:
- print("[RAG] DEGRADED: Continuing without model (ALLOW_DEGRADED_STARTUP=1)")
- self.model = None
- self._loaded = False
- return
- else:
- raise ImportError("sentence-transformers is required for RagService")
try:
# Check if a local model path is provided
model_path = os.environ.get("SENTENCE_TRANSFORMER_MODEL_PATH")
diff --git a/backend/services/sla_service.py b/backend/services/sla_service.py
index 0163a2373d4a9b37f069fbeca372b957748782f3..e65e802d80eb703c5a2dc3ff791fae5f49f3369f 100644
--- a/backend/services/sla_service.py
+++ b/backend/services/sla_service.py
@@ -14,10 +14,6 @@ import os
from datetime import datetime, timedelta, timezone
from typing import Any, Callable, Optional
-from fastapi import BackgroundTasks
-
-from backend.sla_checker import dispatch_slack_alert
-
try:
from dotenv import load_dotenv
except ImportError:
@@ -114,12 +110,11 @@ class SlaEscalationService:
now_fn: Callable[[], datetime] = _utc_now,
notification_router: Any = None,
):
- from backend.auth.crypto import wrap_client
- self.supabase = wrap_client(supabase_client)
+ self.supabase = supabase_client
self.now_fn = now_fn
self.notification_router = notification_router
- def run_once(self, background_tasks: BackgroundTasks | None = None) -> dict[str, int | str]:
+ def run_once(self) -> dict[str, int | str]:
stats: dict[str, int | str] = {
"processed_count": 0,
"breached_count": 0,
@@ -141,7 +136,7 @@ class SlaEscalationService:
if not self._should_breach(ticket, now):
stats["skipped_count"] = int(stats["skipped_count"]) + 1
continue
- self._breach_ticket(ticket, now, background_tasks=background_tasks)
+ self._breach_ticket(ticket, now)
stats["breached_count"] = int(stats["breached_count"]) + 1
except Exception as exc:
stats["error_count"] = int(stats["error_count"]) + 1
@@ -174,13 +169,7 @@ class SlaEscalationService:
return False
return classify_sla_status(ticket.get("sla_breach_at"), now) == "BREACHED"
- def _breach_ticket(
- self,
- ticket: dict[str, Any],
- now: datetime,
- *,
- background_tasks: BackgroundTasks | None = None,
- ) -> None:
+ def _breach_ticket(self, ticket: dict[str, Any], now: datetime) -> None:
ticket_id = str(ticket.get("id"))
company_id = ticket.get("company_id")
escalation_level = int(ticket.get("escalation_level") or 0) + 1
@@ -196,7 +185,6 @@ class SlaEscalationService:
self._insert_audit_log(ticket, escalation_level, timestamp)
self._emit_system_message(ticket, escalation_level, timestamp)
- self._dispatch_breach_alert(ticket, now, background_tasks=background_tasks)
logger.warning(
"SLA breached | ticket_id=%s | company_id=%s | priority=%s | level=%s",
@@ -206,31 +194,6 @@ class SlaEscalationService:
escalation_level,
)
- def _dispatch_breach_alert(
- self,
- ticket: dict[str, Any],
- breach_time: datetime,
- *,
- background_tasks: BackgroundTasks | None = None,
- ) -> None:
- ticket_id = str(ticket.get("id") or "")
- subject = str(ticket.get("subject") or "Untitled ticket")
- category = str(ticket.get("priority") or "Uncategorized")
- assignee = str(ticket.get("assigned_team") or "Unassigned")
-
- if background_tasks is not None:
- background_tasks.add_task(
- dispatch_slack_alert,
- ticket_id,
- subject,
- category,
- assignee,
- breach_time,
- )
- return
-
- dispatch_slack_alert(ticket_id, subject, category, assignee, breach_time)
-
def _insert_audit_log(self, ticket: dict[str, Any], escalation_level: int, timestamp: str) -> None:
ticket_id = str(ticket.get("id"))
self.supabase.table("audit_logs").insert(
diff --git a/backend/tests/test_crypto.py b/backend/tests/test_crypto.py
index 06b33ce020f292f4036fcb768de962e758043859..87a645bf028d1ecf30f94d0594d381f4372f7777 100644
--- a/backend/tests/test_crypto.py
+++ b/backend/tests/test_crypto.py
@@ -1,163 +1,69 @@
import os
import unittest
-import base64
from unittest.mock import patch, MagicMock
-# Import the crypto module under test
-import backend.auth.crypto as crypto
+# Set test key
+os.environ["DB_ENCRYPTION_SECRET_KEY"] = "super-secret-test-key-32-bytes"
-class TestCryptographicHooks(unittest.TestCase):
-
- def test_key_derivation_formats(self):
- """Test urlsafe-b64, hex, and SHA-256 stretch key parsing."""
- # 1. Test URL-safe Base64 key parsing (exactly 32 bytes once decoded)
- dummy_32bytes = os.urandom(32)
- b64_key = base64.urlsafe_b64encode(dummy_32bytes).decode('utf-8')
- derived = crypto.derive_cryptographic_key(b64_key)
- self.assertEqual(derived, dummy_32bytes)
+from backend.auth.crypto import encrypt, decrypt, apply_db_encryption_patch
+apply_db_encryption_patch()
- # 2. Test Hex key parsing (exactly 32 bytes once decoded)
- hex_key = dummy_32bytes.hex()
- derived_hex = crypto.derive_cryptographic_key(hex_key)
- self.assertEqual(derived_hex, dummy_32bytes)
+from supabase import create_client
- # 3. Test SHA-256 stretch parsing for arbitrary strings
- raw_key = "my-secret-bounty-key-stretch-test"
- derived_stretch = crypto.derive_cryptographic_key(raw_key)
- self.assertEqual(len(derived_stretch), 32)
-
- def test_encrypt_decrypt_roundtrip(self):
- """Test successful AES-256-GCM encryption and decryption round-trip."""
- # Force active encryption state by mocking AESGCM with a stretched key
- dummy_key = crypto.derive_cryptographic_key("test-key")
- from cryptography.hazmat.primitives.ciphers.aead import AESGCM
- mock_aesgcm = AESGCM(dummy_key)
+class TestCryptoPII(unittest.TestCase):
+ def test_aes_encryption_decryption(self):
+ plain = "sensitive PII text"
+ enc = encrypt(plain)
+ self.assertNotEqual(plain, enc)
- with patch.object(crypto, "ENCRYPTION_ENABLED", True), \
- patch.object(crypto, "_aesgcm", mock_aesgcm):
-
- plaintext = "Secure GDPR/HIPAA ticket content."
- ciphertext = crypto.encrypt_value(plaintext)
-
- # Verify prefix
- self.assertTrue(ciphertext.startswith("enc:v1:"))
- self.assertNotEqual(plaintext, ciphertext)
-
- # Decrypt back
- decrypted = crypto.decrypt_value(ciphertext)
- self.assertEqual(decrypted, plaintext)
-
- def test_double_encryption_protection(self):
- """Test that calling encrypt twice does not double-encrypt the data (no-op)."""
- dummy_key = crypto.derive_cryptographic_key("test-key")
- from cryptography.hazmat.primitives.ciphers.aead import AESGCM
- mock_aesgcm = AESGCM(dummy_key)
+ dec = decrypt(enc)
+ self.assertEqual(plain, dec)
- with patch.object(crypto, "ENCRYPTION_ENABLED", True), \
- patch.object(crypto, "_aesgcm", mock_aesgcm):
-
- plaintext = "Double encrypt check."
- first_encryption = crypto.encrypt_value(plaintext)
- second_encryption = crypto.encrypt_value(first_encryption)
-
- self.assertEqual(first_encryption, second_encryption)
+ def test_graceful_decrypt_plaintext(self):
+ # Decrypting plain text should just return it as-is
+ plain = "not encrypted text"
+ dec = decrypt(plain)
+ self.assertEqual(plain, dec)
- def test_selectivity_of_field_hooks(self):
- """Verify only contact_email, description, and raw_text are encrypted."""
- dummy_key = crypto.derive_cryptographic_key("test-key")
- from cryptography.hazmat.primitives.ciphers.aead import AESGCM
- mock_aesgcm = AESGCM(dummy_key)
+ @patch("httpx.Client.send")
+ def test_transparent_hooks(self, mock_send):
+ import httpx
+ # Initialize client with dummy credentials
+ client = create_client("https://dummy.supabase.co", "apikey")
+ builder = client.table("tickets")
- with patch.object(crypto, "ENCRYPTION_ENABLED", True), \
- patch.object(crypto, "_aesgcm", mock_aesgcm):
-
- payload = {
- "id": 123,
- "subject": "System crash",
- "contact_email": "user@domain.com",
- "description": "Critical exception in auth service",
- "raw_text": "Sensitive logs and stack traces",
- "company_id": "company-99",
- "priority": "critical"
- }
-
- encrypted_payload = crypto.encrypt_payload(payload)
-
- # Target fields must be encrypted
- self.assertTrue(encrypted_payload["contact_email"].startswith("enc:v1:"))
- self.assertTrue(encrypted_payload["description"].startswith("enc:v1:"))
- self.assertTrue(encrypted_payload["raw_text"].startswith("enc:v1:"))
-
- # Non-target fields must remain untouched
- self.assertEqual(encrypted_payload["id"], 123)
- self.assertEqual(encrypted_payload["subject"], "System crash")
- self.assertEqual(encrypted_payload["company_id"], "company-99")
- self.assertEqual(encrypted_payload["priority"], "critical")
-
- # Decrypt back
- decrypted_payload = crypto.decrypt_payload(encrypted_payload)
- self.assertEqual(decrypted_payload, payload)
-
- def test_graceful_degrade_when_no_key_is_set(self):
- """Verify database actions fall back to plaintext pass-through when encryption is disabled."""
- with patch.object(crypto, "ENCRYPTION_ENABLED", False), \
- patch.object(crypto, "_aesgcm", None):
-
- plaintext = "Normal plaintext content."
- encrypted = crypto.encrypt_value(plaintext)
- decrypted = crypto.decrypt_value(encrypted)
-
- self.assertEqual(encrypted, plaintext)
- self.assertEqual(decrypted, plaintext)
-
- # Test selectivity on row also passes through unchanged
- payload = {
- "contact_email": "test@test.com",
- "description": "normal text"
- }
- encrypted_payload = crypto.encrypt_payload(payload)
- self.assertEqual(encrypted_payload, payload)
-
- def test_legacy_data_pass_through_on_read(self):
- """Verify that existing legacy plaintext database values are read as-is without errors."""
- dummy_key = crypto.derive_cryptographic_key("test-key")
- from cryptography.hazmat.primitives.ciphers.aead import AESGCM
- mock_aesgcm = AESGCM(dummy_key)
+ # Test Insert Hook
+ payload = {
+ "contact_email": "pii@email.com",
+ "description": "My secret PII",
+ "raw_text": "Sensitive raw PII"
+ }
- with patch.object(crypto, "ENCRYPTION_ENABLED", True), \
- patch.object(crypto, "_aesgcm", mock_aesgcm):
-
- legacy_plaintext = "Old plaintext ticket from database."
- decrypted = crypto.decrypt_value(legacy_plaintext)
- self.assertEqual(decrypted, legacy_plaintext)
-
- def test_transparent_client_wrapping(self):
- """Test that the WrappedRequestBuilder hooks execute queries correctly."""
- dummy_key = crypto.derive_cryptographic_key("test-key")
- from cryptography.hazmat.primitives.ciphers.aead import AESGCM
- mock_aesgcm = AESGCM(dummy_key)
+ # Mock httpx Response returning encrypted data from server
+ mock_response = httpx.Response(
+ status_code=201,
+ json=[{
+ "id": "1",
+ "contact_email": encrypt("pii@email.com"),
+ "description": encrypt("My secret PII"),
+ "raw_text": encrypt("Sensitive raw PII")
+ }],
+ request=httpx.Request("POST", "https://dummy.supabase.co")
+ )
+ mock_send.return_value = mock_response
+
+ # Call query
+ res = builder.insert(payload).execute()
+
+ # Verify write payload got encrypted before sending
+ self.assertNotEqual(payload["contact_email"], "pii@email.com")
+ self.assertTrue(payload["contact_email"].strip() != "")
- with patch.object(crypto, "ENCRYPTION_ENABLED", True), \
- patch.object(crypto, "_aesgcm", mock_aesgcm):
-
- # Mock table/builder response
- mock_builder = MagicMock()
- mock_builder.insert.return_value = mock_builder
- mock_builder.execute.return_value = MagicMock(data=[
- {"description": crypto.encrypt_value("Success")}
- ])
-
- wrapped = crypto.WrappedRequestBuilder(mock_builder, "tickets")
-
- # Test insert wraps the payload
- payload = {"description": "Sensitive content"}
- res = wrapped.insert(payload)
-
- # The underlying mock insert should receive the encrypted description
- mock_builder.insert.assert_called_once()
- called_arg = mock_builder.insert.call_args[0][0]
- self.assertTrue(called_arg["description"].startswith("enc:v1:"))
-
- # Test execute decrypts the returned data
- exec_res = res.execute()
- self.assertEqual(exec_res.data[0]["description"], "Success")
+ # Verify read response got decrypted
+ self.assertEqual(res.data[0]["contact_email"], "pii@email.com")
+ self.assertEqual(res.data[0]["description"], "My secret PII")
+ self.assertEqual(res.data[0]["raw_text"], "Sensitive raw PII")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/deploy/monitoring/grafana_dashboard.json b/deploy/monitoring/grafana_dashboard.json
index 75be4690d8033213a60f1db25890ef930849ba66..8bdf8a27c5a57fc28a069233b65a9e23b7a62b84 100644
--- a/deploy/monitoring/grafana_dashboard.json
+++ b/deploy/monitoring/grafana_dashboard.json
@@ -9,13 +9,11 @@
},
"enable": true,
"hide": true,
- "iconColor": "rgba(0, 211, 255, 1)",
"name": "Annotations & Alerts",
"type": "dashboard"
}
]
},
- "description": "HELPDESK.AI service telemetry — AI inference latency, API throughput, token counts, and host resources.",
"editable": true,
"fiscalYearStartMonth": 0,
"graphTooltip": 0,
@@ -24,218 +22,152 @@
"liveNow": false,
"panels": [
{
+ "collapsed": false,
+ "gridPos": {
+ "h": 8,
+ "w": 12,
+ "x": 0,
+ "y": 0
+ },
+ "id": 1,
+ "title": "Model Prediction Throughput (Requests / sec)",
+ "type": "timeseries",
"datasource": {
"type": "prometheus",
- "uid": "${DS_PROMETHEUS}"
+ "uid": "prometheus"
},
+ "targets": [
+ {
+ "expr": "sum(rate(model_predictions_total[1m])) by (status)",
+ "legendFormat": "Predictions: {{status}}",
+ "refId": "A"
+ }
+ ],
"fieldConfig": {
"defaults": {
- "color": {"mode": "palette-classic"},
"custom": {
- "axisLabel": "seconds",
"drawStyle": "line",
- "fillOpacity": 10,
- "lineWidth": 2,
- "showPoints": "never"
+ "lineInterpolation": "smooth"
},
- "unit": "s"
- },
- "overrides": []
+ "unit": "reqps"
+ }
+ }
+ },
+ {
+ "collapsed": false,
+ "gridPos": {
+ "h": 8,
+ "w": 12,
+ "x": 12,
+ "y": 0
},
- "gridPos": {"h": 9, "w": 12, "x": 0, "y": 0},
- "id": 1,
- "options": {
- "legend": {"calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom"},
- "tooltip": {"mode": "multi"}
+ "id": 2,
+ "title": "DistilBERT Model Inference Latency",
+ "type": "timeseries",
+ "datasource": {
+ "type": "prometheus",
+ "uid": "prometheus"
},
- "title": "DistilBERT Inference Latency (p50 / p95 / p99)",
"targets": [
{
- "expr": "histogram_quantile(0.50, sum by (le) (rate(ai_classifier_inference_latency_seconds_bucket[5m])))",
- "legendFormat": "p50",
+ "expr": "histogram_quantile(0.95, sum(rate(model_prediction_latency_seconds_bucket[5m])) by (le))",
+ "legendFormat": "p95 Latency",
"refId": "A"
},
{
- "expr": "histogram_quantile(0.95, sum by (le) (rate(ai_classifier_inference_latency_seconds_bucket[5m])))",
- "legendFormat": "p95",
+ "expr": "histogram_quantile(0.99, sum(rate(model_prediction_latency_seconds_bucket[5m])) by (le))",
+ "legendFormat": "p99 Latency",
"refId": "B"
},
{
- "expr": "histogram_quantile(0.99, sum by (le) (rate(ai_classifier_inference_latency_seconds_bucket[5m])))",
- "legendFormat": "p99",
+ "expr": "sum(rate(model_prediction_latency_seconds_sum[5m])) / sum(rate(model_prediction_latency_seconds_count[5m]))",
+ "legendFormat": "Avg Latency",
"refId": "C"
}
],
- "type": "timeseries"
- },
- {
- "datasource": {
- "type": "prometheus",
- "uid": "${DS_PROMETHEUS}"
- },
"fieldConfig": {
"defaults": {
- "color": {"mode": "palette-classic"},
"custom": {
- "axisLabel": "req/s",
"drawStyle": "line",
- "fillOpacity": 10,
- "lineWidth": 2,
- "showPoints": "never"
+ "lineInterpolation": "smooth"
},
- "unit": "reqps"
- },
- "overrides": []
- },
- "gridPos": {"h": 9, "w": 12, "x": 12, "y": 0},
- "id": 2,
- "options": {
- "legend": {"calcs": ["mean"], "displayMode": "table", "placement": "bottom"},
- "tooltip": {"mode": "multi"}
- },
- "title": "Classifier Request Rate (by status)",
- "targets": [
- {
- "expr": "sum by (status) (rate(ai_classifier_inference_requests_total[1m]))",
- "legendFormat": "{{status}}",
- "refId": "A"
+ "unit": "s"
}
- ],
- "type": "timeseries"
+ }
},
{
- "datasource": {
- "type": "prometheus",
- "uid": "${DS_PROMETHEUS}"
- },
- "fieldConfig": {
- "defaults": {
- "color": {"mode": "palette-classic"},
- "custom": {
- "axisLabel": "tokens/s",
- "drawStyle": "line",
- "fillOpacity": 10,
- "lineWidth": 2,
- "showPoints": "never"
- },
- "unit": "short"
- },
- "overrides": []
+ "collapsed": false,
+ "gridPos": {
+ "h": 8,
+ "w": 12,
+ "x": 0,
+ "y": 8
},
- "gridPos": {"h": 9, "w": 12, "x": 0, "y": 9},
"id": 3,
- "options": {
- "legend": {"calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom"},
- "tooltip": {"mode": "multi"}
+ "title": "Backend CPU Usage",
+ "type": "timeseries",
+ "datasource": {
+ "type": "prometheus",
+ "uid": "prometheus"
},
- "title": "Token Throughput (input tokens / sec)",
"targets": [
{
- "expr": "sum by (model) (rate(ai_classifier_input_tokens_total[1m]))",
- "legendFormat": "{{model}}",
+ "expr": "rate(process_cpu_seconds_total[1m]) * 100",
+ "legendFormat": "CPU Usage",
"refId": "A"
}
],
- "type": "timeseries"
- },
- {
- "datasource": {
- "type": "prometheus",
- "uid": "${DS_PROMETHEUS}"
- },
"fieldConfig": {
"defaults": {
- "color": {"mode": "palette-classic"},
"custom": {
- "axisLabel": "bytes",
"drawStyle": "line",
- "fillOpacity": 10,
- "lineWidth": 2,
- "showPoints": "never"
+ "lineInterpolation": "smooth"
},
- "unit": "decbytes"
- },
- "overrides": []
+ "unit": "percent"
+ }
+ }
+ },
+ {
+ "collapsed": false,
+ "gridPos": {
+ "h": 8,
+ "w": 12,
+ "x": 12,
+ "y": 8
},
- "gridPos": {"h": 9, "w": 12, "x": 12, "y": 9},
"id": 4,
- "options": {
- "legend": {"calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom"},
- "tooltip": {"mode": "multi"}
+ "title": "Backend Memory Usage (Resident Set Size)",
+ "type": "timeseries",
+ "datasource": {
+ "type": "prometheus",
+ "uid": "prometheus"
},
- "title": "Process Memory (RSS)",
"targets": [
{
"expr": "process_resident_memory_bytes",
- "legendFormat": "{{instance}}",
+ "legendFormat": "Memory RSS",
"refId": "A"
}
],
- "type": "timeseries"
- },
- {
- "datasource": {
- "type": "prometheus",
- "uid": "${DS_PROMETHEUS}"
- },
"fieldConfig": {
"defaults": {
- "color": {"mode": "palette-classic"},
"custom": {
- "axisLabel": "CPU seconds/sec",
"drawStyle": "line",
- "fillOpacity": 10,
- "lineWidth": 2,
- "showPoints": "never"
+ "lineInterpolation": "smooth"
},
- "unit": "percentunit"
- },
- "overrides": []
- },
- "gridPos": {"h": 9, "w": 24, "x": 0, "y": 18},
- "id": 5,
- "options": {
- "legend": {"calcs": ["mean", "max"], "displayMode": "table", "placement": "bottom"},
- "tooltip": {"mode": "multi"}
- },
- "title": "Process CPU Usage",
- "targets": [
- {
- "expr": "rate(process_cpu_seconds_total[1m])",
- "legendFormat": "{{instance}}",
- "refId": "A"
+ "unit": "bytes"
}
- ],
- "type": "timeseries"
+ }
}
],
- "refresh": "10s",
- "schemaVersion": 38,
+ "schemaVersion": 36,
"style": "dark",
- "tags": ["helpdesk-ai", "fastapi", "ai-inference", "prometheus"],
- "templating": {
- "list": [
- {
- "current": {"selected": false, "text": "Prometheus", "value": "Prometheus"},
- "hide": 0,
- "includeAll": false,
- "label": "Datasource",
- "multi": false,
- "name": "DS_PROMETHEUS",
- "options": [],
- "query": "prometheus",
- "refresh": 1,
- "regex": "",
- "skipUrlSync": false,
- "type": "datasource"
- }
- ]
- },
- "time": {"from": "now-1h", "to": "now"},
- "timepicker": {},
- "timezone": "",
- "title": "HELPDESK.AI — Service Telemetry",
- "uid": "helpdesk-ai-telemetry",
- "version": 1,
+ "tags": [
+ "helpdesk",
+ "monitoring",
+ "ai"
+ ],
+ "title": "FastAPI AI Helpdesk Performance Telemetry",
+ "timezone": "browser",
"weekStart": ""
}
diff --git a/requirements.txt b/requirements.txt
index f2014c0ba584d1a7043fb66ef5d4a7f5e78acca9..027a7ecfa63483eb6b341c26c4b095262fa00321 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,8 +4,6 @@ datasets>=2.14.0
pandas>=2.0.0
scikit-learn>=1.3.0
sentence-transformers>=2.2.0
-onnxruntime>=1.17.0
-tokenizers>=0.15.0
fastapi>=0.104.0
uvicorn>=0.24.0
openpyxl>=3.1.0
@@ -17,11 +15,4 @@ easyocr
slowapi>=0.1.9
supabase==2.22.4
storage3==2.22.4
-redis>=5.0.0
-pytest
-pytest-asyncio
-httpx
-cryptography>=42.0.0
-websockets>=12.0
-prometheus-client>=0.19.0
-
+prometheus-client>=0.17.0
diff --git a/supabase/functions/send-user-approval-email/index.ts b/supabase/functions/send-user-approval-email/index.ts
index 9b599d0356a34910bb17469ad2e83b74cb7de248..baee5ce55a7db5512a9338a02c1cceb45a5daeee 100644
--- a/supabase/functions/send-user-approval-email/index.ts
+++ b/supabase/functions/send-user-approval-email/index.ts
@@ -1,144 +1,69 @@
-import { serve } from "https://deno.land/std@0.177.0/http/server.ts";
+import { serve } from 'https://deno.land/std@0.168.0/http/server.ts';
const corsHeaders = {
- "Access-Control-Allow-Origin": "*",
- "Access-Control-Allow-Methods": "POST, OPTIONS",
- "Access-Control-Allow-Headers":
- "authorization, x-client-info, apikey, content-type",
+ 'Access-Control-Allow-Origin': '*',
+ 'Access-Control-Allow-Methods': 'POST, OPTIONS',
+ 'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
};
-const RESEND_API_KEY = Deno.env.get("RESEND_API_KEY") || "";
-const FROM_EMAIL =
- Deno.env.get("APPROVAL_FROM_EMAIL") ||
- Deno.env.get("RESEND_FROM_EMAIL") ||
- "HELPDESK.AI ";
-const DASHBOARD_URL =
- Deno.env.get("FRONTEND_DASHBOARD_URL") ||
- Deno.env.get("FRONTEND_URL") ||
- "https://helpdeskaiv1.vercel.app/dashboard";
-
-function buildApprovalHtml(name: string, company: string): string {
- const safeName = name || "there";
- const safeCompany = company || "your organization";
- return `
-
-
-
-
-
-
- HELPDESK.AI
- Account Approved
-
-
-
-
- Hello ${safeName},
-
- Your account for ${safeCompany} has been approved by your administrator.
- You can now sign in and access your dashboard.
-
-
-
-
-
-
- © 2026 HELPDESK.AI
-
-
-
-
-
-`;
-}
-
serve(async (req) => {
- if (req.method === "OPTIONS") {
- return new Response(null, { status: 204, headers: corsHeaders });
- }
-
- try {
- const { userId, email, name, company } = await req.json();
-
- if (!email) {
- throw new Error("Email is required");
+ // Handle CORS preflight requests
+ if (req.method === 'OPTIONS') {
+ return new Response(null, { status: 204, headers: corsHeaders });
}
- if (!RESEND_API_KEY) {
- console.warn(
- `[send-user-approval-email] RESEND_API_KEY missing — cannot send to ${email}`,
- );
- return new Response(
- JSON.stringify({
- success: false,
- error: "RESEND_API_KEY is not configured",
- userId: userId ?? null,
- }),
- {
- status: 503,
- headers: { ...corsHeaders, "Content-Type": "application/json" },
- },
- );
- }
+ try {
+ const { userId, email, name, company } = await req.json();
- console.log(
- `[send-user-approval-email] Sending approval email to ${email} (user=${userId ?? "unknown"})`,
- );
+ if (!email) {
+ throw new Error('Email is required');
+ }
- const res = await fetch("https://api.resend.com/emails", {
- method: "POST",
- headers: {
- "Content-Type": "application/json",
- Authorization: `Bearer ${RESEND_API_KEY}`,
- },
- body: JSON.stringify({
- from: FROM_EMAIL,
- to: [email],
- subject: "Account Approved — Welcome to HELPDESK.AI",
- html: buildApprovalHtml(name, company),
- }),
- });
+ // Initialize Resend or another mail provider (Assuming user configures this later)
+ // const RESEND_API_KEY = Deno.env.get('RESEND_API_KEY');
+ // Currently simulating a successfully sent email.
- const data = await res.json();
+ console.log(`Sending approval email to ${email} for user ${name} in company ${company}...`);
- if (!res.ok) {
- console.error("[send-user-approval-email] Resend error:", data);
- return new Response(
- JSON.stringify({
- success: false,
- error: data?.message || "Failed to send approval email",
- details: data,
- }),
- {
- status: res.status,
- headers: { ...corsHeaders, "Content-Type": "application/json" },
- },
- );
- }
+ // The email content could be sent via Resend:
+ /*
+ const res = await fetch('https://api.resend.com/emails', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${RESEND_API_KEY}`,
+ },
+ body: JSON.stringify({
+ from: 'HelpDesk.ai ',
+ to: [email],
+ subject: 'Account Approved! Welcome to HelpDesk.ai',
+ html: `
+ Hello ${name},
+ Your account for ${company} has been approved by your administrator!
+ You can now log in to the system and access your dashboard.
+ Go to Dashboard
+ `
+ })
+ });
+ */
- return new Response(
- JSON.stringify({
- success: true,
- message: `Approval email sent to ${email}`,
- resendId: data?.id ?? null,
- }),
- {
- status: 200,
- headers: { ...corsHeaders, "Content-Type": "application/json" },
- },
- );
- } catch (error) {
- const message = error instanceof Error ? error.message : String(error);
- return new Response(JSON.stringify({ success: false, error: message }), {
- status: 400,
- headers: { ...corsHeaders, "Content-Type": "application/json" },
- });
- }
+ return new Response(
+ JSON.stringify({
+ success: true,
+ message: `Approval email simulated for ${email}`
+ }),
+ {
+ status: 200,
+ headers: { ...corsHeaders, 'Content-Type': 'application/json' }
+ }
+ );
+ } catch (error) {
+ return new Response(
+ JSON.stringify({ error: error.message }),
+ {
+ status: 400,
+ headers: { ...corsHeaders, 'Content-Type': 'application/json' }
+ }
+ );
+ }
});
diff --git a/supabase/migrations/20260522080000_add_sla_escalation.sql b/supabase/migrations/20260522080000_add_sla_escalation.sql
index 34248dbdb93cd9f8011f34c4dc2b57836bdace46..f5ad2bf7335f7d433af2aed55703585672755b5f 100644
--- a/supabase/migrations/20260522080000_add_sla_escalation.sql
+++ b/supabase/migrations/20260522080000_add_sla_escalation.sql
@@ -43,7 +43,7 @@ CREATE POLICY "Service role full audit access" ON audit_logs
CREATE POLICY "Admins can view own company audit logs" ON audit_logs
FOR SELECT USING (
company_id IN (
- SELECT company_id FROM profiles WHERE id = auth.uid()
+ SELECT company_id FROM user_companies WHERE user_id = auth.uid()
)
);
diff --git a/supabase/migrations/20260531_add_company_settings.sql b/supabase/migrations/20260531_add_company_settings.sql
index dab8ceb7186c5791311c06c59453dfa2471c8f28..fd4c57390af67ed3298cd53189cdceb7a6893925 100644
--- a/supabase/migrations/20260531_add_company_settings.sql
+++ b/supabase/migrations/20260531_add_company_settings.sql
@@ -17,23 +17,6 @@ CREATE TABLE system_settings (
admin_alerts BOOLEAN NOT NULL DEFAULT TRUE,
digest_frequency TEXT NOT NULL DEFAULT 'daily' CHECK (digest_frequency IN ('daily', 'weekly')),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
--- Create system_settings table for storing per-company system configuration
-
--- NOTE: migration filename contains 'add_company_settings'. The migration now creates
--- `system_settings` per the unified schema; filename unchanged for migration ordering.
-
-CREATE TABLE IF NOT EXISTS system_settings (
- company_id UUID PRIMARY KEY,
- ai_confidence_threshold FLOAT DEFAULT 0.80,
- duplicate_sensitivity FLOAT DEFAULT 0.85,
- enable_auto_resolve BOOLEAN DEFAULT FALSE,
- auto_close_enabled BOOLEAN DEFAULT TRUE,
- auto_close_days INTEGER DEFAULT 7,
- email_notifications BOOLEAN DEFAULT TRUE,
- admin_alerts BOOLEAN DEFAULT TRUE,
- digest_frequency TEXT DEFAULT 'daily',
- created_at TIMESTAMPTZ DEFAULT NOW(),
- updated_at TIMESTAMPTZ DEFAULT NOW()
);
-- Enable Row Level Security
@@ -54,49 +37,6 @@ CREATE POLICY "Company members can manage own settings" ON system_settings
)
);
-CREATE POLICY "Admins can view own company settings" ON system_settings
- FOR SELECT USING (
- company_id IN (
- SELECT company_id FROM profiles
- WHERE id = auth.uid()
- AND role IN ('admin', 'super_admin', 'master_admin')
- )
- );
-
--- Admins can create and update settings for their own company from the dashboard.
-CREATE POLICY "Admins can insert own company settings" ON system_settings
- FOR INSERT WITH CHECK (
- company_id IN (
- SELECT company_id FROM profiles
- WHERE id = auth.uid()
- AND role IN ('admin', 'super_admin', 'master_admin')
- )
- );
-
-CREATE POLICY "Admins can update own company settings" ON system_settings
- FOR UPDATE USING (
- company_id IN (
- SELECT company_id FROM profiles
- WHERE id = auth.uid()
- AND role IN ('admin', 'super_admin', 'master_admin')
- )
- )
- WITH CHECK (
- company_id IN (
- SELECT company_id FROM profiles
- WHERE id = auth.uid()
- AND role IN ('admin', 'super_admin', 'master_admin')
- )
- );
-
-CREATE OR REPLACE FUNCTION update_timestamp()
-RETURNS TRIGGER AS $$
-BEGIN
- NEW.updated_at = NOW();
- RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-- Trigger to auto-update updated_at on modification
CREATE OR REPLACE FUNCTION update_system_settings_timestamp()
RETURNS TRIGGER LANGUAGE plpgsql AS $$