delete user

Author: calebbourg

src/components/ui/members/member-card.tsx

@@ -1,18 +1,73 @@
+import { useOrganizationStateStore } from "@/lib/providers/organization-state-store-provider";
+import { useAuthStore } from "@/lib/providers/auth-store-provider";
+import { useUserMutation } from "@/lib/api/organizations/users";
+import { Button } from "@/components/ui/button";
+import { Trash2 } from "lucide-react";
+import { CoachingRelationshipWithUserNames } from "@/types/coaching_relationship_with_user_names";
+import { OrganizationStateStore } from "@/lib/stores/organization-state-store";
+import { AuthStore } from "@/lib/stores/auth-store";
+
 interface MemberCardProps {
   firstName: string;
   lastName: string;
   email?: string;
+  userId: string;
+  userRelationships: CoachingRelationshipWithUserNames[];
+  onRefresh: () => void;
 }
 
-export function MemberCard({ firstName, lastName, email }: MemberCardProps) {
+export function MemberCard({
+  firstName,
+  lastName,
+  email,
+  userId,
+  userRelationships,
+  onRefresh,
+}: MemberCardProps) {
+  const currentOrganizationId = useOrganizationStateStore(
+    (state: OrganizationStateStore) => state.currentOrganizationId
+  );
+  const { userSession } = useAuthStore((state: AuthStore) => state);
+  const { deleteNested: deleteUser } = useUserMutation(currentOrganizationId);
+
+  // Check if current user is a coach in any of this user's relationships
+  // and make sure we can't delete ourselves
+  const canDeleteUser = userRelationships.some(
+    (rel) => rel.coach_id === userSession.id && userId !== userSession.id
+  );
+
+  const handleDelete = async () => {
+    if (!confirm("Are you sure you want to delete this member?")) {
+      return;
+    }
+
+    try {
+      await deleteUser(currentOrganizationId, userId);
+      onRefresh(); // Call refresh after successful deletion
+    } catch (error) {
+      console.error("Error deleting user:", error);
+      // You might want to show an error toast here
+    }
+  };
+
   return (
-    <div className="flex items-center p-4 hover:bg-accent/50 transition-colors cursor-pointer">
+    <div className="flex items-center p-4 hover:bg-accent/50 transition-colors">
       <div className="flex-1">
         <h3 className="font-medium">
           {firstName} {lastName}
         </h3>
         {email && <p className="text-sm text-muted-foreground">{email}</p>}
       </div>
+      {canDeleteUser && (
+        <Button
+          variant="ghost"
+          size="icon"
+          onClick={handleDelete}
+          className="text-destructive hover:text-destructive"
+        >
+          <Trash2 className="h-4 w-4" />
+        </Button>
+      )}
     </div>
   );
 }

src/components/ui/members/member-container.tsx

@@ -63,7 +63,11 @@ export function MemberContainer({
           />
         )}
       </div>
-      <MemberList users={associatedUsers} />
+      <MemberList
+        users={associatedUsers}
+        relationships={userRelationships}
+        onRefresh={onRefresh}
+      />
     </div>
   );
 }

src/components/ui/members/member-list.tsx

@@ -1,12 +1,27 @@
 import { Card, CardContent } from "@/components/ui/card";
 import { User } from "@/types/user";
 import { MemberCard } from "./member-card";
+import { CoachingRelationshipWithUserNames } from "@/types/coaching_relationship_with_user_names";
 
 interface MemberListProps {
   users: User[];
+  relationships: CoachingRelationshipWithUserNames[];
+  onRefresh: () => void;
 }
 
-export function MemberList({ users }: MemberListProps) {
+export function MemberList({
+  users,
+  relationships,
+  onRefresh,
+}: MemberListProps) {
+  // Create a mapping of user IDs to their associated relationships
+  const userRelationshipsMap = users.reduce((acc, user) => {
+    acc[user.id] = relationships.filter(
+      (rel) => rel.coach_id === user.id || rel.coachee_id === user.id
+    );
+    return acc;
+  }, {} as Record<string, CoachingRelationshipWithUserNames[]>);
+
   return (
     <Card className="w-full">
       <CardContent className="p-6">
@@ -17,6 +32,9 @@ export function MemberList({ users }: MemberListProps) {
               firstName={user.first_name}
               lastName={user.last_name}
               email={user.email}
+              userId={user.id}
+              userRelationships={userRelationshipsMap[user.id]}
+              onRefresh={onRefresh}
             />
           ))}
         </div>

src/lib/api/actions.ts

@@ -65,6 +65,17 @@ export const ActionApi = {
    */
   delete: async (id: Id): Promise<Action> =>
     EntityApi.deleteFn<null, Action>(`${ACTIONS_BASEURL}/${id}`),
+
+  /**
+   * Deletes an action nested under another entity (foreign key relationship).
+   *
+   * @param entityId The ID of the entity under which to delete the action
+   * @param actionId The ID of the action to delete
+   * @returns Promise resolving to the deleted Action object
+   */
+  deleteNested: async (entityId: Id, actionId: Id): Promise<Action> => {
+    throw new Error("Delete nested operation not implemented");
+  },
 };
 
 /**
@@ -174,5 +185,6 @@ export const useActionMutation = () => {
     createNested: ActionApi.createNested,
     update: ActionApi.update,
     delete: ActionApi.delete,
+    deleteNested: ActionApi.deleteNested,
   });
 };

src/lib/api/agreements.ts

@@ -69,6 +69,17 @@ export const AgreementApi = {
    */
   delete: async (id: Id): Promise<Agreement> =>
     EntityApi.deleteFn<null, Agreement>(`${AGREEMENTS_BASEURL}/${id}`),
+
+  /**
+   * Deletes an agreement nested under another entity (foreign key relationship).
+   *
+   * @param entityId The ID of the entity under which to delete the agreement
+   * @param agreementId The ID of the agreement to delete
+   * @returns Promise resolving to the deleted Agreement object
+   */
+  deleteNested: async (entityId: Id, agreementId: Id): Promise<Agreement> => {
+    throw new Error("Delete nested operation not implemented");
+  },
 };
 
 /**
@@ -175,5 +186,6 @@ export const useAgreementMutation = () => {
     createNested: AgreementApi.createNested,
     update: AgreementApi.update,
     delete: AgreementApi.delete,
+    deleteNested: AgreementApi.deleteNested,
   });
 };

src/lib/api/coaching-relationships.ts

@@ -91,6 +91,20 @@ export const CoachingRelationshipApi = {
   delete: async (_id: Id) => {
     throw new Error("Delete operation not implemented");
   },
+
+  /**
+   * Deletes a coaching relationship nested under another entity (foreign key relationship).
+   *
+   * @param entityId The ID of the entity under which to delete the coaching relationship
+   * @param relationshipId The ID of the coaching relationship to delete
+   * @returns Promise resolving to the deleted CoachingRelationshipWithUserNames object
+   */
+  deleteNested: async (
+    organizationId: Id,
+    relationshipId: Id
+  ): Promise<CoachingRelationshipWithUserNames> => {
+    throw new Error("Delete nested operation not implemented");
+  },
 };
 
 /**
@@ -188,6 +202,7 @@ export const useCoachingRelationshipMutation = (organizationId: Id) => {
       createNested: CoachingRelationshipApi.createNested,
       update: CoachingRelationshipApi.update,
       delete: CoachingRelationshipApi.delete,
+      deleteNested: CoachingRelationshipApi.deleteNested,
     }
   );
 };

src/lib/api/coaching-sessions.ts

@@ -95,6 +95,20 @@ export const CoachingSessionApi = {
     EntityApi.deleteFn<null, CoachingSession>(
       `${COACHING_SESSIONS_BASEURL}/${id}`
     ),
+
+  /**
+   * Deletes a coaching session nested under another entity (foreign key relationship).
+   *
+   * @param entityId The ID of the entity under which to delete the coaching session
+   * @param coachingSessionId The ID of the coaching session to delete
+   * @returns Promise resolving to the deleted CoachingSession object
+   */
+  deleteNested: async (
+    entityId: Id,
+    coachingSessionId: Id
+  ): Promise<CoachingSession> => {
+    throw new Error("Delete nested operation not implemented");
+  },
 };
 
 /**
@@ -195,6 +209,7 @@ export const useCoachingSessionMutation = () => {
       createNested: CoachingSessionApi.createNested,
       update: CoachingSessionApi.update,
       delete: CoachingSessionApi.delete,
+      deleteNested: CoachingSessionApi.deleteNested,
     }
   );
 };

src/lib/api/entity-api.ts

@@ -193,6 +193,7 @@ export namespace EntityApi {
     url: string,
     config?: any
   ): Promise<R> => {
+    console.log("deleteFn", url, config);
     return mutationFn<T, R>("delete", url, config);
   };
 
@@ -374,6 +375,7 @@ export namespace EntityApi {
       createNested: (id: Id, entity: T) => Promise<U>;
       update: (id: Id, entity: T) => Promise<U>;
       delete: (id: Id) => Promise<U>;
+      deleteNested: (entityId: Id, nestedEntityId: Id) => Promise<U>;
     }
   ) => {
     const [isLoading, setIsLoading] = useState(false);
@@ -444,6 +446,17 @@ export namespace EntityApi {
        * @returns Promise resolving to the deleted entity
        */
       delete: (id: Id) => executeWithState(() => api.delete(id)),
+
+      /**
+       * Deletes an entity nested under another entity (foreign key relationship).
+       *
+       * @param entityId The entity's id under which to delete entity
+       * @param nestedEntityId The nested entity's id to delete
+       * @returns Promise resolving to the deleted entity
+       */
+      deleteNested: (entityId: Id, nestedEntityId: Id) =>
+        executeWithState(() => api.deleteNested(entityId, nestedEntityId)),
+
       /** Indicates if any operation is currently in progress */
       isLoading,
       /** Contains the error if the last operation failed, null otherwise */

src/lib/api/organizations.ts

@@ -71,6 +71,20 @@ export const OrganizationApi = {
    */
   delete: async (id: Id): Promise<Organization> =>
     EntityApi.deleteFn<null, Organization>(`${ORGANIZATIONS_BASEURL}/${id}`),
+
+  /**
+   * Deletes an organization nested under another entity (foreign key relationship).
+   *
+   * @param entityId The ID of the entity under which to delete the organization
+   * @param organizationId The ID of the organization to delete
+   * @returns Promise resolving to the deleted Organization object
+   */
+  deleteNested: async (
+    entityId: Id,
+    organizationId: Id
+  ): Promise<Organization> => {
+    throw new Error("Delete nested operation not implemented");
+  },
 };
 
 /**
@@ -155,6 +169,7 @@ export const useOrganizationMutation = () => {
       createNested: OrganizationApi.createNested,
       update: OrganizationApi.update,
       delete: OrganizationApi.delete,
+      deleteNested: OrganizationApi.deleteNested,
     }
   );
 };

src/lib/api/organizations/users.ts

@@ -59,6 +59,15 @@ export const UserApi = {
   delete: async (id: Id): Promise<User> => {
     throw new Error("Delete operation not implemented");
   },
+
+  /**
+   * Deletes a user nested in an organization.
+   */
+  deleteNested: async (organizationId: Id, userId: Id): Promise<User> => {
+    return EntityApi.deleteFn<null, User>(
+      `${ORGANIZATIONS_USERS_BASEURL(organizationId)}/${userId}`
+    );
+  },
 };
 
 /**
@@ -92,6 +101,7 @@ export const useUserMutation = (organizationId: Id) => {
       createNested: UserApi.createNested,
       update: UserApi.update,
       delete: UserApi.delete,
+      deleteNested: UserApi.deleteNested,
     }
   );
 };