source: src/Clients/Angular/finki-chattery/src/app/core/state/question-state/question.effects.ts@ 9df3069

import { Injectable } from '@angular/core';
import { act, Actions, createEffect, ofType } from '@ngrx/effects';
import { catchError, filter, mergeMap, switchMap, tap, withLatestFrom } from 'rxjs/operators';
import { PreviewQuestionsOrderEnum, SearchQuestionsQueryViewModel } from 'src/app/shared-app/models';
import { TranslateFromJsonService } from 'src/app/shared-app/services';

import { BaseApiService } from 'src/app/shared-app/services/base-api.service';
import { NotificationService } from '../../services/notification.service';
import { QuestionFacadeService } from '../question-facade.service';
import { AnswerQuestionRequest, RespondToAnswerRequest, VoteAnswerRequest } from './question-state-request.models';
import {
  AnswerQuestionStateResponse,
  AnswerResponseQuestionStateResponse,
  PreviewQuestionResponse,
  QuestionStateResponse,
  VoteAnswerResponse
} from './question-state-response.models';
import {
  AnswerQuestion,
  AnswerQuestionSuccess,
  EditAnswerQuestion,
  EditAnswerQuestionSuccess,
  EditAnswerResponse,
  EditAnswerResponseSuccess,
  EffectFinishedWorking,
  EffectFinishedWorkingError,
  GetPreviewQuestionsLatest,
  GetPreviewQuestionsLatestSuccess,
  GetPreviewQuestionsPopular,
  GetPreviewQuestionsPopularSuccess,
  GetQuestionState,
  GetQuestionStateSuccess,
  GetSearchQuestions,
  GetSearchQuestionsSuccess,
  QuestionActionTypes,
  RespondToAnswer,
  RespondToAnswerSuccess,
  SetCorrectAnswer,
  SetCorrectAnswerSuccess,
  VoteAnswer,
  VoteAnswerSuccess
} from './question.actions';
import { QuestionMapper } from './question.mapper';

@Injectable({
  providedIn: 'root'
})
export class QuestionEffects {
  constructor(
    private actions$: Actions,
    private api: BaseApiService,
    private translate: TranslateFromJsonService,
    private facade: QuestionFacadeService,
    private notification: NotificationService
  ) {}

  getQuestionState$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<GetQuestionState>(QuestionActionTypes.GetQuestionState),
      switchMap((action) => {
        return this.api.get<QuestionStateResponse>(`v1/questions/${action.questionUid}`).pipe(
          switchMap((state) => [
            new GetQuestionStateSuccess(QuestionMapper.ToQuestionStateViewModel(state, this.translate)),
            new EffectFinishedWorking()
          ]),
          catchError((err) => [new EffectFinishedWorkingError(err)])
        );
      })
    );
  });

  getPreviewQuestionsLatest$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<GetPreviewQuestionsLatest>(QuestionActionTypes.GetPreviewQuestionsLatest),
      withLatestFrom(this.facade.getPreviewQuestionsLatest()),
      filter(([action, questions]) => questions.length === 0),
      switchMap((action) => {
        return this.api.get<PreviewQuestionResponse[]>(`v1/questions/preview?order=${PreviewQuestionsOrderEnum.Latest}`).pipe(
          switchMap((state) => [
            new GetPreviewQuestionsLatestSuccess(QuestionMapper.ToPreviwQuestionsViewModel(state, this.translate)),
            new EffectFinishedWorking()
          ]),
          catchError((err) => [new EffectFinishedWorkingError(err)])
        );
      })
    );
  });

  getPreviewQuestionsPopular$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<GetPreviewQuestionsPopular>(QuestionActionTypes.GetPreviewQuestionsPopular),
      withLatestFrom(this.facade.getPreviewQuestionsPopular()),
      filter(([action, questions]) => questions.length === 0),
      switchMap((action) => {
        return this.api.get<PreviewQuestionResponse[]>(`v1/questions/preview?order=${PreviewQuestionsOrderEnum.Popular}`).pipe(
          switchMap((state) => [
            new GetPreviewQuestionsPopularSuccess(QuestionMapper.ToPreviwQuestionsViewModel(state, this.translate)),
            new EffectFinishedWorking()
          ]),
          catchError((err) => [new EffectFinishedWorkingError(err)])
        );
      })
    );
  });

  getSearchQuestions$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<GetSearchQuestions>(QuestionActionTypes.GetSearchQuestions),
      mergeMap((action) => {
        const categoriesAsString = action.categories !== null ? action.categories.join(',') : '';
        return this.api
          .get<PreviewQuestionResponse[]>(`v1/questions/search?searchText=${action.searchText}&categories=${categoriesAsString}`)
          .pipe(
            switchMap((state) => [
              new GetSearchQuestionsSuccess(
                QuestionMapper.ToPreviwQuestionsViewModel(state, this.translate),
                new SearchQuestionsQueryViewModel(action.searchText)
              ),
              new EffectFinishedWorking()
            ]),
            catchError((err) => [new EffectFinishedWorkingError(err)])
          );
      })
    );
  });

  voteAnswer$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<VoteAnswer>(QuestionActionTypes.VoteAnswer),
      mergeMap((action) => {
        const body = new VoteAnswerRequest(action.voteType);
        return this.api.post<VoteAnswerResponse>(`v1/questions/${action.questionUid}/answers/${action.answerUid}/votes`, body).pipe(
          tap((state) => this.notification.successNotification('sucess-vote')),
          switchMap((state) => [new VoteAnswerSuccess(QuestionMapper.ToVoteAnswerViewModel(state)), new EffectFinishedWorking()]),
          catchError((err) => [new EffectFinishedWorkingError(err)])
        );
      })
    );
  });

  setCorrectAnswer$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<SetCorrectAnswer>(QuestionActionTypes.SetCorrectAnswer),
      mergeMap((action) => {
        return this.api.put<string>(`v1/questions/${action.questionUid}/answers/${action.answerUid}/correct`).pipe(
          tap((state) => this.notification.successNotification('success-correct-answer')),
          switchMap((state) => [new SetCorrectAnswerSuccess(state), new EffectFinishedWorking()]),
          catchError((err) => [new EffectFinishedWorkingError(err)])
        );
      })
    );
  });

  respondToAnswer$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<RespondToAnswer>(QuestionActionTypes.RespondToAnswer),
      mergeMap((action) => {
        return this.api
          .post<AnswerResponseQuestionStateResponse>(
            `v1/questions/${action.questionUid}/answers/${action.answerUid}/answerresponses`,
            new RespondToAnswerRequest(action.text)
          )
          .pipe(
            tap((state) => this.notification.successNotification('success-answer-response')),
            switchMap((state) => [
              new RespondToAnswerSuccess(QuestionMapper.ToAnswerResponseQuestionStateViewModel(state), action.answerUid),
              new EffectFinishedWorking()
            ]),
            catchError((err) => [new EffectFinishedWorkingError(err)])
          );
      })
    );
  });

  answerQuestion$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<AnswerQuestion>(QuestionActionTypes.AnswerQuestion),
      mergeMap((action) => {
        return this.api
          .post<AnswerQuestionStateResponse>(`v1/questions/${action.questionUid}/answers`, new AnswerQuestionRequest(action.text))
          .pipe(
            tap((state) => this.notification.successNotification('success-answer')),
            switchMap((state) => [
              new AnswerQuestionSuccess(QuestionMapper.ToAnswerQuestionStateViewModel(state)),
              new EffectFinishedWorking()
            ]),
            catchError((err) => [new EffectFinishedWorkingError(err)])
          );
      })
    );
  });

  editResponseToAnswer$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<EditAnswerResponse>(QuestionActionTypes.EditAnswerResponse),
      mergeMap((action) => {
        return this.api
          .put<AnswerResponseQuestionStateResponse>(
            `v1/questions/${action.questionUid}/answers/${action.answerUid}/answerresponses/${action.answerResponseUid}`,
            new RespondToAnswerRequest(action.text)
          )
          .pipe(
            tap((state) => this.notification.successNotification('success-edit-answer-response')),
            switchMap((state) => [
              new EditAnswerResponseSuccess(
                QuestionMapper.ToAnswerResponseQuestionStateViewModel(state),
                action.answerUid,
                action.answerResponseUid
              ),
              new EffectFinishedWorking()
            ]),
            catchError((err) => [new EffectFinishedWorkingError(err)])
          );
      })
    );
  });

  editAnswer$ = createEffect(() => {
    return this.actions$.pipe(
      ofType<EditAnswerQuestion>(QuestionActionTypes.EditAnswerQuestion),
      mergeMap((action) => {
        return this.api
          .put<AnswerQuestionStateResponse>(
            `v1/questions/${action.questionUid}/answers/${action.answerUid}`,
            new AnswerQuestionRequest(action.text)
          )
          .pipe(
            tap((state) => this.notification.successNotification('success-edit-answer')),
            switchMap((state) => [
              new EditAnswerQuestionSuccess(QuestionMapper.ToAnswerQuestionStateViewModel(state), action.answerUid),
              new EffectFinishedWorking()
            ]),
            catchError((err) => [new EffectFinishedWorkingError(err)])
          );
      })
    );
  });
}