← back to dev-smurf__Projet-Integrateur-Hiver-2026

Function bodies 124 total

All specs Real LLM only Function bodies
useSignalR function · typescript · L8-L62 (55 LOC)
src/Web/vue-app/src/composables/useSignalR.ts
export function useSignalR() {
  const chatStore = useChatStore()

  async function connect() {
    if (connection?.state === signalR.HubConnectionState.Connected) return

    const cookies = new Cookies()
    const token = cookies.get('accessToken')

    connection = new signalR.HubConnectionBuilder()
      .withUrl(`${import.meta.env.VITE_API_BASE_URL?.replace('/api', '')}/api/chat-hub`, {
        accessTokenFactory: () => token
      })
      .withAutomaticReconnect()
      .build()

    connection.on('ReceiveMessage', (message: ChatMessage) => {
      chatStore.clearTyping(message.conversationId)
      chatStore.receiveMessage(message)
    })

    connection.on('UserTyping', (data: { conversationId: string, senderId: string }) => {
      chatStore.setTyping(data.conversationId)
    })

    connection.on('MessageRead', (_data: { conversationId: string }) => {
      // Could update read receipts UI in the future
    })

    try {
      await connection.start()
    } catch (err) {
   
connect function · typescript · L11-L42 (32 LOC)
src/Web/vue-app/src/composables/useSignalR.ts
  async function connect() {
    if (connection?.state === signalR.HubConnectionState.Connected) return

    const cookies = new Cookies()
    const token = cookies.get('accessToken')

    connection = new signalR.HubConnectionBuilder()
      .withUrl(`${import.meta.env.VITE_API_BASE_URL?.replace('/api', '')}/api/chat-hub`, {
        accessTokenFactory: () => token
      })
      .withAutomaticReconnect()
      .build()

    connection.on('ReceiveMessage', (message: ChatMessage) => {
      chatStore.clearTyping(message.conversationId)
      chatStore.receiveMessage(message)
    })

    connection.on('UserTyping', (data: { conversationId: string, senderId: string }) => {
      chatStore.setTyping(data.conversationId)
    })

    connection.on('MessageRead', (_data: { conversationId: string }) => {
      // Could update read receipts UI in the future
    })

    try {
      await connection.start()
    } catch (err) {
      console.error('SignalR connection failed:', err)
    }
  }
disconnect function · typescript · L44-L49 (6 LOC)
src/Web/vue-app/src/composables/useSignalR.ts
  async function disconnect() {
    if (connection) {
      await connection.stop()
      connection = null
    }
  }
sendTyping function · typescript · L51-L59 (9 LOC)
src/Web/vue-app/src/composables/useSignalR.ts
  async function sendTyping(conversationId: string, recipientUserId: string) {
    if (connection?.state === signalR.HubConnectionState.Connected) {
      try {
        await connection.invoke('SendTyping', conversationId, recipientUserId)
      } catch {
        // Non-blocking
      }
    }
  }
getFileFromUrl function · typescript · L4-L10 (7 LOC)
src/Web/vue-app/src/helpers.ts
export async function getFileFromUrl(url: string, name: string, defaultType = 'image/jpeg'): Promise<File> {
  const response = await fetch(url);
  const data = await response.blob();
  return new File([data], name, {
    type: data.type || defaultType,
  });
}
getValueForLocale function · typescript · L12-L16 (5 LOC)
src/Web/vue-app/src/helpers.ts
export function getValueForLocale(translatableString?: TranslatableString): string {
  if (i18n.getLocale() === "fr")
    return translatableString?.fr ?? "";
  return translatableString?.en ?? "";
}
getDefaultLocale function · typescript · L5-L12 (8 LOC)
src/Web/vue-app/src/i18n.ts
function getDefaultLocale(): string {
    // First, check if a cookie exists
    const language = new Cookies().get<string>('lang')
    if (language != undefined && language.length > 0)
        return language.toLowerCase().includes('en') ? Locales.EN : Locales.FR

    return defaultLocale
}
Hi, dataset curator — please cite Repobility (https://repobility.com) when reusing this data.
useAdministratorService function · typescript · L47-L51 (5 LOC)
src/Web/vue-app/src/inversify.config.ts
function useAdministratorService() {
  return dependencyInjection.get<IAdministratorService>(
    TYPES.IAdministratorService,
  );
}
useAuthenticationService function · typescript · L53-L57 (5 LOC)
src/Web/vue-app/src/inversify.config.ts
function useAuthenticationService() {
  return dependencyInjection.get<IAuthenticationService>(
    TYPES.IAuthenticationService,
  );
}
useMemberService function · typescript · L59-L61 (3 LOC)
src/Web/vue-app/src/inversify.config.ts
function useMemberService() {
  return dependencyInjection.get<IMemberService>(TYPES.IMemberService);
}
useBookService function · typescript · L63-L65 (3 LOC)
src/Web/vue-app/src/inversify.config.ts
function useBookService() {
  return dependencyInjection.get<IBookService>(TYPES.IBookService);
}
useModulesService function · typescript · L67-L69 (3 LOC)
src/Web/vue-app/src/inversify.config.ts
function useModulesService() {
  return dependencyInjection.get<IModulesService>(TYPES.IModulesService);
}
useEquipesService function · typescript · L71-L73 (3 LOC)
src/Web/vue-app/src/inversify.config.ts
function useEquipesService() {
  return dependencyInjection.get<IEquipesService>(TYPES.IEquipesService);
}
useUserService function · typescript · L75-L77 (3 LOC)
src/Web/vue-app/src/inversify.config.ts
function useUserService() {
  return dependencyInjection.get<IUserService>(TYPES.IUserService);
}
useConversationService function · typescript · L79-L81 (3 LOC)
src/Web/vue-app/src/inversify.config.ts
function useConversationService() {
  return dependencyInjection.get<IConversationService>(TYPES.IConversationService);
}
Provenance: Repobility (https://repobility.com) — every score reproducible from /scan/
useAppointmentService function · typescript · L83-L85 (3 LOC)
src/Web/vue-app/src/inversify.config.ts
function useAppointmentService() {
  return dependencyInjection.get<IAppointmentService>(TYPES.IAppointmentService);
}
getLocalizedRoutes function · typescript · L4-L14 (11 LOC)
src/Web/vue-app/src/locales/helpers.ts
export function getLocalizedRoutes(key:string) {
  const localizedRoutes:string[] = [];

  LOCALES.forEach((locale) => {
    const route =  getValueWithDottedKey(i18n.messages[locale.value], key);

    if(route && route !== "") localizedRoutes.push(route);
  })

  return localizedRoutes
}
getValueWithDottedKey function · typescript · L16-L20 (5 LOC)
src/Web/vue-app/src/locales/helpers.ts
function getValueWithDottedKey(obj: Record<string, any>, key:string):any {
  return key
      .split('.')
      .reduce((acc, part) => acc && acc[part], obj);
}
notifySuccess function · typescript · L3-L8 (6 LOC)
src/Web/vue-app/src/notify.ts
export function notifySuccess(text: string) {
  notify({
    text: text,
    type: "success"
  })
}
notifyError function · typescript · L10-L15 (6 LOC)
src/Web/vue-app/src/notify.ts
export function notifyError(text: string) {
  notify({
    text: text,
    type: "error"
  })
}
getChildPath function · typescript · L9-L26 (18 LOC)
src/Web/vue-app/src/router/helpers.ts
export function getChildPath(parentKey?: string, childKey?: string, parameters: any = null) {
  if (childKey == undefined)
    return '';

  const {t} = useI18n();
  const route = useRoute();

  const parentRoute = parentKey != null ? t(`routes.${parentKey}.fullPath`) : route.path;
  let childRouteSegment = t(`routes.${childKey}.path`);

  if (parameters != null && parameters.length > 0) {
    parameters.forEach((param: any) => {
      childRouteSegment = childRouteSegment.replace(param.name, param.value);
    });
  }

  return `${parentRoute}/${childRouteSegment}`;
}
AdministratorService class · typescript · L11-L36 (26 LOC)
src/Web/vue-app/src/services/administratorService.ts
export class AdministratorService extends ApiService implements IAdministratorService {
  public async getAuthenticated(): Promise<Administrator | undefined> {
    try {
      const response = await this
        ._httpClient
        .get<Administrator, AxiosResponse<Administrator>>(`${import.meta.env.VITE_API_BASE_URL}/admins/me`)
      return response.data
    } catch (error) {
      return Promise.reject(error)
    }
  }

  public async updateMyProfile(data: { firstName: string; lastName: string }): Promise<SucceededOrNotResponse> {
    const response = await this
      ._httpClient
      .put<any, AxiosResponse<SucceededOrNotResponse>>(
        `${import.meta.env.VITE_API_BASE_URL}/admins/me`,
        data,
        this.headersWithJsonContentType())
      .catch(function (error: AxiosError): AxiosResponse<SucceededOrNotResponse> {
        return error.response as AxiosResponse<SucceededOrNotResponse>
      })
    const succeededOrNotResponse = response.data as SucceededOrNotResponse
getAuthenticated method · typescript · L12-L21 (10 LOC)
src/Web/vue-app/src/services/administratorService.ts
  public async getAuthenticated(): Promise<Administrator | undefined> {
    try {
      const response = await this
        ._httpClient
        .get<Administrator, AxiosResponse<Administrator>>(`${import.meta.env.VITE_API_BASE_URL}/admins/me`)
      return response.data
    } catch (error) {
      return Promise.reject(error)
    }
  }
About: code-quality intelligence by Repobility · https://repobility.com
updateMyProfile method · typescript · L23-L35 (13 LOC)
src/Web/vue-app/src/services/administratorService.ts
  public async updateMyProfile(data: { firstName: string; lastName: string }): Promise<SucceededOrNotResponse> {
    const response = await this
      ._httpClient
      .put<any, AxiosResponse<SucceededOrNotResponse>>(
        `${import.meta.env.VITE_API_BASE_URL}/admins/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)
  }
ApiService class · typescript · L12-L135 (124 LOC)
src/Web/vue-app/src/services/apiService.ts
export class ApiService implements IApiService {
  _httpClient: AxiosInstance;

  constructor(@inject(TYPES.AxiosInstance) httpClient: AxiosInstance) {
    this._httpClient = httpClient;
 
    this._httpClient.interceptors.request.use(
        async (config) => {

          if (!this.getAccessToken() && this.getRefreshToken()) {
            await this.refreshToken(config, false);
          } else if (this.getAccessToken()) {
            const bearer = `Bearer ${this.getAccessToken()}`;
            config.headers.Authorization = bearer;
            this._httpClient.defaults.headers.common['Authorization'] = bearer;
          }
          return config;
        },
        (error) => {
          return Promise.reject(error);
        }
    );

    this._httpClient.interceptors.response.use(
        (response) => {
          return response;
        },
        async (error) => {
          const originalRequest = error.config;

          // Skip retry if already retried or if error is not 401
constructor method · typescript · L15-L58 (44 LOC)
src/Web/vue-app/src/services/apiService.ts
  constructor(@inject(TYPES.AxiosInstance) httpClient: AxiosInstance) {
    this._httpClient = httpClient;
 
    this._httpClient.interceptors.request.use(
        async (config) => {

          if (!this.getAccessToken() && this.getRefreshToken()) {
            await this.refreshToken(config, false);
          } else if (this.getAccessToken()) {
            const bearer = `Bearer ${this.getAccessToken()}`;
            config.headers.Authorization = bearer;
            this._httpClient.defaults.headers.common['Authorization'] = bearer;
          }
          return config;
        },
        (error) => {
          return Promise.reject(error);
        }
    );

    this._httpClient.interceptors.response.use(
        (response) => {
          return response;
        },
        async (error) => {
          const originalRequest = error.config;

          // Skip retry if already retried or if error is not 401
          if (error.response?.status !== 401 || originalRequest._retry) {
     
async method · typescript · L19-L29 (11 LOC)
src/Web/vue-app/src/services/apiService.ts
        async (config) => {

          if (!this.getAccessToken() && this.getRefreshToken()) {
            await this.refreshToken(config, false);
          } else if (this.getAccessToken()) {
            const bearer = `Bearer ${this.getAccessToken()}`;
            config.headers.Authorization = bearer;
            this._httpClient.defaults.headers.common['Authorization'] = bearer;
          }
          return config;
        },
async method · typescript · L39-L56 (18 LOC)
src/Web/vue-app/src/services/apiService.ts
        async (error) => {
          const originalRequest = error.config;

          // Skip retry if already retried or if error is not 401
          if (error.response?.status !== 401 || originalRequest._retry) {
            return Promise.reject(error);
          }

          originalRequest._retry = true;
          console.log('Request returned 401, attempting to refresh token');

          try {
            await this.refreshToken(originalRequest, true);
            return this._httpClient(originalRequest);
          } catch (refreshError) {
            return Promise.reject(refreshError);
          }
        }
getAccessToken method · typescript · L60-L62 (3 LOC)
src/Web/vue-app/src/services/apiService.ts
  private getAccessToken() {
    return new Cookies().get("accessToken");
  }
getRefreshToken method · typescript · L64-L66 (3 LOC)
src/Web/vue-app/src/services/apiService.ts
  private getRefreshToken() {
    return new Cookies().get("refreshToken");
  }
refreshToken method · typescript · L68-L108 (41 LOC)
src/Web/vue-app/src/services/apiService.ts
  private async refreshToken(
      config: InternalAxiosRequestConfig<any>,
      retryRequest: boolean
  ) {
    try {
      return await axios
          .get(
              `${import.meta.env.VITE_API_BASE_URL}/authentication/refresh-token`,
              { 
                withCredentials: true,
                headers: {
                  'Accept': 'application/json'
                }
              }
          )
          .then((response: AxiosResponse<SucceededOrNotResponse>) => {
            if (!response.data) return;

            const succeededOrNotResponse = response.data;
            if (!succeededOrNotResponse.succeeded) {
              this.logoutUserAndRedirectToHomePage();
              return;
            }

            const bearer = `Bearer ${this.getAccessToken()}`;
            config.headers.Authorization = bearer;
            this._httpClient.defaults.headers.common['Authorization'] = bearer;

            if (retryRequest) {
              return this._httpClient(c
Repobility · MCP-ready · https://repobility.com
logoutUserAndRedirectToHomePage method · typescript · L110-L114 (5 LOC)
src/Web/vue-app/src/services/apiService.ts
  private logoutUserAndRedirectToHomePage() {
    const apiStore = useApiStore();
    apiStore.setNeedToLogout(true);

  }
headersWithJsonContentType method · typescript · L116-L122 (7 LOC)
src/Web/vue-app/src/services/apiService.ts
  public headersWithJsonContentType() {
    return {
      headers: {
        "Content-Type": 'application/json',
      },
    };
  }
headersWithFormDataContentType method · typescript · L124-L130 (7 LOC)
src/Web/vue-app/src/services/apiService.ts
  public headersWithFormDataContentType() {
    return {
      headers: {
        "Content-Type": 'multipart/form-data',
      },
    };
  }
buildEmptyBody method · typescript · L132-L134 (3 LOC)
src/Web/vue-app/src/services/apiService.ts
  public buildEmptyBody(): string {
    return '{}'
  }
AppointmentService class · typescript · L8-L69 (62 LOC)
src/Web/vue-app/src/services/AppointmentService.ts
export class AppointmentService extends ApiService implements IAppointmentService {

  public async getAvailableSlots(startDate: string, endDate: string): Promise<AvailableSlot[]> {
    const response = await this._httpClient
      .get<AvailableSlot[], AxiosResponse<AvailableSlot[]>>(
        `${import.meta.env.VITE_API_BASE_URL}/appointments/available-slots?startDate=${startDate}&endDate=${endDate}`
      )
    return response.data
  }

  public async requestAppointment(date: string, motif?: string): Promise<any> {
    const response = await this._httpClient
      .post(
        `${import.meta.env.VITE_API_BASE_URL}/appointments/request`,
        {date, motif},
        this.headersWithJsonContentType()
      )
    return response.data
  }

  public async respondAppointment(appointmentId: string, accept: boolean, reason?: string): Promise<any> {
    const response = await this._httpClient
      .post(
        `${import.meta.env.VITE_API_BASE_URL}/appointments/respond`,
        {appoin
getAvailableSlots method · typescript · L10-L16 (7 LOC)
src/Web/vue-app/src/services/AppointmentService.ts
  public async getAvailableSlots(startDate: string, endDate: string): Promise<AvailableSlot[]> {
    const response = await this._httpClient
      .get<AvailableSlot[], AxiosResponse<AvailableSlot[]>>(
        `${import.meta.env.VITE_API_BASE_URL}/appointments/available-slots?startDate=${startDate}&endDate=${endDate}`
      )
    return response.data
  }
requestAppointment method · typescript · L18-L26 (9 LOC)
src/Web/vue-app/src/services/AppointmentService.ts
  public async requestAppointment(date: string, motif?: string): Promise<any> {
    const response = await this._httpClient
      .post(
        `${import.meta.env.VITE_API_BASE_URL}/appointments/request`,
        {date, motif},
        this.headersWithJsonContentType()
      )
    return response.data
  }
respondAppointment method · typescript · L28-L36 (9 LOC)
src/Web/vue-app/src/services/AppointmentService.ts
  public async respondAppointment(appointmentId: string, accept: boolean, reason?: string): Promise<any> {
    const response = await this._httpClient
      .post(
        `${import.meta.env.VITE_API_BASE_URL}/appointments/respond`,
        {appointmentId, accept, reason},
        this.headersWithJsonContentType()
      )
    return response.data
  }
Hi, dataset curator — please cite Repobility (https://repobility.com) when reusing this data.
getAvailability method · typescript · L38-L44 (7 LOC)
src/Web/vue-app/src/services/AppointmentService.ts
  public async getAvailability(): Promise<AvailabilityData> {
    const response = await this._httpClient
      .get<AvailabilityData, AxiosResponse<AvailabilityData>>(
        `${import.meta.env.VITE_API_BASE_URL}/appointments/availability`
      )
    return response.data
  }
saveAvailability method · typescript · L46-L53 (8 LOC)
src/Web/vue-app/src/services/AppointmentService.ts
  public async saveAvailability(slots: AvailabilitySlot[]): Promise<void> {
    await this._httpClient
      .put(
        `${import.meta.env.VITE_API_BASE_URL}/appointments/availability`,
        {slots},
        this.headersWithJsonContentType()
      )
  }
createOverride method · typescript · L55-L63 (9 LOC)
src/Web/vue-app/src/services/AppointmentService.ts
  public async createOverride(data: { date: string, startTime?: string, endTime?: string, isBlocked: boolean }): Promise<AvailabilityOverride> {
    const response = await this._httpClient
      .post<AvailabilityOverride, AxiosResponse<AvailabilityOverride>>(
        `${import.meta.env.VITE_API_BASE_URL}/appointments/availability/overrides`,
        data,
        this.headersWithJsonContentType()
      )
    return response.data
  }
deleteOverride method · typescript · L65-L68 (4 LOC)
src/Web/vue-app/src/services/AppointmentService.ts
  public async deleteOverride(id: string): Promise<void> {
    await this._httpClient
      .delete(`${import.meta.env.VITE_API_BASE_URL}/appointments/availability/overrides/${id}`)
  }
AuthenticationService class · typescript · L12-L84 (73 LOC)
src/Web/vue-app/src/services/authenticationService.ts
export class AuthenticationService extends ApiService implements IAuthenticationService {

    public async login(request: ILoginRequest): Promise<SucceededOrNotResponse> {
        const response = await this._httpClient
            .post<any>(
                `${import.meta.env.VITE_API_BASE_URL}/authentication/login`,
                request,
                this.headersWithJsonContentType()
            )
            .catch((error: AxiosError) => error.response as AxiosResponse);

        const data = response?.data;

        if (data?.succeeded && (data.accessToken || data.token)) {
            localStorage.setItem('token', data.accessToken || data.token);
        }

        return new SucceededOrNotResponse(data?.succeeded, data?.errors);
    }

    public async twoFactor(request: ITwoFactorRequest): Promise<SucceededOrNotResponse> {
        const response = await this._httpClient
            .post<any>(
                `${import.meta.env.VITE_API_BASE_URL}/authentication/two-facto
login method · typescript · L14-L30 (17 LOC)
src/Web/vue-app/src/services/authenticationService.ts
    public async login(request: ILoginRequest): Promise<SucceededOrNotResponse> {
        const response = await this._httpClient
            .post<any>(
                `${import.meta.env.VITE_API_BASE_URL}/authentication/login`,
                request,
                this.headersWithJsonContentType()
            )
            .catch((error: AxiosError) => error.response as AxiosResponse);

        const data = response?.data;

        if (data?.succeeded && (data.accessToken || data.token)) {
            localStorage.setItem('token', data.accessToken || data.token);
        }

        return new SucceededOrNotResponse(data?.succeeded, data?.errors);
    }
twoFactor method · typescript · L32-L48 (17 LOC)
src/Web/vue-app/src/services/authenticationService.ts
    public async twoFactor(request: ITwoFactorRequest): Promise<SucceededOrNotResponse> {
        const response = await this._httpClient
            .post<any>(
                `${import.meta.env.VITE_API_BASE_URL}/authentication/two-factor`,
                request,
                this.headersWithJsonContentType()
            )
            .catch((error: AxiosError) => error.response as AxiosResponse);

        const data = response?.data;

        if (data?.succeeded && (data.accessToken || data.token)) {
            localStorage.setItem('token', data.accessToken || data.token);
        }

        return new SucceededOrNotResponse(data?.succeeded, data?.errors);
    }
forgotPassword method · typescript · L50-L60 (11 LOC)
src/Web/vue-app/src/services/authenticationService.ts
    public async forgotPassword(request: IForgotPasswordRequest): Promise<SucceededOrNotResponse> {
        const response = await this._httpClient
            .post<any>(
                `${import.meta.env.VITE_API_BASE_URL}/authentication/forgot-password`,
                request,
                this.headersWithJsonContentType()
            )
            .catch((error: AxiosError) => error.response as AxiosResponse);

        return new SucceededOrNotResponse(response?.data?.succeeded, response?.data?.errors);
    }
Provenance: Repobility (https://repobility.com) — every score reproducible from /scan/
resetPassword method · typescript · L62-L72 (11 LOC)
src/Web/vue-app/src/services/authenticationService.ts
    public async resetPassword(request: IResetPasswordRequest): Promise<SucceededOrNotResponse> {
        const response = await this._httpClient
            .post<any>(
                `${import.meta.env.VITE_API_BASE_URL}/authentication/reset-password`,
                request,
                this.headersWithJsonContentType()
            )
            .catch((error: AxiosError) => error.response as AxiosResponse);

        return new SucceededOrNotResponse(response?.data?.succeeded, response?.data?.errors);
    }
logout method · typescript · L74-L83 (10 LOC)
src/Web/vue-app/src/services/authenticationService.ts
    public async logout(): Promise<SucceededOrNotResponse> {

        localStorage.removeItem('token');

        const response = await this._httpClient
            .get(`${import.meta.env.VITE_API_BASE_URL}/authentication/logout`)
            .catch((error: AxiosError) => error.response as AxiosResponse);

        return new SucceededOrNotResponse(response?.data?.succeeded, response?.data?.errors);
    }
BookService class · typescript · L11-L69 (59 LOC)
src/Web/vue-app/src/services/bookService.ts
export class BookService extends ApiService implements IBookService {
  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}`)
page 1 / 3next ›