@primocaredentgroup/elettromedicali 0.1.0 → 0.1.1

package/src/component/userProfiles.ts

@@ -1,319 +1,129 @@
 import { v } from 'convex/values';
 import { query, mutation } from './_generated/server';
-import { paginationOptsValidator } from 'convex/server';
 
 export const getUserProfile = query({
   args: { auth0Id: v.string() },
   handler: async (ctx, args) => {
-    const profile = await ctx.db
+    return await ctx.db
       .query('user_profiles')
       .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.auth0Id))
       .first();
-
-    return profile;
   },
 });
 
 export const getCurrentUserProfile = query({
-  args: { auth0Id: v.string() },
+  args: {
+    auth0Id: v.string(),
+    userName: v.optional(v.string()),
+    userEmail: v.optional(v.string()),
+    userRole: v.optional(v.string()),
+    userIsActive: v.optional(v.boolean()),
+  },
   handler: async (ctx, args) => {
-    const realProfile = await ctx.db
+    const settings = await ctx.db
       .query('user_profiles')
       .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.auth0Id))
       .first();
 
-    if (!realProfile) {
+    if (!settings) {
       return null;
     }
 
-    if (realProfile.isActive === false) {
+    if (args.userIsActive === false) {
       return {
-        ...realProfile,
+        ...settings,
+        name: args.userName,
+        email: args.userEmail,
         role: null,
         isDisabled: true,
         isImpersonating: false,
       };
     }
 
-    const realRole = realProfile.roleId ? await ctx.db.get(realProfile.roleId) : null;
-    const isAdmin = realRole?.name === 'admin';
+    const isAdmin = args.userRole === 'admin';
 
-    if (isAdmin && realProfile.impersonatingUserId) {
-      const impersonatedProfile = await ctx.db.get(realProfile.impersonatingUserId);
-      
-      if (impersonatedProfile) {
-        const impersonatedRole = impersonatedProfile.roleId 
-          ? await ctx.db.get(impersonatedProfile.roleId) 
-          : null;
+    if (isAdmin && settings.impersonatingUserId) {
+      const impersonatedSettings = await ctx.db
+        .query('user_profiles')
+        .withIndex('by_auth0Id', (q) => q.eq('auth0Id', settings.impersonatingUserId!))
+        .first();
 
+      if (impersonatedSettings) {
         return {
-          ...impersonatedProfile,
-          role: impersonatedRole?.name,
+          ...impersonatedSettings,
+          role: undefined,
           isImpersonating: true,
-          realAdminId: realProfile._id,
-          realAdminName: realProfile.name || realProfile.email,
-          realAdminEmail: realProfile.email,
+          realAdminId: settings._id,
+          realAdminName: args.userName,
+          realAdminEmail: args.userEmail,
           isDisabled: false,
         };
       }
     }
 
     return {
-      ...realProfile,
-      role: realRole?.name,
+      ...settings,
+      name: args.userName,
+      email: args.userEmail,
+      role: args.userRole,
       isImpersonating: false,
       isDisabled: false,
     };
   },
 });
 
-function isPlaceholderAuth0Id(auth0Id: string): boolean {
-  return auth0Id.startsWith('placeholder_') || 
-         auth0Id.startsWith('manual_') || 
-         !auth0Id.includes('|');
-}
-
 export const upsertUserProfile = mutation({
   args: {
     auth0Id: v.string(),
-    email: v.string(),
-    name: v.optional(v.string()),
-    roleName: v.optional(v.string()),
-    clinicId: v.optional(v.id('clinics')),
+    clinicId: v.optional(v.string()),
     supplierId: v.optional(v.id('suppliers')),
   },
   handler: async (ctx, args) => {
-    let existing = await ctx.db
+    const existing = await ctx.db
       .query('user_profiles')
       .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.auth0Id))
       .first();
 
-    let shouldUpdateAuth0Id = false;
-    if (!existing) {
-      const existingByEmail = await ctx.db
-        .query('user_profiles')
-        .withIndex('by_email', (q) => q.eq('email', args.email))
-        .first();
-      
-      if (existingByEmail && isPlaceholderAuth0Id(existingByEmail.auth0Id)) {
-        existing = existingByEmail;
-        shouldUpdateAuth0Id = true;
-        console.log(`🔄 Found pre-created user with email ${args.email}, updating auth0Id from placeholder to real Auth0 ID`);
-      }
-    }
-
-    let roleId = existing?.roleId;
-    if (args.roleName || !roleId) {
-      const roleName = args.roleName || 'user';
-      let role = await ctx.db
-        .query('roles')
-        .withIndex('by_name', (q) => q.eq('name', roleName))
-        .first();
-      
-      if (!role) {
-        const newRoleId = await ctx.db.insert('roles', {
-          name: roleName,
-          description: roleName === 'admin' ? 'Administrator with full access' : 
-                      roleName === 'user' ? 'Standard user with limited access' :
-                      roleName === 'supplier' ? 'Supplier with access to assigned tickets' :
-                      `${roleName} role`,
-          createdAt: Date.now(),
-        });
-        role = await ctx.db.get(newRoleId);
-      }
-      
-      if (role) {
-        roleId = role._id;
-      }
-    }
-
     if (existing) {
-      const updateData: any = {
-        email: args.email,
-        name: args.name,
-        ...(args.clinicId && { clinicId: args.clinicId }),
-        ...(args.supplierId && { supplierId: args.supplierId }),
-      };
-      
-      if (shouldUpdateAuth0Id) {
-        updateData.auth0Id = args.auth0Id;
-        console.log(`✅ Updated auth0Id for user ${args.email}`);
-      }
-      
-      if (roleId) {
-        updateData.roleId = roleId;
+      const updateData: any = {};
+      if (args.clinicId !== undefined) updateData.clinicId = args.clinicId;
+      if (args.supplierId !== undefined) updateData.supplierId = args.supplierId;
+      if (Object.keys(updateData).length > 0) {
+        await ctx.db.patch(existing._id, updateData);
       }
-      await ctx.db.patch(existing._id, updateData);
       return existing._id;
     } else {
-      const newProfile: any = {
+      const profileId = await ctx.db.insert('user_profiles', {
         auth0Id: args.auth0Id,
-        email: args.email,
-        name: args.name,
         ...(args.clinicId && { clinicId: args.clinicId }),
         ...(args.supplierId && { supplierId: args.supplierId }),
-      };
-      if (roleId) {
-        newProfile.roleId = roleId;
-      }
-      const profileId = await ctx.db.insert('user_profiles', newProfile);
+      });
       return profileId;
     }
   },
 });
 
-export const updateUserRole = mutation({
-  args: {
-    userId: v.id('user_profiles'),
-    roleName: v.string(),
-    clinicId: v.optional(v.id('clinics')),
-    supplierId: v.optional(v.id('suppliers')),
-  },
-  handler: async (ctx, args) => {
-    const newRole = await ctx.db
-      .query('roles')
-      .withIndex('by_name', (q) => q.eq('name', args.roleName))
-      .first();
-
-    if (!newRole) {
-      throw new Error(`Role ${args.roleName} not found`);
-    }
-
-    await ctx.db.patch(args.userId, {
-      roleId: newRole._id,
-      ...(args.clinicId !== undefined && { clinicId: args.clinicId }),
-      ...(args.supplierId !== undefined && { supplierId: args.supplierId }),
-    });
-
-    return args.userId;
-  },
-});
-
 export const updateUserSupplier = mutation({
   args: {
-    userId: v.id('user_profiles'),
+    userId: v.string(),
     supplierId: v.id('suppliers'),
   },
   handler: async (ctx, args) => {
-    await ctx.db.patch(args.userId, {
-      supplierId: args.supplierId,
-    });
-
-    return args.userId;
+    const profile = await ctx.db
+      .query('user_profiles')
+      .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.userId))
+      .first();
+    if (!profile) throw new Error('User settings not found');
+    await ctx.db.patch(profile._id, { supplierId: args.supplierId });
+    return profile._id;
   },
 });
 
 export const listUsers = query({
-  args: {
-    limit: v.optional(v.number()),
-  },
+  args: { limit: v.optional(v.number()) },
   handler: async (ctx, args) => {
     const maxResults = args.limit || 500;
-    const users = await ctx.db.query('user_profiles').order('desc').take(maxResults);
-    
-    const usersWithRoles = await Promise.all(
-      users.map(async (user) => {
-        const role = user.roleId ? await ctx.db.get(user.roleId) : null;
-        return {
-          ...user,
-          role: role?.name || user.role,
-        };
-      })
-    );
-
-    return usersWithRoles;
-  },
-});
-
-export const listUsersPaginated = query({
-  args: {
-    paginationOpts: paginationOptsValidator,
-    roleId: v.optional(v.id('roles')),
-    isActive: v.optional(v.boolean()),
-    searchTerm: v.optional(v.string()),
-  },
-  handler: async (ctx, args) => {
-    let baseQuery;
-    
-    if (args.roleId) {
-      baseQuery = ctx.db
-        .query('user_profiles')
-        .withIndex('by_roleId', (q: any) => q.eq('roleId', args.roleId));
-    } else if (args.isActive !== undefined) {
-      baseQuery = ctx.db
-        .query('user_profiles')
-        .withIndex('by_isActive', (q: any) => q.eq('isActive', args.isActive));
-    } else {
-      baseQuery = ctx.db.query('user_profiles');
-    }
-
-    let filteredQuery = baseQuery.order('desc');
-    
-    if (args.isActive !== undefined && args.roleId) {
-      filteredQuery = filteredQuery.filter((q: any) => q.eq(q.field('isActive'), args.isActive));
-    }
-
-    const result = await filteredQuery.paginate(args.paginationOpts);
-
-    let filteredPage = result.page;
-    
-    if (args.searchTerm) {
-      const search = args.searchTerm.toLowerCase();
-      filteredPage = filteredPage.filter((user: any) => 
-        user.name?.toLowerCase().includes(search) ||
-        user.email?.toLowerCase().includes(search)
-      );
-    }
-
-    const roleIds = [...new Set(filteredPage.map((u: any) => u.roleId).filter(Boolean))];
-    const roles = await Promise.all(roleIds.map(id => ctx.db.get(id)));
-    const roleMap = new Map(roles.filter(Boolean).map((r: any) => [r._id.toString(), r.name]));
-
-    const minimalPage = filteredPage.map((user: any) => ({
-      _id: user._id,
-      auth0Id: user.auth0Id,
-      email: user.email,
-      name: user.name,
-      roleId: user.roleId,
-      role: roleMap.get(user.roleId?.toString()) || user.role || 'user',
-      isActive: user.isActive,
-      clinicId: user.clinicId,
-      supplierId: user.supplierId,
-      createdAt: user.createdAt || user._creationTime,
-    }));
-
-    return {
-      page: minimalPage,
-      isDone: result.isDone,
-      continueCursor: result.continueCursor,
-    };
-  },
-});
-
-export const getUsersCount = query({
-  args: {
-    roleId: v.optional(v.id('roles')),
-    isActive: v.optional(v.boolean()),
-  },
-  handler: async (ctx, args) => {
-    let query;
-    
-    if (args.roleId) {
-      query = ctx.db.query('user_profiles')
-        .withIndex('by_roleId', (q: any) => q.eq('roleId', args.roleId));
-    } else if (args.isActive !== undefined) {
-      query = ctx.db.query('user_profiles')
-        .withIndex('by_isActive', (q: any) => q.eq('isActive', args.isActive));
-    } else {
-      query = ctx.db.query('user_profiles');
-    }
-
-    if (args.isActive !== undefined && args.roleId) {
-      query = query.filter((q: any) => q.eq(q.field('isActive'), args.isActive));
-    }
-
-    const users = await query.take(1000);
-    return { total: users.length };
+    return await ctx.db.query('user_profiles').order('desc').take(maxResults);
   },
 });
 
@@ -364,9 +174,7 @@ export const getPrimoUPToken = query({
       )
       .first();
 
-    if (!activeToken) {
-      return null;
-    }
+    if (!activeToken) return null;
 
     if (activeToken.expiresAt && activeToken.expiresAt < Date.now()) {
       return {
@@ -404,7 +212,6 @@ export const logPrimoUPAccess = mutation({
       timestamp: Date.now(),
       metadata: args.metadata,
     });
-
     return { success: true };
   },
 });
@@ -418,51 +225,11 @@ export const getPrimoUPAccessLogs = query({
   },
   handler: async (ctx, args) => {
     const targetUserId = args.isAdmin && args.userId ? args.userId : args.auth0Id;
-
-    const logs = await ctx.db
+    return await ctx.db
       .query('primoup_access_logs')
       .withIndex('by_userId_timestamp', (q) => q.eq('userId', targetUserId))
       .order('desc')
       .take(args.limit || 50);
-
-    return logs;
-  },
-});
-
-export const updateUserRoleByEmail = mutation({
-  args: {
-    email: v.string(),
-    roleName: v.string(),
-  },
-  handler: async (ctx, args) => {
-    const user = await ctx.db
-      .query('user_profiles')
-      .filter((q) => q.eq(q.field('email'), args.email))
-      .first();
-
-    if (!user) {
-      throw new Error(`User with email ${args.email} not found`);
-    }
-
-    const role = await ctx.db
-      .query('roles')
-      .withIndex('by_name', (q) => q.eq('name', args.roleName))
-      .first();
-
-    if (!role) {
-      throw new Error(`Role ${args.roleName} not found`);
-    }
-
-    await ctx.db.patch(user._id, {
-      roleId: role._id,
-    });
-
-    return {
-      success: true,
-      userId: user._id,
-      email: user.email,
-      newRole: args.roleName,
-    };
   },
 });
 
@@ -477,9 +244,7 @@ export const saveUserClinics = mutation({
       .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.auth0Id))
       .first();
 
-    if (!profile) {
-      throw new Error('User profile not found');
-    }
+    if (!profile) throw new Error('User settings not found');
 
     const optimizedClinics = args.primoupClinics.map((clinic: any) => ({
       id: clinic.id,
@@ -509,41 +274,20 @@ export const updateSelectedClinic = mutation({
       .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.auth0Id))
       .first();
 
-    if (!profile) {
-      throw new Error('User profile not found');
-    }
+    if (!profile) throw new Error('User settings not found');
 
     if (profile.primoupClinics) {
       const hasClinic = profile.primoupClinics.some((clinic: any) => clinic.id === args.clinicId);
-      if (!hasClinic) {
-        throw new Error('Clinic not found in user clinics');
-      }
+      if (!hasClinic) throw new Error('Clinic not found in user clinics');
     }
 
-    const clinic = await ctx.db
-      .query('clinics')
-      .withIndex('by_primoupId', (q) => q.eq('primoupId', args.clinicId.toString()))
-      .first();
-
-    if (!clinic) {
-      console.warn(`⚠️ Clinic NOT FOUND in Convex with primoupId: ${args.clinicId}`);
-      const newCounter = (profile.clinicChangeCounter || 0) + 1;
-      await ctx.db.patch(profile._id, {
-        selectedClinicId: args.clinicId,
-        clinicId: undefined,
-        clinicChangeCounter: newCounter,
-      });
-      return profile._id;
-    }
-    
     const newCounter = (profile.clinicChangeCounter || 0) + 1;
-    
+
     await ctx.db.patch(profile._id, {
       selectedClinicId: args.clinicId,
-      clinicId: clinic._id,
       clinicChangeCounter: newCounter,
     });
-    
+
     return profile._id;
   },
 });
@@ -551,7 +295,7 @@ export const updateSelectedClinic = mutation({
 export const startImpersonation = mutation({
   args: {
     auth0Id: v.string(),
-    targetUserId: v.id('user_profiles'),
+    targetUserAuth0Id: v.string(),
   },
   handler: async (ctx, args) => {
     const currentUser = await ctx.db
@@ -559,36 +303,24 @@ export const startImpersonation = mutation({
       .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.auth0Id))
       .first();
 
-    if (!currentUser) {
-      throw new Error('User profile not found');
-    }
+    if (!currentUser) throw new Error('User settings not found');
 
-    const currentRole = currentUser.roleId ? await ctx.db.get(currentUser.roleId) : null;
-    if (!currentRole || currentRole.name !== 'admin') {
-      throw new Error('Solo gli amministratori possono impersonare altri utenti');
-    }
+    const targetUser = await ctx.db
+      .query('user_profiles')
+      .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.targetUserAuth0Id))
+      .first();
 
-    const targetUser = await ctx.db.get(args.targetUserId);
-    if (!targetUser) {
-      throw new Error('Utente target non trovato');
-    }
+    if (!targetUser) throw new Error('Target user settings not found');
 
     if (targetUser._id === currentUser._id) {
       throw new Error('Non puoi impersonare te stesso');
     }
 
     await ctx.db.patch(currentUser._id, {
-      impersonatingUserId: args.targetUserId,
+      impersonatingUserId: args.targetUserAuth0Id,
     });
 
-    return {
-      success: true,
-      impersonatedUser: {
-        id: targetUser._id,
-        name: targetUser.name,
-        email: targetUser.email,
-      },
-    };
+    return { success: true };
   },
 });
 
@@ -600,14 +332,7 @@ export const stopImpersonation = mutation({
       .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.auth0Id))
       .first();
 
-    if (!currentUser) {
-      throw new Error('User profile not found');
-    }
-
-    const currentRole = currentUser.roleId ? await ctx.db.get(currentUser.roleId) : null;
-    if (!currentRole || currentRole.name !== 'admin') {
-      throw new Error('Solo gli amministratori possono terminare l\'impersonazione');
-    }
+    if (!currentUser) throw new Error('User settings not found');
 
     await ctx.db.patch(currentUser._id, {
       impersonatingUserId: undefined,
@@ -617,108 +342,6 @@ export const stopImpersonation = mutation({
   },
 });
 
-export const updateUserProfile = mutation({
-  args: {
-    userId: v.id('user_profiles'),
-    name: v.optional(v.string()),
-    email: v.optional(v.string()),
-    roleName: v.optional(v.string()),
-    clinicId: v.optional(v.id('clinics')),
-    supplierId: v.optional(v.id('suppliers')),
-  },
-  handler: async (ctx, args) => {
-    const targetUser = await ctx.db.get(args.userId);
-    if (!targetUser) {
-      throw new Error('Target user not found');
-    }
-
-    const updateData: Record<string, any> = {};
-
-    if (args.name !== undefined) {
-      updateData.name = args.name;
-    }
-
-    if (args.email !== undefined) {
-      const existingUser = await ctx.db
-        .query('user_profiles')
-        .withIndex('by_email', (q) => q.eq('email', args.email!))
-        .first();
-      
-      if (existingUser && existingUser._id !== args.userId) {
-        throw new Error('Email già in uso da un altro utente');
-      }
-      updateData.email = args.email;
-    }
-
-    if (args.roleName !== undefined) {
-      const newRole = await ctx.db
-        .query('roles')
-        .withIndex('by_name', (q) => q.eq('name', args.roleName!))
-        .first();
-      
-      if (!newRole) {
-        throw new Error(`Ruolo ${args.roleName} non trovato`);
-      }
-      updateData.roleId = newRole._id;
-    }
-
-    if (args.clinicId !== undefined) {
-      updateData.clinicId = args.clinicId;
-    }
-
-    if (args.supplierId !== undefined) {
-      updateData.supplierId = args.supplierId;
-    }
-
-    if (Object.keys(updateData).length > 0) {
-      await ctx.db.patch(args.userId, updateData);
-    }
-
-    return args.userId;
-  },
-});
-
-export const disableUser = mutation({
-  args: {
-    userId: v.id('user_profiles'),
-    callerUserId: v.optional(v.id('user_profiles')),
-  },
-  handler: async (ctx, args) => {
-    if (args.callerUserId && args.userId === args.callerUserId) {
-      throw new Error('Non puoi disabilitare te stesso');
-    }
-
-    const targetUser = await ctx.db.get(args.userId);
-    if (!targetUser) {
-      throw new Error('Utente non trovato');
-    }
-
-    await ctx.db.patch(args.userId, {
-      isActive: false,
-    });
-
-    return { success: true, userId: args.userId };
-  },
-});
-
-export const enableUser = mutation({
-  args: {
-    userId: v.id('user_profiles'),
-  },
-  handler: async (ctx, args) => {
-    const targetUser = await ctx.db.get(args.userId);
-    if (!targetUser) {
-      throw new Error('Utente non trovato');
-    }
-
-    await ctx.db.patch(args.userId, {
-      isActive: true,
-    });
-
-    return { success: true, userId: args.userId };
-  },
-});
-
 export const getRealAdminProfile = query({
   args: { auth0Id: v.string() },
   handler: async (ctx, args) => {
@@ -727,17 +350,10 @@ export const getRealAdminProfile = query({
       .withIndex('by_auth0Id', (q) => q.eq('auth0Id', args.auth0Id))
       .first();
 
-    if (!profile) {
-      return null;
-    }
+    if (!profile) return null;
 
-    const role = profile.roleId ? await ctx.db.get(profile.roleId) : null;
-    
     return {
       _id: profile._id,
-      name: profile.name,
-      email: profile.email,
-      role: role?.name,
       isImpersonating: !!profile.impersonatingUserId,
       impersonatingUserId: profile.impersonatingUserId,
     };