karusic/front/src/app/service/album.ts

/** @file
 * @author Edouard DUPIN
 * @copyright 2018, Edouard DUPIN, all right reserved
 * @license PROPRIETARY (see license file)
 */

import { Injectable } from "@angular/core";

import { Album, AlbumResource, UUID } from "app/back-api";
import { RESTConfig } from "app/back-api/rest-tools";
import { environment } from "environments/environment";
import { GenericDataService } from "./GenericDataService";
import {
  DataTools,
  DataStore,
  SessionService,
  TypeCheck,
  isNumber,
  isArrayOf,
} from "@kangaroo-and-rabbit/kar-cw";

@Injectable()
export class AlbumService extends GenericDataService<Album> {
  getRestConfig(): RESTConfig {
    return {
      server: environment.server.karusic,
      token: this.session.getToken(),
    };
  }
  private lambdaGets(): Promise<Album[]> {
    const self = this;
    return AlbumResource.gets({ restConfig: this.getRestConfig() });
  }

  constructor(private session: SessionService) {
    super();
    console.log("Start AlbumService");
    this.setStore(new DataStore<Album>(() => this.lambdaGets()));
  }

  insert(data: Album): Promise<Album> {
    const self = this;
    return new Promise((resolve, reject) => {
      AlbumResource.post({
        restConfig: this.getRestConfig(),
        data,
      })
        .then((value: Album) => {
          self.dataStore.updateValue(value);
          resolve(value);
        })
        .catch((error) => {
          reject(error);
        });
    });
  }
  patch(id: number, data: Album): Promise<Album> {
    const self = this;
    return new Promise((resolve, reject) => {
      AlbumResource.patch({
        restConfig: this.getRestConfig(),
        params: {
          id,
        },
        data,
      })
        .then((value: Album) => {
          self.dataStore.updateValue(value);
          resolve(value);
        })
        .catch((error) => {
          reject(error);
        });
    });
  }

  delete(id: number): Promise<void> {
    const self = this;
    return new Promise((resolve, reject) => {
      AlbumResource.remove({
        restConfig: this.getRestConfig(),
        params: {
          id,
        },
      })
        .then(() => {
          self.dataStore.delete(id);
          resolve();
        })
        .catch((error) => {
          reject(error);
        });
    });
  }

  deleteCover(id: number, coverId: UUID): Promise<Album> {
    let self = this;
    return new Promise((resolve, reject) => {
      AlbumResource.removeCover({
        restConfig: this.getRestConfig(),
        params: {
          id,
          coverId,
        },
      })
        .then((value) => {
          self.dataStore.updateValue(value);
          resolve(value);
        })
        .catch((error) => {
          reject(error);
        });
    });
  }
  uploadCover(id: number, file: File, progress: any = null): Promise<Album> {
    let self = this;
    return new Promise((resolve, reject) => {
      AlbumResource.uploadCover({
        restConfig: this.getRestConfig(),
        params: {
          id,
        },
        data: {
          file,
        },
      })
        .then((value) => {
          self.dataStore.updateValue(value);
          resolve(value);
        })
        .catch((error) => {
          reject(error);
        });
    });
  }

  /**
   * Get all the artists for a specific album
   * @param idAlbum - Id of the album.
   * @returns a promise on the list of Artist ID for this album
   */
  getArtists(idAlbum: number): Promise<number[]> {
    let self = this;
    return new Promise((resolve, reject) => {
      self
        .gets()
        .then((response: Album[]) => {
          let data = DataTools.getsWhere(
            response,
            [
              {
                check: TypeCheck.EQUAL,
                key: "albumId",
                value: idAlbum,
              },
            ],
            ["name"]
          );
          // filter with artist- ID !!!
          const listArtistId = DataTools.extractLimitOneList(data, "artists");
          if (isArrayOf(listArtistId, isNumber)) {
            resolve(listArtistId);
          } else {
            reject(`Fail to get the ids (impossible case) ${listArtistId}`);
          }
        })
        .catch((response) => {
          reject(response);
        });
    });
  }
}