# All files / src/app/shared/services task-wrapper.service.ts

100% Statements 38/38
73.33% Branches 11/15
100% Functions 8/8
100% Lines 32/32

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    6724x

    24x

    24x
    24x

    24x
    24x
    24x
    24x
    24x

    24x

    268x
    268x
    268x
    268x

    45x
    45x
    41x

    2x

    9x
    9x
    9x

    3x
    3x
    3x

    11x

    24x
    2x

    2x
    2x

    2x

    1x

    24x
     import { Injectable } from '@angular/core';

    import { Observable, Subscriber } from 'rxjs';

    import { NotificationType } from '../enum/notification-type.enum';
    import { ExecutingTask } from '../models/executing-task';
    import { FinishedTask } from '../models/finished-task';
    import { NotificationService } from './notification.service';
    import { ServicesModule } from './services.module';
    import { SummaryService } from './summary.service';
    import { TaskManagerService } from './task-manager.service';
    import { TaskMessageService } from './task-message.service';

    @Injectable({
      providedIn: ServicesModule
    })
    export class TaskWrapperService {
      constructor(
        private notificationService: NotificationService,
        private summaryService: SummaryService,
        private taskMessageService: TaskMessageService,
        private taskManagerService: TaskManagerService
      ) {}

      wrapTaskAroundCall({ task, call }: { task: FinishedTask; call: Observable<any> }) {
        return new Observable((observer: Subscriber<any>) => {
          call.subscribe(
            (resp) => {
              if (resp.status === 202) {
                this._handleExecutingTasks(task);
              } else {
                this.summaryService.refresh();
                task.success = true;
                this.notificationService.notifyTask(task);
              }
            },
            (resp) => {
              task.success = false;
              task.exception = resp.error;
              observer.error(resp);
            },
            () => {
              observer.complete();
            }
          );
        });
      }

      _handleExecutingTasks(task: FinishedTask) {
        this.notificationService.show(
          NotificationType.info,
          this.taskMessageService.getRunningTitle(task)
        );

        const executingTask = new ExecutingTask(task.name, task.metadata);
        this.summaryService.addRunningTask(executingTask);

        this.taskManagerService.subscribe(
          executingTask.name,
          executingTask.metadata,
          (asyncTask: FinishedTask) => {
            this.notificationService.notifyTask(asyncTask);
          }
        );
      }
    }