Function bodies 124 total

  public async getAllBooks(): Promise<Book[]> {
    const response = await this
      ._httpClient
      .get<AxiosResponse<Book[]>>(`${import.meta.env.VITE_API_BASE_URL}/books`)
      .catch(function (error: AxiosError): AxiosResponse<Book[]> {
        return error.response as AxiosResponse<Book[]>
      })
    return response.data as Book[]
  }

  public async getBook(bookId: string): Promise<Book> {
    const response = await this
      ._httpClient
      .get<AxiosResponse<Book>>(`${import.meta.env.VITE_API_BASE_URL}/books/${bookId}`)
      .catch(function (error: AxiosError): AxiosResponse<Book> {
        return error.response as AxiosResponse<Book>;
      });
    return response.data as Book
  }

  public async deleteBook(bookId: string): Promise<SucceededOrNotResponse> {
    const response = await this
      ._httpClient
      .delete<AxiosResponse<any>>(`${import.meta.env.VITE_API_BASE_URL}/books/${bookId}`)
      .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
        return error.response as AxiosResponse<SucceededOrNotResponse>
      })
    return new SucceededOrNotResponse(response.status === 204)
  }

  public async createBook(request: ICreateBookRequest): Promise<SucceededOrNotResponse> {
    const response = await this
      ._httpClient
      .post<ICreateBookRequest, AxiosResponse<any>>(
        `${import.meta.env.VITE_API_BASE_URL}/books`,
        request,
        this.headersWithFormDataContentType())
      .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
        return error.response as AxiosResponse<SucceededOrNotResponse>
      })
    const succeededOrNotResponse = response.data as SucceededOrNotResponse
    return new SucceededOrNotResponse(succeededOrNotResponse.succeeded, succeededOrNotResponse.errors)
  }

  public async editBook(request: IEditBookRequest): Promise<SucceededOrNotResponse> {
    const response = await this
      ._httpClient
      .put<ICreateBookRequest, AxiosResponse<any>>(
        `${import.meta.env.VITE_API_BASE_URL}/books/${request.id}`,
        request,
        this.headersWithFormDataContentType())
      .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
        return error.response as AxiosResponse<SucceededOrNotResponse>
      })
    const succeededOrNotResponse = response.data as SucceededOrNotResponse
    return new SucceededOrNotResponse(succeededOrNotResponse.succeeded, succeededOrNotResponse.errors)
  }

export class ConversationService extends ApiService implements IConversationService {

  public async getConversations(): Promise<Conversation[]> {
    const response = await this._httpClient
      .get<Conversation[], AxiosResponse<Conversation[]>>(
        `${import.meta.env.VITE_API_BASE_URL}/conversations`
      )
    return response.data
  }

  public async getMessages(conversationId: string, page: number = 0, pageSize: number = 30): Promise<ChatMessage[]> {
    const response = await this._httpClient
      .get<ChatMessage[], AxiosResponse<ChatMessage[]>>(
        `${import.meta.env.VITE_API_BASE_URL}/conversations/${conversationId}/messages?page=${page}&pageSize=${pageSize}`
      )
    return response.data
  }

  public async createConversation(memberId: string): Promise<{ id: string }> {
    const response = await this._httpClient
      .post<{ id: string }, AxiosResponse<{ id: string }>>(
        `${import.meta.env.VITE_API_BASE_URL}/conversations`,
        { memberId },
    

  public async getConversations(): Promise<Conversation[]> {
    const response = await this._httpClient
      .get<Conversation[], AxiosResponse<Conversation[]>>(
        `${import.meta.env.VITE_API_BASE_URL}/conversations`
      )
    return response.data
  }

  public async getMessages(conversationId: string, page: number = 0, pageSize: number = 30): Promise<ChatMessage[]> {
    const response = await this._httpClient
      .get<ChatMessage[], AxiosResponse<ChatMessage[]>>(
        `${import.meta.env.VITE_API_BASE_URL}/conversations/${conversationId}/messages?page=${page}&pageSize=${pageSize}`
      )
    return response.data
  }

  public async sendMessage(conversationId: string, text: string, attachment?: File): Promise<ChatMessage> {
    const formData = new FormData()
    formData.append('conversationId', conversationId)
    if (text) formData.append('text', text)
    if (attachment) formData.append('attachment', attachment)

    const response = await this._httpClient
      .post<ChatMessage, AxiosResponse<ChatMessage>>(
        `${import.meta.env.VITE_API_BASE_URL}/conversations/${conversationId}/messages`,
        formData,
        this.headersWithFormDataContentType()
      )
    return response.data
  }

  public async markAsRead(conversationId: string): Promise<void> {
    await this._httpClient
      .put(`${import.meta.env.VITE_API_BASE_URL}/conversations/${conversationId}/read`, {}, this.headersWithJsonContentType())
  }

  public async getUnreadCount(): Promise<number> {
    const response = await this._httpClient
      .get<{ count: number }, AxiosResponse<{ count: number }>>(
        `${import.meta.env.VITE_API_BASE_URL}/conversations/unread-count`
      )
    return response.data.count
  }

export class EquipeService extends ApiService implements IEquipesService {
  /**
   * Récupère tous les équipes
   */
  public async getAllEquipes(): Promise<Equipe[]> {
    try {
      const response = await this._httpClient.get<Equipe[]>(
        `${import.meta.env.VITE_API_BASE_URL}/equipes`,
      );
      return response.data ?? [];
    } catch (error) {
      console.error("Erreur lors de la récupération des équipes:", error);
      return [];
    }
  }

  /**
   * Récupère un équipe spécifique par son ID
   */
  public async getEquipe(id: string): Promise<Equipe> {
    try {
      const response = await this._httpClient.get<Equipe>(
        `${import.meta.env.VITE_API_BASE_URL}/equipe/${id}`,
      );
      return response.data;
    } catch (error) {
      console.error(`Erreur lors de la récupération de l'équipe ${id}:`, error);
      throw error;
    }
  }

  public async getEquipeFlexible(id: string): Promise<Equipe | null> {
    try {
      return await this.getEquipe(id);
 

  public async getAllEquipes(): Promise<Equipe[]> {
    try {
      const response = await this._httpClient.get<Equipe[]>(
        `${import.meta.env.VITE_API_BASE_URL}/equipes`,
      );
      return response.data ?? [];
    } catch (error) {
      console.error("Erreur lors de la récupération des équipes:", error);
      return [];
    }
  }

  public async getEquipe(id: string): Promise<Equipe> {
    try {
      const response = await this._httpClient.get<Equipe>(
        `${import.meta.env.VITE_API_BASE_URL}/equipe/${id}`,
      );
      return response.data;
    } catch (error) {
      console.error(`Erreur lors de la récupération de l'équipe ${id}:`, error);
      throw error;
    }
  }

  public async getEquipeFlexible(id: string): Promise<Equipe | null> {
    try {
      return await this.getEquipe(id);
    } catch {
      try {
        const list = await this.getAllEquipes();
        const found = list.find((m: Equipe) => {
          const ids = [
            m.Id,
            (m as any).id,
            (m as any).IdString,
            (m as any).Id && (m as any).Id.toString && (m as any).Id.toString(),
          ];
          return ids.some((x: any) => x === id);
        });
        if (found) return found;

        const num = Number(id);
        if (!isNaN(num)) {
          if (num > 0 && num <= list.length) return list[num - 1];

          if (num >= 0 && num < list.length) return list[num];
        }
        return null;
      } catch (e) {
        console.error("Erreur lors du fallback getAllModules:", e);
        return null;
      }
    }
  }

  public async createEquipe(
    request: ICreateEquipeRequest,
  ): Promise<SucceededOrNotResponse> {
    try {
      const response = await this._httpClient.post<
        ICreateEquipeRequest,
        import("axios").AxiosResponse<any>
      >(
        `${import.meta.env.VITE_API_BASE_URL}/equipes`,
        request,
        { headers: { "Content-Type": "application/json" } },
      );

      const errors = Array.isArray(response.data?.errors)
        ? response.data.errors
        : [];
      return new SucceededOrNotResponse(
        response.data?.succeeded ?? true,
        errors,
      );
    } catch (error: any) {
      const message = error.response?.data?.errors || [
        "Une erreur de communication est survenue.",
      ];
      return new SucceededOrNotResponse(
        false,
        Array.isArray(message) ? message : [message],
      );
    }
  }

        import("axios").AxiosResponse<any>
      >(
        `${import.meta.env.VITE_API_BASE_URL}/equipes`,

  public async updateEquipe(
    id: string,
    request: IEditEquipeRequest,
  ): Promise<SucceededOrNotResponse> {
    try {
      const response = await this._httpClient.put<SucceededOrNotResponse>(
        `${import.meta.env.VITE_API_BASE_URL}/equipe/${id}`,
        request,
        { headers: { "Content-Type": "application/json" } },
      );

      const errors = Array.isArray(response.data?.errors)
        ? response.data.errors
        : [];
      return new SucceededOrNotResponse(
        response.data?.succeeded ?? true,
        errors,
      );
    } catch (error: any) {
      const message = error.response?.data?.errors || [
        "Impossible de modifier le module.",
      ];
      return new SucceededOrNotResponse(
        false,
        Array.isArray(message) ? message : [message],
      );
    }
  }

  public async deleteEquipe(id: string): Promise<SucceededOrNotResponse> {
    try {
      const response = await this._httpClient.delete<any>(
        `${import.meta.env.VITE_API_BASE_URL}/equipe/${id}`,
      );
      const data = response.data;
      const succeeded =
        data?.succeeded ?? data?.Succeeded ?? response.status === 200;
      const errors = Array.isArray(data?.errors)
        ? data.errors
        : Array.isArray(data?.Errors)
          ? data.Errors
          : [];
      return new SucceededOrNotResponse(succeeded, errors);
    } catch (error: any) {
      console.error("[ModuleService] Error during deleteModule:", error);
      const message = error.response?.data?.errors || [
        "Impossible de supprimer l'équipe.",
      ];
      return new SucceededOrNotResponse(
        false,
        Array.isArray(message) ? message : [message],
      );
    }
  }

export class MemberService extends ApiService implements IMemberService {
  public async getAuthenticated(): Promise<Member | undefined> {
    try {
      const response = await this
        ._httpClient
        .get<Member, AxiosResponse<Member>>(`${import.meta.env.VITE_API_BASE_URL}/members/me`)
      return response.data
    } catch (error) {
      return Promise.reject(error)
    }
  }

  public async search(pageIndex: number, pageSize: number, searchValue: string): Promise<PaginatedResponse<Member>> {
    const response = await this
        ._httpClient
        .get<any, AxiosResponse<PaginatedResponse<Member>>>(
            `${import.meta.env.VITE_API_BASE_URL}/members?pageIndex=${pageIndex}&pageSize=${pageSize}&searchValue=${searchValue}`)
        .catch(function (error: AxiosError): AxiosResponse<PaginatedResponse<Member>> | undefined {
          return error.response
        })
    if (!response) return { items: [], totalCount: 0 } as unknown as PaginatedResponse<Member>
    r

  public async getAuthenticated(): Promise<Member | undefined> {
    try {
      const response = await this
        ._httpClient
        .get<Member, AxiosResponse<Member>>(`${import.meta.env.VITE_API_BASE_URL}/members/me`)
      return response.data
    } catch (error) {
      return Promise.reject(error)
    }
  }

  public async search(pageIndex: number, pageSize: number, searchValue: string): Promise<PaginatedResponse<Member>> {
    const response = await this
        ._httpClient
        .get<any, AxiosResponse<PaginatedResponse<Member>>>(
            `${import.meta.env.VITE_API_BASE_URL}/members?pageIndex=${pageIndex}&pageSize=${pageSize}&searchValue=${searchValue}`)
        .catch(function (error: AxiosError): AxiosResponse<PaginatedResponse<Member>> | undefined {
          return error.response
        })
    if (!response) return { items: [], totalCount: 0 } as unknown as PaginatedResponse<Member>
    return response.data as PaginatedResponse<Member>
  }

  public async getMember(id: string): Promise<Member> {
    const response = await this
        ._httpClient
        .get<any, AxiosResponse<Member>>(`${import.meta.env.VITE_API_BASE_URL}/members/${id}`)
        .catch(function (error: AxiosError): AxiosResponse<Member> {
          return error.response as AxiosResponse<Member>
        })
    return response.data as Member
  }

  public async getMemberModules(memberId: string): Promise<MemberModuleDto[]> {
    const response = await this
      ._httpClient
      .get<MemberModuleDto[], AxiosResponse<MemberModuleDto[]>>(
        `${import.meta.env.VITE_API_BASE_URL}/members/${memberId}/modules`)
      .catch(function (error: AxiosError): AxiosResponse<MemberModuleDto[]> {
        return error.response as AxiosResponse<MemberModuleDto[]>
      })

    return response?.data ?? []
  }

  public async getDashboardSummary(): Promise<DashboardSummaryDto | null> {
    const response = await this
      ._httpClient
      .get<DashboardSummaryDto, AxiosResponse<DashboardSummaryDto>>(
        `${import.meta.env.VITE_API_BASE_URL}/admin/dashboard/summary`)
      .catch(function (error: AxiosError): AxiosResponse<DashboardSummaryDto> {
        return error.response as AxiosResponse<DashboardSummaryDto>
      })

    return response?.data ?? null
  }

  public async getRecentMembers(days = 30, pageSize = 50, searchValue = ""): Promise<Member[]> {
    const response = await this
      ._httpClient
      .get<Member[], AxiosResponse<Member[]>>(
        `${import.meta.env.VITE_API_BASE_URL}/admin/members/recent?days=${days}&pageSize=${pageSize}&searchValue=${encodeURIComponent(searchValue)}`)
      .catch(function (error: AxiosError): AxiosResponse<Member[]> {
        return error.response as AxiosResponse<Member[]>
      })

    return response?.data ?? []
  }

  public async addModuleToMember(memberId: string, moduleId: string): Promise<SucceededOrNotResponse> {
    const response = await this
      ._httpClient
      .post<any, AxiosResponse<SucceededOrNotResponse>>(
        `${import.meta.env.VITE_API_BASE_URL}/members/${memberId}/modules/${moduleId}`,
        {},
        this.headersWithJsonContentType())
      .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
        return error.response as AxiosResponse<SucceededOrNotResponse>
      })

    const succeededOrNotResponse = response.data as SucceededOrNotResponse
    return new SucceededOrNotResponse(succeededOrNotResponse?.succeeded ?? true, succeededOrNotResponse?.errors)
  }

  public async updateMemberModuleProgress(memberId: string, moduleId: string, progressPercent: number): Promise<SucceededOrNotResponse> {
    const response = await this
      ._httpClient
      .put<any, AxiosResponse<SucceededOrNotResponse>>(
        `${import.meta.env.VITE_API_BASE_URL}/members/${memberId}/modules/${moduleId}/progress`,
        { progressPercent },
        this.headersWithJsonContentType())
      .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
        return error.response as AxiosResponse<SucceededOrNotResponse>
      })

    const succeededOrNotResponse = response.data as SucceededOrNotResponse
    return new SucceededOrNotResponse(succeededOrNotResponse?.succeeded ?? true, succeededOrNotResponse?.errors)
  }

  public async removeModuleFromMember(memberId: string, moduleId: string): Promise<SucceededOrNotResponse> {
    const response = await this
      ._httpClient
      .delete<any, AxiosResponse<SucceededOrNotResponse>>(
        `${import.meta.env.VITE_API_BASE_URL}/members/${memberId}/modules/${moduleId}`)
      .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
        return error.response as AxiosResponse<SucceededOrNotResponse>
      })

    const succeededOrNotResponse = response.data as SucceededOrNotResponse
    return new SucceededOrNotResponse(succeededOrNotResponse?.succeeded ?? true, succeededOrNotResponse?.errors)
  }

  public async createMember(member: Member): Promise<SucceededOrNotResponse> {
    const response = await this
        ._httpClient
        .post<any, AxiosResponse<SucceededOrNotResponse>>(
            `${import.meta.env.VITE_API_BASE_URL}/members`,
            member,
            this.headersWithJsonContentType())
        .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
          return error.response as AxiosResponse<SucceededOrNotResponse>
        })
    const succeededOrNotResponse = response.data as SucceededOrNotResponse
    return new SucceededOrNotResponse(succeededOrNotResponse.succeeded, succeededOrNotResponse.errors)
  }

  public async updateMember(member: Member): Promise<SucceededOrNotResponse> {
    const response = await this
        ._httpClient
        .put<any, AxiosResponse<SucceededOrNotResponse>>(
            `${import.meta.env.VITE_API_BASE_URL}/members/${member.id}`,
            member,
            this.headersWithJsonContentType())
        .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
          return error.response as AxiosResponse<SucceededOrNotResponse>
        })
    const succeededOrNotResponse = response.data as SucceededOrNotResponse
    return new SucceededOrNotResponse(succeededOrNotResponse.succeeded, succeededOrNotResponse.errors)
  }

  public async updateMyProfile(data: {
    firstName: string; lastName: string;
    phoneNumber?: string; phoneExtension?: number;
    apartment?: number; street?: string; city?: string; zipCode?: string;
  }): Promise<SucceededOrNotResponse> {
    const response = await this
      ._httpClient
      .put<any, AxiosResponse<SucceededOrNotResponse>>(
        `${import.meta.env.VITE_API_BASE_URL}/members/me`,
        data,
        this.headersWithJsonContentType())
      .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
        return error.response as AxiosResponse<SucceededOrNotResponse>
      })
    const succeededOrNotResponse = response.data as SucceededOrNotResponse
    return new SucceededOrNotResponse(succeededOrNotResponse.succeeded, succeededOrNotResponse.errors)
  }

  public async deleteMember(id: Guid): Promise<SucceededOrNotResponse> {
    const response = await this
        ._httpClient
        .delete<any, AxiosResponse<SucceededOrNotResponse>>(`${import.meta.env.VITE_API_BASE_URL}/members/${id}`)
        .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
          return error.response as AxiosResponse<SucceededOrNotResponse>
        })
    return new SucceededOrNotResponse(response.status === 204)
  }

export class ModulesApiService extends ApiService implements IModulesService {

    public async getAllModules(): Promise<ModuleDto[]> {
        try {
            const response = await this._httpClient.get<ModuleDto[]>(
                `${import.meta.env.VITE_API_BASE_URL}/modules`
            );
            return response.data ?? [];
        } catch (error) {
            console.error("Erreur lors de la récupération des modules:", error);
            return [];
        }
    }

    public async getModule(id: string): Promise<ModuleDto> {
        try {
            const response = await this._httpClient.get<ModuleDto>(
                `${import.meta.env.VITE_API_BASE_URL}/module/${id}`
            );
            return response.data;
        } catch (error) {
            console.error(`Erreur lors de la récupération du module ${id}:`, error);
            throw error;
        }
    }

    public async getModuleFlexible(id: string): Promise<ModuleDto | null> {
        try {
           

    public async getAllModules(): Promise<ModuleDto[]> {
        try {
            const response = await this._httpClient.get<ModuleDto[]>(
                `${import.meta.env.VITE_API_BASE_URL}/modules`
            );
            return response.data ?? [];
        } catch (error) {
            console.error("Erreur lors de la récupération des modules:", error);
            return [];
        }
    }

    public async getModule(id: string): Promise<ModuleDto> {
        try {
            const response = await this._httpClient.get<ModuleDto>(
                `${import.meta.env.VITE_API_BASE_URL}/module/${id}`
            );
            return response.data;
        } catch (error) {
            console.error(`Erreur lors de la récupération du module ${id}:`, error);
            throw error;
        }
    }

    public async getModuleFlexible(id: string): Promise<ModuleDto | null> {
        try {
            return await this.getModule(id);
        } catch {
            try {
                const list = await this.getAllModules();
                const found = list.find((m: ModuleDto) => {
                    const ids = [m.id, (m as any).Id];
                    return ids.some((x: any) => x === id);
                });
                if (found) return found;
                return null;
            } catch (e) {
                console.error('Erreur lors du fallback getAllModules:', e);
                return null;
            }
        }
    }

    public async createModule(request: ICreateModuleRequest): Promise<SucceededOrNotResponse> {
        const formData = this.prepareFormData(request);

        try {
            const response = await this._httpClient.post<ICreateModuleRequest, import("axios").AxiosResponse<any>>(
                `${import.meta.env.VITE_API_BASE_URL}/modules`,
                formData,
                this.headersWithFormDataContentType()
            );

            const errors = Array.isArray(response.data?.errors) ? response.data.errors : [];
            return new SucceededOrNotResponse(response.data?.succeeded ?? true, errors);

        } catch (error: any) {
            const message = error.response?.data?.errors || ["Une erreur de communication est survenue."];
            return new SucceededOrNotResponse(false, Array.isArray(message) ? message : [message]);
        }
    }

    public async updateModule(id: string, request: IEditModuleRequest): Promise<SucceededOrNotResponse> {
        const formData = this.prepareFormData(request);

        try {
            const response = await this._httpClient.put<IEditModuleRequest, import("axios").AxiosResponse<any>>(
                `${import.meta.env.VITE_API_BASE_URL}/module/${id}`,
                formData,
                this.headersWithFormDataContentType()
            );

            const errors = Array.isArray(response.data?.errors) ? response.data.errors : [];
            return new SucceededOrNotResponse(response.data?.succeeded ?? true, errors);

        } catch (error: any) {
            const message = error.response?.data?.errors || ["Impossible de modifier le module."];
            return new SucceededOrNotResponse(false, Array.isArray(message) ? message : [message]);
        }
    }

    public async deleteModule(id: string): Promise<SucceededOrNotResponse> {
        try {
            const response = await this._httpClient.delete<any>(
                `${import.meta.env.VITE_API_BASE_URL}/module/${id}`
            );
            const data = response.data;
            const succeeded = data?.succeeded ?? data?.Succeeded ?? response.status === 200;
            const errors = Array.isArray(data?.errors) ? data.errors
                         : Array.isArray(data?.Errors) ? data.Errors
                         : [];
            return new SucceededOrNotResponse(succeeded, errors);
        } catch (error: any) {
            console.error('[ModuleService] Error during deleteModule:', error);
            const message = error.response?.data?.errors || ["Impossible de supprimer le module."];
            return new SucceededOrNotResponse(false, Array.isArray(message) ? message : [message]);
        }
    }

    public async saveModuleFull(id: string, request: ISaveModuleFullRequest): Promise<SucceededOrNotResponse> {
        try {
            const response = await this._httpClient.put<any>(
                `${import.meta.env.VITE_API_BASE_URL}/module/${id}/full`,
                request,
                this.headersWithJsonContentType()
            );
            const errors = Array.isArray(response.data?.errors) ? response.data.errors : [];
            return new SucceededOrNotResponse(response.data?.succeeded ?? true, errors);
        } catch (error: any) {
            const message = error.response?.data?.errors || ["Impossible de sauvegarder le module."];
            return new SucceededOrNotResponse(false, Array.isArray(message) ? message : [message]);
        }
    }

    public async getModuleSections(moduleId: string): Promise<ModuleSectionDto[]> {
        const response = await this._httpClient.get<ModuleSectionDto[]>(
            `${import.meta.env.VITE_API_BASE_URL}/module/${moduleId}/sections`
        );
        return response.data ?? [];
    }

    public async assignModule(moduleId: string, memberId: string): Promise<SucceededOrNotResponse> {
        try {
            const response = await this._httpClient.post<any>(
                `${import.meta.env.VITE_API_BASE_URL}/module/${moduleId}/assign`,
                { memberId },
                this.headersWithJsonContentType()
            );
            return new SucceededOrNotResponse(response.data?.succeeded ?? true, response.data?.errors ?? []);
        } catch (error: any) {
            return new SucceededOrNotResponse(false, [error.response?.data?.errors?.[0] || "Erreur d'assignation."]);
        }
    }

    public async unassignModule(moduleId: string, memberId: string): Promise<SucceededOrNotResponse> {
        try {
            const response = await this._httpClient.delete<any>(
                `${import.meta.env.VITE_API_BASE_URL}/module/${moduleId}/assign/${memberId}`
            );
            return new SucceededOrNotResponse(response.data?.succeeded ?? true, response.data?.errors ?? []);
        } catch (error: any) {
            return new SucceededOrNotResponse(false, [error.response?.data?.errors?.[0] || "Erreur de désassignation."]);
        }
    }

    public async getModuleAssignments(moduleId: string): Promise<any[]> {
        try {
            const response = await this._httpClient.get<any[]>(
                `${import.meta.env.VITE_API_BASE_URL}/module/${moduleId}/assignments`
            );
            return response.data ?? [];
        } catch {
            return [];
        }
    }

    public async getMyModules(): Promise<ModuleDto[]> {
        try {
            const response = await this._httpClient.get<ModuleDto[]>(
                `${import.meta.env.VITE_API_BASE_URL}/member/modules`
            );
            return Array.isArray(response.data) ? response.data : [];
        } catch {
            return [];
        }
    }

    public async getMyModuleDetail(moduleId: string): Promise<ModuleDto> {
        const response = await this._httpClient.get<ModuleDto>(
            `${import.meta.env.VITE_API_BASE_URL}/member/modules/${moduleId}`
        );
        return response.data;
    }

    private prepareFormData(request: ICreateModuleRequest | IEditModuleRequest): FormData {
        const formData = new FormData();

        if (request.name) formData.append("Name", request.name);
        if (request.subject) formData.append("Subject", request.subject);
        if (request.content) formData.append("Content", request.content);

        if (request.cardImage) formData.append("CardImage", request.cardImage);

        return formData;
    }

export class UserService extends ApiService implements IUserService {
  public async getCurrentUser(): Promise<User> {
    const response = await this
    ._httpClient
    .get<any, AxiosResponse<User>>(`${import.meta.env.VITE_API_BASE_URL}/users/me`)
    .catch(function (error: AxiosError): AxiosResponse<User> {
      return error.response as AxiosResponse<User>
    })
    return response?.data as User
  }
}

  public async getCurrentUser(): Promise<User> {
    const response = await this
    ._httpClient
    .get<any, AxiosResponse<User>>(`${import.meta.env.VITE_API_BASE_URL}/users/me`)
    .catch(function (error: AxiosError): AxiosResponse<User> {
      return error.response as AxiosResponse<User>
    })
    return response?.data as User
  }