items.js

import { library } from './library.js';

export class User {

}

export class CurrentUser extends User {

}

export class Item {
  constructor(data) {
    this.data = data;
    this.id = data.id;
    this.name = data.name;
    this.type = data.type;
    this.display_name = ''; // The artist name or user name associated with the item
  }
  static concatenateArtists(artists) {
    const num_artists = artists.length;
    let artists_str = artists[0].name;
    for (let i = 1; i < num_artists; i++) {
      artists_str.concat(', ' + artists[i].name);
    }
    return artists_str;
  }
  static async calculateDurationString(duration_ms, magnitude = 'minutes') {
    const hours = Math.floor(duration_ms / (60 * 60 * 1000))
    const minutes = Math.floor(duration_ms / 60 * 1000);
    const seconds = Math.ceil((duration_ms % (60 * 1000) / 1000));
    let duration = '';
    if (magnitude === 'hours') {
      duration.concat(hours.toString() + ':');
      duration.concat(minutes.toString().padStart(2, '0') + ':');
    } else {
      duration.concat(minutes.toString() + ':');
    }
    duration.concat(seconds.toString().padStart(2, '0'));
    return duration;
  }
}

// NOTE: could possibly add the ability to get extra information about each track such as bpm through analysis
export class Track extends Item {
  constructor(data, album = '') {
    // Tracks in a playlist will have a track and added_at property which this will parse
    let date_added = '';
    const object_properties = Object.getOwnPropertyNames(data);
    const num_properties = object_properties.length;
    for (let i = 0; i < num_properties; i++) {
      if (object_properties[i] === 'added_at') {
        date_added = data.added_at;
        data = data.track;
      }
    }
    super(data);
    this.artists = data.artists;
    this.display_name = Item.concatenateArtists(this.artists);
    // Tracks in an album do not have an album in thier data so we pass it manually
    this.album = album;
    if (this.album === '') {
      this.album = data.album.name;
    }
    this.date_added = date_added;
    this.duration_ms = data.duration_ms;
    this.duration = Item.calculateDurationString(this.duration_ms);
  }
}

export class Collection extends Item {
  constructor(data) {
    super(data);
    this.num_songs = data.tracks.total;
    // Initialise the following so they can be loaded when required
    this.tracks_href = data.tracks.href;
    this.duration_ms = 0;
    this.duration = '';
    this.tracks = [];
  }
  async getTracks() {
    const data = await library.getAllFromHref(this.tracks_href);
    const num_tracks = data.length;
    const tracks = [];
    if (this.type === 'playlist') {
      for (let i = 0; i < num_tracks; i++) {
        tracks.push(new Track(data[i]));
      }
    }
    else if (this.type === 'album') {
      for (let i = 0; i < this.num_songs; i++) {
        tracks.push(new Track(data[i], this.name));
      }
    }
    return tracks;
  }
  calculateTotalDuration() {
    const length = this.tracks.length;
    for (let i = 0; i < length; i++) {
      this.duration_ms += this.tracks[i].duration_ms;
    }
    const duration = Item.calculateDurationString(this.duration_ms, 'hours');
    return duration;
  }
  async loadTracks(item) {
    this.tracks = await this.getTracks(item);
    this.duration = this.calculateTotalDuration(item);
    return 0;
  }
}

export class Playlist extends Collection {
  constructor(data) {
    super(data);
    this.description = data.description;
    this.owner = data.owner.display_name;
    this.display_name = this.owner;
  }
}

export class Album extends Collection {
  constructor(data) {
    // Albums saved to library will have an album and an added_at property which this will parse
    let date_added = '';
    if (Object.getOwnPropertyNames(data).length === 2) {
      date_added = data.added_at;
      data = data.album;
    }
    super(data);
    this.artists = data.artists;
    this.display_name = Item.concatenateArtists(this.artists);
    this.album_type = data.album_type;
    this.release_date = data.release_date;
    this.release_year = this.release_date.substr(0, 4);
    this.label = data.label;
    this.date_added = date_added;
  }
}

// NOTE: the api says that you can get related artists but it is Deprecated so won't include it for now
export class Artist extends Item {
  constructor(data) {
    super(data);
    //console.log(data);
    this.followers = data.followers.total;
    // Initialise fields to be filled later
    this.top_tracks = [];
    this.discography = [];
    this.appears_on = [];
  }
  async getTopTracks() {
    const data = await library.getFromHref('https://api.spotify.com/v1/artists/' + this.id + '/top-tracks');
    const num_tracks = data.tracks.length;
    const top_tracks = [];
    for (let i = 0; i < num_tracks; i++) {
      top_tracks.push(new Track(data.tracks[i]));
    }
    return top_tracks;
  }
  async loadTopTracks() {
    this.top_tracks = await this.getTopTracks();
    return 0;
  }
  async getAlbums(include_groups = 'album,single,appears_on,compilation', market = 'ES', offset = 0, limit = 50) {
    const data = await library.getAllFromHref('https://api.spotify.com/v1/artists/' + this.id + '/albums' + '?' + new URLSearchParams({
      include_groups: include_groups,
      limit: limit,
      offset: offset,
      market: market
    }).toString()
    );
    const num_albums = data.length;
    const discography = [];
    for (let i = 0; i < num_albums; i++) {
      let album_data = await library.getFromHref(data[i].href);
      discography.push(new Album(album_data));
    }
    return discography;
  }
  async loadDiscography() {
    this.discography = await this.getAlbums('album,single,compilation');
    return 0;
  }
  async loadAppearsOn() {
    this.appears_on = await this.getAlbums('appears_on');
    return 0;
  }
  async loadArtistData() {
    this.top_tracks = await this.getTopTracks();
    this.discography = await this.getAlbums('album,single,compilation');
    this.appears_on = await this.getAlbums('appears_on');
    return 0;
  }
}