goofy/library.js at main · Chimildic/goofy

History

10000

// Документация: https://chimildic.github.io/goofy

// Телеграм: https://t.me/forum_goofy

// Форум: https://github.com/Chimildic/goofy/discussions

const VERSION = '2.1.0';

const UserProperties = PropertiesService.getUserProperties();

const KeyValue = UserProperties.getProperties();

const API_BASE_URL = 'https://api.spotify.com/v1';

const DEFAULT_DATE = new Date('2000-01-01');

function doGet() {

return Auth.hasAccess() ? displayLaunchPage_() : Auth.displayAuthPage();

}

function doPost(args) {

if (args.parameter.from?.includes("audiolist")) {

return Audiolist.onPost.bind(this)(args)

}

function displayAuthResult_(request) {

return Auth.displayAuthResult(request);

}

function displayLaunchPage_() {

try {

return HtmlService.createHtmlOutputFromFile('launch.html')

.addMetaTag('viewport', 'width=device-width, initial-scale=1')

.setXFrameOptionsMode(HtmlService.XFrameOptionsMode.ALLOWALL);

} catch {

return HtmlService.createHtmlOutput('Авторизация прошла успешно');

}

function runTasks_() {

RecentTracks.update();

let isUpdatedSavedTracks = Clerk.runOnceAWeek('monday', '01:00', updateSavedTracks);

!isUpdatedSavedTracks && Clerk.runOnceAfter('01:00', appendSavedTracks);

function updateSavedTracks(tracks) {

tracks = tracks || Source.getSavedTracks();

Cache.compressTracks(tracks);

Cache.write('SavedTracks.json', tracks);

}

function appendSavedTracks() {

let cacheTracks = Cache.read('SavedTracks.json');

let remoteTracks = Source.getSavedTracks(50);

Filter.removeTracks(remoteTracks, cacheTracks);

if (remoteTracks.length == 50 || cacheTracks.length == 0) {

updateSavedTracks();

} else if (remoteTracks.length > 0) {

updateSavedTracks(Combiner.push(remoteTracks, cacheTracks));

}

String.prototype.formatName = function () {

return this.toLowerCase()

.replace(/['`,?!@#$%^&*()+-./\\]/g, ' ')

.replace(/\s{2,}/g, ' ')

.replace(/ё/g, 'е')

.trim();

};

Date.prototype.setBound = function (value) {

if (value == 'startDay') {

this.setHours(0, 0, 0, 0);

} else if (value == 'endDay') {

this.setHours(23, 59, 59, 999);

}

return this;

};

Date.prototype.getTimestampUNIX = function (bound) {

return Math.trunc(this.setBound(bound).getTime() / 1000);

};

Object.prototype.isEmpty = function () {

return Object.keys(this).length == 0;

}

Array.prototype.toObject = function (parseMethod) {

return this.reduce((accumulator, element, i) => (accumulator[parseMethod(element)] = i, accumulator), {});

}

JSON.parseFromString = function (content) {

try {

return JSON.parse(content);

} catch (error) {

Admin.printError('Не удалось преобразовать строку JSON в объект JavaScript\n', error.stack, '\nКонтент:', `"${content}"`);

return undefined;

}

JSON.parseFromResponse = function (response) {

let content = response.getContentText();

if (content.length == 0) {

return { msg: 'Пустое тело ответа', status: response.getResponseCode() };

}

return JSON.parseFromString(content);

}

HtmlService.createCheerio = function (response) {

try {

return Cheerio.load(response.getContentText());

} catch (error) {

Admin.printInfo(error);

}

const CustomUrlFetchApp = (function () {

let countRequest = 0;

return {

fetch, fetchAll, parseQuery,

getCountRequest: () => countRequest,

};

function fetch(url, params = {}) {

params.muteHttpExceptions = true;

return readResponse(tryFetch(url, params), url, params);

}

function fetchAll(requests) {

requests.forEach((request) => (request.muteHttpExceptions = true));

let responses = [];

let limit = KeyValue.REQUESTS_IN_ROW || 20;

let count = Math.ceil(requests.length / limit);

for (let i = 0; i < count; i++) {

let requestPack = requests.splice(0, limit);

let responsePack = sendPack(requestPack).map((response, index) =>

readResponse(response, requestPack[index].url, {

headers: requestPack[index].headers,

payload: requestPack[index].payload,

muteHttpExceptions: requestPack[index].muteHttpExceptions,

})

);

Combiner.push(responses, responsePack);

}

return responses;

function sendPack(requests) {

let raw = tryFetchAll(requests);

if (typeof raw == 'undefined') {

return [];

}

let failed = raw.reduce((failed, response, index) => {

if (response.getResponseCode() == 429) {

failed.requests.push(requests[index])

failed.syncIndexes.push(index);

let seconds = parseRetryAfter(response);

if (failed.seconds < seconds) {

failed.seconds = seconds;

}

return failed;

}, { seconds: 0, requests: [], syncIndexes: [] });

if (failed.seconds > 0) {

Admin.pause(failed.seconds);

sendPack(failed.requests).forEach((response, index) => {

let requestIndex = failed.syncIndexes[index];

raw[requestIndex] = response;

});

}

return raw;

}

function tryFetchAll(requests) {

return tryCallback(() => {

countRequest += requests.length;

return UrlFetchApp.fetchAll(requests)

});

}

function readResponse(response, url, params = {}) {

if (isSuccess(response.getResponseCode())) {

return onSuccess();

}

return onError();

function isSuccess(code) {

return code >= 200 && code < 300;

}

function onSuccess() {

let type = response.getHeaders()['Content-Type'] || '';

if (type.includes('json')) {

return JSON.parseFromResponse(response) || [];

}

return response;

}

function onError() {

let responseCode = response.getResponseCode();

if (responseCode == 429) {

return onRetryAfter();

}

writeErrorLog();

if (responseCode >= 500) {

return tryFetchOnce();

}

function onRetryAfter() {

Admin.pause(parseRetryAfter(response));

return fetch(url, params);

}

function tryFetchOnce() {

Admin.pause(2);

response = tryFetch(url, params);

if (isSuccess(response.getResponseCode())) {

return onSuccess();

}

writeErrorLog();

}

function writeErrorLog() {

let errorText = response.getContentText().substring(0, 500)

if (errorText.toLowerCase().includes('access not granted')) {

throw `Нет прав доступа. Для повторной авторизации:\n1) Нажмите "начать развертывание > пробные развертывания"\n2) Перейдите по ссылке "веб-приложение"\n3) Подтвердите права доступа\n\nОшибка может возникать при смене пароля от Spotify аккаунта.\n\nЕсли при переходе по ссылке веб-приложения страница не открывается, повторите шаги в режиме инкогнито\n(Google делает автоматический редирект на другой аккаунт, где ваш проект с goofy недоступен).`

} else {

Admin.printError(`Номер: ${response.getResponseCode()}\nАдрес: ${url}\nМетод: ${params.method}\nТекст ответа: ${errorText}`);

}

function parseRetryAfter(response) {

return 1 + (parseInt(response.getHeaders()['Retry-After']) || 2);

}

function tryFetch(url, params) {

return tryCallback(() => {

countRequest++;

return UrlFetchApp.fetch(url, params)

});

}

function tryCallback(callback, attempt = 0) {

try {

return callback();

} catch (error) {

Admin.printError('При отправке запроса произошла ошибка:\n', error.stack);

if (attempt++ < 2) {

Admin.pause(5);

return tryCallback(callback, attempt);

}

function parseQuery(obj) {

return Object.keys(obj)

.map((k) => (typeof obj[k] != 'string' && obj[k] != undefined) || (typeof obj[k] == 'string' && obj[k].length > 0)

? `${encodeURIComponent(k)}=${encodeURIComponent(obj[k])}`

: ''

).filter(s => s.length > 0).join('&');

}

})();

const Audiolist = (function() {

const MESSAGE_TYPES = { DEFAULT: 'default', ERROR: 'error', WARNINNG: 'warning' }

const VARIABLE_TYPES = {

SPOTIFY_TRACK: { entityType: 'TRACK', platform: 'SPOTIFY', classType: 'SpotifyGoofyTrack' },

LASTFM_TRACK: { entityType: 'TRACK', platform: 'LASTFM', classType: 'LastfmGoofyTrack' },

}

function responseMessage(text, type = MESSAGE_TYPES.DEFAULT) {

return response({ message: text, messageType: type })

}

function responseItems(items, type) {

return response({ items, variableType: type })

}

function response(params = {}) {

if (params.items != undefined) {

if (params.variableType == undefined) {

throw "Отсутствует variableType"

} else if (!Array.isArray(params.items)) {

throw "items может быть только массивом"

} else {

if (params.variableType == VARIABLE_TYPES.LASTFM_TRACK) {

params.items = mapLastfmTracks(params.items)

}

params.items.forEach(i => (i.executorClassType = params.variableType.classType))

}

return ContentService.createTextOutput(JSON.stringify(params))

}

function mapLastfmTracks(items) {

return items.map(t => ({

artist: t.artist?.["#text"] || t.artist?.name || '',

album: t.album?.["#text"] || '',

name: t.name || '',

dateAt: parseInt(t.date?.uts) * 1000 || 0,

}))

}

return {

MESSAGE_TYPES, VARIABLE_TYPES, responseMessage, responseItems, response,

onPost(args) {

try {

this.Audiolist = Audiolist

let { funcName, ...data } = JSON.parse(args.postData.contents)

let func = funcName.split('.').reduce((acc, key) => acc?.[key], this)

if (func == undefined) {

return Audiolist.responseMessage(`Не удалось найти функцию с именем ${data.funcName}. Проверьте регистр букв и обновите развертывание.`, Audiolist.MESSAGE_TYPES.ERROR)

}

return func(data)

} catch (e) {

return Audiolist.responseMessage(e.message, Audiolist.MESSAGE_TYPES.ERROR)

}

hello() {

return responseMessage('Hello world! Тебе удалось соединить goofy и Audiolist. Можешь запускать любые функции и отправлять ответы. Например, встроенная функция "Audiolist.history" пришлет все треки из истории прослушиваний goofy. Чтобы использовать их в следующих командах, добавь выходную переменную для команды "Функция goofy".')

history() {

let recentTracks = RecentTracks.get()

return responseItems(recentTracks, Audiolist.VARIABLE_TYPES.SPOTIFY_TRACK)

}

})()

const Source = (function () {

return {

getTracks, getTracksRandom, getPlaylistTracks, getTopTracks, getTopArtists, getFollowedTracks, getSavedTracks,

getSavedAlbumTracks, getSavedAlbums, getRecomTracks, getArtists, getArtistsAlbums, getArtistsTracks,

getAlbumTracks, getAlbumsTracks, getArtistsTopTracks, getRelatedArtists, getCategoryTracks,

getListCategory, mineTracks, craftTracks, extractTracks, createUrlForRecomTracks, getRecentReleasesByArtists, getRecomArtists

};

function getTopTracks(timeRange) {

return getTop(timeRange, 'tracks');

}

function getTopArtists(timeRange) {

return getTop(timeRange, 'artists');

}

function getTop(timeRange, type) {

// Баг Spotify: https://community.spotify.com/t5/Spotify-for-Developers/Bug-with-offset-for-method-quot-Get-User-s-Top-Artists-and/td-p/5032362

let template = `${API_BASE_URL}/me/top/%s?offset=%s&limit=%s&time_range=%s_term`;

return SpotifyRequest.getAll([

Utilities.formatString(template, type, 0, 49, timeRange),

Utilities.formatString(template, type, 49, 49, timeRange),

], false).reduce((items, response) => {

return Combiner.push(items, response.items);

}, []);

}

function getListCategory(params = {}) {

let query = CustomUrlFetchApp.parseQuery(params);

let url = `${API_BASE_URL}/browse/categories?${query}`;

return SpotifyRequest.get(url).items;

}

function getCategoryTracks(category_id, params = {}) {

let query = CustomUrlFetchApp.parseQuery(params);

let url = `${API_BASE_URL}/browse/categories/${category_id}/playlists?${query}`;

return getTracks(SpotifyRequest.get(url).items);

}

function getRelatedArtists(artists, isFlat = true) {

return getArtistsByPath(artists, '/artists/%s/related-artists', isFlat);

}

function getArtistsTopTracks(artists, isFlat = true) {

return getArtistsByPath(artists, '/artists/%s/top-tracks?market=from_token', isFlat);

}

function getArtistsByPath(artists, path, isFlat) {

let template = API_BASE_URL + path;

let urls = artists.reduce((urls, artist) => {

urls.push(Utilities.formatString(template, artist.id));

return urls;

}, []);

let responses = SpotifyRequest.getAll(urls);

return isFlat ? responses.flat(1) : responses;

}

function getRecomTracks(queryObj) {

let url = createUrlForRecomTracks(queryObj);

return SpotifyRequest.get(url).tracks;

}

function getRecomArtists(artists, queryObj = {}, isFlat = true) {

let isFullArtist = queryObj.isFullArtist

delete queryObj.isFullArtist

let urls = artists.map(artist => {

let params = Object.assign({}, queryObj)

params.limit = params.limit || 50

if (queryObj.seed_artists == undefined) {

params.seed_artists = artist.id

} else {

params.seed_artists += `,${artist.id}`

}

return createUrlForRecomTracks(params)

})

let recomTrackGroups = SpotifyRequest.getAll(urls)

let result = recomTrackGroups

.map(response => response.tracks.reduce((acc, track) => {

if (artists && artists.length > 0) {

acc.push(track.artists[0])

}

return acc

}, []))

if (isFullArtist) {

result = result.map(artists => Source.getArtists({ include: artists }))

}

return isFlat ? result.flat(1) : result

}

function getFollowedTracks(params = {}) {

let playlists = getFollowedPlaylists(params.type, params.userId, params.exclude);

Selector.keepRandom(playlists, params.limit);

return !params.hasOwnProperty('isFlat') || params.isFlat ? getTracks(playlists) : playlists.map(p => {

p.tracks.items = getTracks([p]);

return p;

});

}

function getArtistsTracks(params) {

let artists = getArtists(params.artist);

params.album = params.album || {};

params.album.isFlat = false;

let tracks = getArtistsAlbums(artists, params.album).reduce((tracks, albums) => {

tracks.push(getAlbumsTracks(albums, params.album.track_limit));

return tracks;

}, []);

return !params.hasOwnProperty('isFlat') || params.isFlat ? tracks.flat(1) : tracks;

}

function getArtists(paramsArtist) {

let artists = [];

if (paramsArtist.include) {

Combiner.push(artists, getArtistsById(paramsArtist.include));

}

if (paramsArtist.followed_include) {

Combiner.push(artists, getFollowedArtists());

}

if (paramsArtist.exclude) {

let excludeIds = paramsArtist.exclude.map((item) => item.id);

artists = artists.filter((item) => !excludeIds.includes(item.id));

}

artists = artists.filter((artist) => {

artist.followers = artist.followers.total || artist.followers;

return (

RangeTracks.isBelong(artist, paramsArtist) &&

RangeTracks.isBelongGenres(artist.genres, paramsArtist.genres) &&

!RangeTracks.isBelongBanGenres(artist.genres, paramsArtist.ban_genres)

);

});

return Selector.sliceRandom(artists, paramsArtist.artist_limit);

}

function getArtistsById(artistsArray) {

let ids = artistsArray.map((item) => item.id);

return SpotifyRequest.getFullObjByIds('artists', ids, 50);

}

function getFollowedArtists() {

return SpotifyRequest.getItemsByPath('me/following?type=artist&limit=50');

}

function getArtistsAlbums(artists, params = {}) {

let groups = params.groups || 'album,single';

let albums = artists.reduce((albums, artist) => {

let path = `artists/${artist.id}/albums?include_groups=${groups}&limit=50&market=from_token`;

let response = SpotifyRequest.getItemsByPath(path).filter((album) => RangeTracks.isBelongReleaseDate(album.release_date, params.release_date));

Filter.dedupAlbums(response);

albums.push(Selector.sliceRandom(response, params.album_limit));

return albums;

}, []);

return !params.hasOwnProperty('isFlat') || params.isFlat ? albums.flat(1) : albums;

}

function getAlbumsTracks(albums, limit) {

return albums.reduce((tracks, album) => {

return Combiner.push(tracks, getAlbumTracks(album, limit));

}, []);

}

function getAlbumTracks(album, limit) {

let items = SpotifyRequest.getItemsByPath(`albums/${album.id}/tracks`);

Selector.keepRandom(items, limit);

return items.map((item) => {

item.album = album;

return item;

});

}

function getSavedAlbumTracks(limit) {

let items = getSavedAlbums();

Selector.keepRandom(items, limit);

return items.reduce((tracks, album) => {

let albumTracks = album.tracks.items.map(item => (item.album = album, item));

// Фикс ошибки при использовании JSON.stringify

// TypeError: Converting circular structure to JSON

delete album.tracks;

return Combiner.push(tracks, albumTracks)

}, []);

}

function getSavedAlbums() {

return SpotifyRequest.getItemsByPath('me/albums?limit=50', 400).map((item) => {

let album = item.album;

album.added_at = item.added_at;

return album;

});

}

function getFollowedPlaylists(type = 'followed', userId = User.id, excludePlaylist = []) {

let playlistArray = Playlist.getPlaylistArray(userId);

if (type != 'all') {

playlistArray = playlistArray.filter((playlist) => {

let isOwned = playlist.owner.id == userId;

return type == 'owned' ? isOwned : !isOwned;

});

}

if (excludePlaylist.length > 0) {

let ids = excludePlaylist.map((item) => item.id);

playlistArray = playlistArray.filter((item) => !ids.includes(item.id));

}

return playlistArray;

}

function getRecentReleasesByArtists(params) {

if (params.artists.length >= 300) {

console.warn(`При большом количестве исполнителей (запрошено ${params.artists.length}) функция может не уложиться в лимит времени выполнения\nили получить временный бан от Spotify за спам запросами.\n\nВоспользуйтесь шаблоном: https://chimildic.github.io/goofy/#/template?id=Новые-релизы-по-частям`)

}

let initDateStr = new Date().toISOString()

let startDate = params.hasOwnProperty('sinceDays') ? Filter.getDateRel(params.beforeDays, 'startDay') : params.startDate

let types = params.type.sort((a, b) => a.localeCompare(b))

let requestUrls = params.artists.map(artist => `${API_BASE_URL}/artists/${artist.id}/albums?include_groups=${types.join(",")}&limit=50&market=from_token`)

let foundReleases = {}

let uncompleteRequests = []

SpotifyRequest.getAll(requestUrls).forEach((response, index) => {

let minFoundDateStrings = types.reduce((acc, type) => (acc[type] = initDateStr, acc), {})

let artistId = params.artists[index].id

foundReleases[artistId] = foundReleases[artistId] || {}

foundReleases[artistId].albums = response.items.filter(album => {

minFoundDateStrings[album.album_type] = album.release_date

return RangeTracks.isBelongReleaseDate(album.release_date, params.date)

})

if (response.items.length == 50 && response.next != undefined) {

let notFoundTypes = []

Object.entries(minFoundDateStrings).forEach(([albumType, dateStr]) => {

let minFoundDate = new Date(dateStr)

if (startDate < minFoundDate) {

notFoundTypes.push(albumType)

}

})

if (notFoundTypes.length > 0) {

uncompleteRequests.push({ id: artistId, groups: notFoundTypes })

}

})

uncompleteRequests.forEach(item => {

let artistAlbums = Source.getArtistsAlbums(/* artist = { id: '' }*/ item, /* params = { groups: [] }*/ item)

Combiner.push(foundReleases[item.id].albums, artistAlbums)

})

let trackGroups = Object.entries(foundReleases).map(([artistId, data]) => {

Filter.dedupAlbums(data.albums)

return Source.getAlbumsTracks(data.albums) || []

})

if (!params.hasOwnProperty('isFlat') || params.isFlat) {

let tracks = trackGroups.flat(1)

Order.sort(tracks, 'album.release_date', 'desc')

return tracks

}

return trackGroups

}

function mineTracks(params) {

let findMethod, getTracksMethod;

let selectMethod = params.hasOwnProperty('inRow') && params.inRow ? Selector.keepFirst : Selector.keepRandom;

if (params.type == 'album') {

findMethod = Search.findAlbums;

getTracksMethod = getAlbumsTracks;

} else if (params.type == 'track') {

findMethod = Search.findTracks;

// getTracksMethod - не нужно, треки уже в результате поиска

} else {

params.type = 'playlist';

findMethod = Search.findPlaylists;

getTracksMethod = getTracks;

}

let result = findMethod(params.keyword, params.requestCount);

if (params.type == 'playlist' && params.hasOwnProperty('followers')) {

filterByFollowers();

}

let tracks = reduceResult();

Filter.dedupTracks(tracks);

return tracks;

function reduceResult() {

return result.reduce((tracks, array) => {

selectMethod(array, params.itemCount || 3);

Selector.keepAllExceptFirst(array, params.skipCount || 0);

let trackItems = getTracksMethod ? getTracksMethod(array) : array;

return Combiner.push(tracks, filterPopularity(trackItems));

}, []);

}

function filterByFollowers() {

for (let i = 0; i < result.length; i++) {

result[i] = getFullPlaylistObject(result[i]).filter((p) => {

return isBelongRangeFollowers(p.followers.total);

});

}

function filterPopularity(array) {

if (!params.hasOwnProperty('popularity')) {

return array;

}

if (array[0] && !array[0].hasOwnProperty('popularity')) {

let ids = array.map((t) => t.id);

array = SpotifyRequest.getFullObjByIds('tracks', ids, 50);

}

return array.filter((t) => t.popularity >= (params.popularity || 0));

}

function getFullPlaylistObject(array) {

let urls = array.map(p => `${API_BASE_URL}/playlists/${p.id}`);

return SpotifyRequest.getAll(urls);

}

function isBelongRangeFollowers(value) {

return value >= params.followers.min && value <= params.followers.max;

}

function craftTracks(tracks, params = {}) {

let recomTracks = SpotifyRequest.getAll(createUrls()).reduce((recomTracks, response) => {

return Combiner.push(recomTracks, response.tracks);

}, []);

Filter.dedupTracks(recomTracks);

return recomTracks;

function createUrls() {

let urls = [];

let queryObj = params.query || {};

let ids = mapToIds();

let availablePosition = findAvailablePosition();

let count = Math.ceil(ids.length / availablePosition);

for (let i = 0; i < count; i++) {

queryObj[params.key] = ids.splice(0, availablePosition).join(',');

urls.push(createUrlForRecomTracks(queryObj));

}

return urls;

}

function mapToIds() {

let ids;

if (params.key == 'seed_artists') {

ids = tracks.map((t) => (t.artists ? t.artists[0].id : t.id));

} else {

ids = tracks.map((t) => t.id);

params.key = 'seed_tracks';

}

return Array.from(new Set(ids));

}

function findAvailablePosition() {

let value = 5;

if (!params.hasOwnProperty('query')) {

return value;

}

if (params.query.hasOwnProperty('seed_genres')) {

value -= params.query.seed_genres.split(',').length;

}

if (params.query.hasOwnProperty('seed_tracks') && params.key != 'seed_tracks') {

value -= params.query.seed_tracks.split(',').length;

}

if (params.query.hasOwnProperty('seed_artists') && params.key != 'seed_artists') {

value -= params.query.seed_artists.split(',').length;

}

if (value <= 0) {

throw `Не осталось места под ${params.key}. Уменьшите количество значения других seed_*`;

}

return value;

}

function createUrlForRecomTracks(queryObj) {

queryObj.limit = queryObj.limit > 100 ? 100 : queryObj.limit || 100;

queryObj.market = queryObj.market || 'from_token';

let query = CustomUrlFetchApp.parseQuery(queryObj);

return `${API_BASE_URL}/recommendations?${query}`;

}

function getTracksRandom(playlistArray, countPlaylist = 1) {

return getTracks(Selector.sliceRandom(playlistArray, countPlaylist));

}

function getPlaylistTracks(name, id, userId, count, inRow) {

return getTracks([{ id: id, name: name, userId: userId, count: count, inRow: inRow == undefined ? true : inRow }]);

}

function getTracks(playlistArray) {

return extractTracks(getTrackItems(playlistArray));

}

function getTrackItems(playlistArray) {

return playlistArray.reduce((items, playlist) => {

let playlistItems = [];

if (typeof playlist == 'undefined') {

return items;

}

if (playlist.id) {

playlistItems = getItemsByPlaylistId(playlist.id);

} else if (playlist.name) {

playlistItems = getItemsByPlaylistName(playlist.name, playlist.userId);

}

if (!playlist.hasOwnProperty('inRow') || playlist.inRow) {

Selector.keepFirst(playlistItems, playlist.count);

} else {

Selector.keepRandom(playlistItems, playlist.count);

}

return Combiner.push(items, playlistItems);

}, []);

}

function getItemsByPlaylistId(playlistId) {

let playlist = Playlist.getById(playlistId);

return getItemsByPlaylistObject(playlist);

}

function getItemsByPlaylistName(playlistName, userId) {

let playlist = Playlist.getByName(playlistName, userId);

if (!playlist || !playlist.id) {

return [];

}

return getItemsByPlaylistId(playlist.id);

}

function getItemsByPlaylistObject(obj) {

let items = [];

if (obj && obj.tracks && obj.tracks.items) {

items = obj.tracks.total <= 100 ? obj.tracks.items : SpotifyRequest.getItemsByNext(obj.tracks);

items.forEach((item) => (item.origin = { id: obj.id, name: obj.name, type: obj.type }));

}

return items;

}

function getSavedTracks(limit = 200000) {

let requestCount = Math.ceil(limit / 50);

let items = SpotifyRequest.getItemsByPath('me/tracks?limit=50', requestCount);

return Selector.sliceFirst(extractTracks(items), limit);

}

function extractTracks(items) {

if (!items || items.length == 0) return [];

let key = items[0].played_at ? 'played_at' : 'added_at';

return items.reduce((tracks, item) => {

if ((!item.hasOwnProperty('is_local') || !item.is_local) && item.track && item.track.artists && item.track.artists.length > 0) {

let date = item[key] ? item[key] : DEFAULT_DATE.toISOString();

item.track[key] = date;

if (item.hasOwnProperty('origin')) {

item.track.origin = item.origin;

}

tracks.push(item.track);

}

return tracks;

}, []);

}

})();

const Player = (function () {

return {

getPlayback, transferPlayback, getAvailableDevices, next, previous, pause, resume, toggleShuffle, setRepeatMode, addToQueue,

};

function getPlayback() {

return SpotifyRequest.get(`${API_BASE_URL}/me/player`) || {};

}

function transferPlayback(deviceId, isPlay) {

return SpotifyRequest.put(`${API_BASE_URL}/me/player`, { device_ids: [deviceId], play: isPlay, });

}

function getAvailableDevices() {

return SpotifyRequest.get(`${API_BASE_URL}/me/player/devices`);

}

function next(deviceId) {

return SpotifyRequest.post(createUrl('/me/player/next', deviceId));

}

function previous(deviceId) {

return SpotifyRequest.post(createUrl('/me/player/previous', deviceId));

}

function pause(deviceId) {

return SpotifyRequest.put(createUrl('/me/player/pause', deviceId));

}

function toggleShuffle(state, deviceId) {

return SpotifyRequest.put(createUrl('/me/player/shuffle', deviceId, { state: state }));

}

function setRepeatMode(state, deviceId) {

return SpotifyRequest.put(createUrl('/me/player/repeat', deviceId, { state: state }));

}

function resume(params = {}) {

if (params.hasOwnProperty('tracks')) {

params.uris = params.tracks.map(t => t.uri || `spotify:track:${t.id}`);

delete params.tracks;

}

let url = createUrl('/me/player/play', params.deviceId);

return SpotifyRequest.put(url, params);

}

function addToQueue(tracks, deviceId) {

Array.isArray(tracks) ? tracks.forEach(t => addItem(t.id)) : addItem(tracks.id);

function addItem(id) {

let queryObj = { uri: `spotify:track:${id}` };

let url = createUrl('/me/player/queue', deviceId, queryObj);

return SpotifyRequest.post(url);

}

function createUrl(path, deviceId = '', queryObj = {}) {

queryObj.device_id = queryObj.device_id || deviceId;

let query = CustomUrlFetchApp.parseQuery(queryObj);

return API_BASE_URL + path + `?${query ? query : ''}`;

}

})();

const RecentTracks = (function () {

const ON_SPOTIFY_RECENT_TRACKS = 'true' === KeyValue.ON_SPOTIFY_RECENT_TRACKS;

const ON_LASTFM_RECENT_TRACKS = 'true' === KeyValue.ON_LASTFM_RECENT_TRACKS;

const SPOTIFY_FILENAME = 'SpotifyRecentTracks.json';

const LASTFM_FILENAME = 'LastfmRecentTracks.json';

const BOTH_SOURCE_FILENAME = 'BothRecentTracks.json';

const ITEMS_LIMIT = parseInt(KeyValue.COUNT_RECENT_TRACKS) || 60000;

return {

get, update, compress, appendTracks,

};

function get(limit) {

let tracks = [];

if (ON_SPOTIFY_RECENT_TRACKS && ON_LASTFM_RECENT_TRACKS) {

tracks = Cache.read(BOTH_SOURCE_FILENAME);

} else if (ON_SPOTIFY_RECENT_TRACKS) {

tracks = Cache.read(SPOTIFY_FILENAME);

} else if (ON_LASTFM_RECENT_TRACKS) {

tracks = Cache.read(LASTFM_FILENAME);

}

return Selector.sliceFirst(tracks, limit);

}

function update() {

let hasUpdate = 0;

if (ON_SPOTIFY_RECENT_TRACKS) {

hasUpdate += updatePlatformRecentTracks(getSpotifyRecentTracks(), SPOTIFY_FILENAME, findNewPlayed);

}

if (ON_LASTFM_RECENT_TRACKS) {

let lastfmTracks = Lastfm.getLastfmRecentTracks(KeyValue.LASTFM_LOGIN, parseInt(KeyValue.LASTFM_RANGE_RECENT_TRACKS));

hasUpdate += updatePlatformRecentTracks(lastfmTracks, LASTFM_FILENAME, Lastfm.findNewPlayed);

}

if (hasUpdate > 0 && ON_SPOTIFY_RECENT_TRACKS && ON_LASTFM_RECENT_TRACKS) {

updateBothSourceRecentTracks();

}

function updatePlatformRecentTracks(recentTracks, filename, findNewPlayedMethod) {

let fileItems = Cache.read(filename);

let newItems = findNewPlayedMethod(recentTracks, fileItems);

return appendNewPlayed(newItems, filename);

}

function updateBothSourceRecentTracks() {

let spotifyTracks = Cache.read(SPOTIFY_FILENAME);

let lastfmTracks = Cache.read(LASTFM_FILENAME);

Combiner.push(spotifyTracks, lastfmTracks);

Order.sort(spotifyTracks, 'meta.played_at', 'desc');

Filter.dedupTracks(spotifyTracks);

Cache.write(BOTH_SOURCE_FILENAME, spotifyTracks);

}

function appendNewPlayed(newItems, filename) {

if (newItems.length == 0) {

Admin.printInfo(`Нет новых треков ${filename}`);

return false;

}

Cache.compressTracks(newItems);

let total = Cache.append(filename, newItems, 'begin', ITEMS_LIMIT);

Admin.printInfo(`+${newItems.length}, всего: ${total} (${filename})`);

return true;

}

function getSpotifyRecentTracks() {

let url = `${API_BASE_URL}/me/player/recently-played?limit=50`;

return Source.extractTracks(SpotifyRequest.get(url).items);

}

function findNewPlayed(recentItems, fileItems) {

if (fileItems.length == 0) {

return recentItems;

}

let lastPlayedTime = new Date(fileItems[0].played_at).getTime();

for (let i = recentItems.length - 1; i >= 0; i--) {

let time = new Date(recentItems[i].played_at).getTime();

if (time - lastPlayedTime == 0) {

return recentItems.slice(0, i);

}

return recentItems.filter(recentItem => {

return -1 == fileItems.findIndex(fileItem =>

fileItem.name == recentItem.name

&& fileItem.played_at == recentItem.played_at);

});

}

function appendTracks(filename, tracks) {

Cache.compressTracks(tracks);

tracks.forEach((t) => {

if (t.hasOwnProperty('added_at')) {

t.played_at = t.added_at;

delete t.added_at;

} else if (!t.hasOwnProperty('played_at')) {

t.played_at = new Date().toISOString();

}

});

let fileItems = Cache.read(filename);

Combiner.push(fileItems, tracks);

Order.sort(fileItems, 'meta.played_at', 'desc');

Cache.write(filename, fileItems);

}

function compress() {

if (ON_SPOTIFY_RECENT_TRACKS) {

compressFile(SPOTIFY_FILENAME);

}

if (ON_LASTFM_RECENT_TRACKS) {

compressFile(LASTFM_FILENAME);

}

if (ON_SPOTIFY_RECENT_TRACKS && ON_LASTFM_RECENT_TRACKS) {

compressFile(BOTH_SOURCE_FILENAME);

}

function compressFile(filename) {

Cache.copy(filename);

let tracks = Cache.read(filename);

Cache.compressTracks(tracks);

Cache.write(filename, tracks);

}

})();

const Combiner = (function () {

return {

alternate, mixinMulti, mixin, replace, push,

};

function replace(oldArray, newArray) {

oldArray.length = 0;

push(oldArray, newArray);

}

function push(sourceArray, ...additionalArray) {

additionalArray.forEach((array) => {

array = Array.isArray(array) ? array : [array];

if (array.length < 1000) {

sourceArray.push.apply(sourceArray, array);

} else {

array.forEach((item) => sourceArray.push(item));

}

});

return sourceArray;

}

function alternate(bound, ...arrays) {

let limitLength = getLimitLength(bound, arrays);

const resultArray = [];

for (let i = 0; i < limitLength; i++) {

pushPack(i);

}

return resultArray;

function pushPack(index) {

View remainder of file in raw view

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

library.js

library.js

Files

library.js

Latest commit

History

library.js

File metadata and controls