exercise.service.ts

import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { ApplicationConfigService } from 'app/core/config/application-config.service';
import { LikesService } from 'app/entities/likes/likes.service';
import { StatisticsService } from 'app/entities/statistics/statistics.service';
import { SearchService } from 'app/search/service/search-service';
import { ArtemisExerciseInfo } from 'app/shared/model/artemis-exercise-info.model';
import { Exercise } from 'app/shared/model/exercise.model';
import { SearchResultDTO } from 'app/shared/model/search/search-result-dto.model';
import { Statistics } from 'app/shared/model/statistics.model';
import { Observable } from 'rxjs';

@Injectable({ providedIn: 'root' })
export class ExerciseService {
  public resourceUrl = this.applicationConfigService.getEndpointFor('api/exerciseFile/');
  public exerciseUrl = this.applicationConfigService.getEndpointFor('api/exercise/');

  constructor(
    private http: HttpClient,
    private likesService: LikesService,
    private searchService: SearchService,
    private statisticsService: StatisticsService,
    private applicationConfigService: ApplicationConfigService
  ) {}

  public loadExerciseFile(exerciseId: string, filePath: string): Observable<string> {
    const headers = new HttpHeaders(); // .set('Content-Type', 'text/plain; charset=utf-8');
    const options: HttpParams = new HttpParams();
    options.append('filePath', filePath);

    return this.http.get<string>(this.resourceUrl + encodeURIComponent(exerciseId), {
      headers,
      params: new HttpParams().set('filePath', filePath),
      responseType: 'text' as 'json',
    });
  }

  public loadExercise(exerciseId: string): Observable<SearchResultDTO> {
    return this.http.get<SearchResultDTO>(this.exerciseUrl + encodeURIComponent(exerciseId));
  }

  populateExerciseWithData(exercise: Exercise): Exercise {
    if (exercise !== undefined) {
      exercise.views = 0;
      exercise.downloads = 0;

      this.likesService.getLikesForexerciseID(exercise.originalResult.exerciseId).subscribe(
        (data: number) => {
          exercise.numberOfLikes = data;
        },
        () => alert('Could not load number of likes')
      );

      this.statisticsService.getNumberOfWatchListEntriesForExerciseID(exercise.originalResult.exerciseId).subscribe(
        (data: number) => {
          exercise.numberOfWatchlistEntries = data;
        },
        () => alert('Could not load number of likes')
      );

      this.likesService.hasLiked(exercise.originalResult.exerciseId).subscribe(
        (data: boolean) => {
          exercise.userHasLiked = data;
        },
        () => alert('Could not load if user has liked or not')
      );

      this.searchService.getStatisticsForExercise(exercise.originalResult.exerciseId).subscribe(
        (data: Statistics) => {
          exercise.views = data.views!;
          exercise.downloads = data.downloads!;
        },
        () => alert('Could not load exercise statistics')
      );
    }
    return exercise;
  }

  /**
   * Used on init of import page, this function passes the retrieved (from Artemis)
   * exerciseUrl to the server
   * @param exerciseUrl
   */
  public importExerciseInfoFromArtemis(exerciseToken: string): Observable<ArtemisExerciseInfo> {
    return this.http.get<ArtemisExerciseInfo>(
      `${encodeURIComponent(this.exerciseUrl)}imported-exercise-info/${encodeURIComponent(exerciseToken)}`
    );
  }

  /**
   * Submits an ArtemisExerciseInfo object to server and triggers its import
   * @param exerciseInfo to submit and import
   */
  public submitExerciseInfoForImport(
    exerciseInfo: ArtemisExerciseInfo,
    exerciseToken: string,
    gitlabGroupId: number
  ): Observable<ArtemisExerciseInfo> {
    return this.http.post<ArtemisExerciseInfo>(`${this.exerciseUrl}import-exercise/${exerciseToken}/${gitlabGroupId}`, exerciseInfo);
  }
}