← Back to branch summary

~stephen-stewart/online-services-common-js/update-global-nav

« back to all changes in this revision

Viewing changes to build/music-io/music-io-debug.js

  • Committer: Stephen Stewart
  • Date: 2014-02-22 15:05:16 UTC
  • Revision ID: stephen.stewart@canonical.com-20140222150516-rkzti2c43ggwr2ta
import latest js, convert

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/music-io/music-io-debug.js
 
1
YUI.add('music-io', function (Y, NAME) {
 
2
 
 
3
"use strict";
 
4
/*global STREAMING_URL, STREAMING_PASS, STREAMING_USER */
 
5
var ERRATA = 'c=web&v=1.2&f=json',
 
6
    ONEERROR = 'one:error',
 
7
    EMPTY = '',
 
8
    AMPERSAND = '&',
 
9
    AMPERSANDSONGEQUALS = '&songId=',
 
10
    CREATEPLAYLISTVIEW = 'createPlaylist.view?',
 
11
    GETMUSICDIRECTORYVIEW = 'getMusicDirectory.view?id=',
 
12
    GETRANDOMSONGSVIEW = 'getRandomSongs.view?',
 
13
    SIZE='size',
 
14
    SRC = 'src',
 
15
    namespace = Y.namespace('Music');
 
16
 
 
17
namespace.DataSource = Y.Base.create('dataSource', Y.DataSource.IO, [], {
 
18
    /* This is perverse, I know, but it prevents DRY, so hooray. */
 
19
    _defDataFn: function(e) {
 
20
        var data = e.data,
 
21
        meta = e.meta,
 
22
        response = {
 
23
            results: (Y.Lang.isArray(data)) ? data: [data],
 
24
            meta: (meta) ? meta : {}
 
25
        };
 
26
        try {
 
27
            response.json = Y.JSON.parse(e.data.responseText)['subsonic-response'];
 
28
            if (response.json.error) {
 
29
                Y.Global.fire(ONEERROR, {
 
30
                    message: response.json.error.message
 
31
                });
 
32
                Y.Do.Halt('An error in the API caused a halt');
 
33
                return;
 
34
            }
 
35
        } catch(ex) {}
 
36
        this.fire('response', Y.mix({
 
37
            'response': response}, e));
 
38
    },
 
39
    getArtists: function(callback) {
 
40
        this.sendRequest({
 
41
            request: 'getIndexes.view?' + ERRATA,
 
42
            callback: {
 
43
                failure: function() { Y.Global.fire(ONEERROR); },
 
44
                success: callback
 
45
            }
 
46
        });
 
47
    },
 
48
    createPlaylist: function(name, songs, callback) {
 
49
        var songParams = EMPTY,
 
50
        songsLength = songs.length,
 
51
        i,
 
52
        params;
 
53
 
 
54
        for (i = 0; i < songsLength; i++) {
 
55
            songParams = songParams + AMPERSANDSONGEQUALS + songs[i];
 
56
        }
 
57
        params = 'name=' + name + songParams;
 
58
        this.sendRequest({
 
59
            request: CREATEPLAYLISTVIEW + params + AMPERSAND + ERRATA,
 
60
            callback: {
 
61
                success: callback,
 
62
                failure: function() { Y.Global.fire(ONEERROR); }
 
63
            }
 
64
        });
 
65
    },
 
66
    updatePlaylist: function(playlistId, songs, callback) {
 
67
        var songParams = EMPTY,
 
68
        songsLength = songs.length,
 
69
        i,
 
70
        params;
 
71
 
 
72
        for (i = 0; i < songsLength; i++) {
 
73
            songParams = songParams + AMPERSANDSONGEQUALS + songs[i];
 
74
        }
 
75
        params = 'playlistId=' + playlistId + songParams;
 
76
        this.sendRequest({
 
77
            request: CREATEPLAYLISTVIEW + params + AMPERSAND + ERRATA,
 
78
            callback: {
 
79
                success: callback,
 
80
                failure: function() { Y.Global.fire(ONEERROR); }
 
81
            }
 
82
        });
 
83
    },
 
84
    deletePlaylist: function(playlistId, callback) {
 
85
        this.sendRequest({
 
86
            request: 'deletePlaylist.view?id=' + playlistId + AMPERSAND + ERRATA,
 
87
            callback: {
 
88
                success: callback
 
89
            }
 
90
        });
 
91
    },
 
92
    getPlaylist: function(playlistId, callback) {
 
93
        this.sendRequest({
 
94
            request: 'getPlaylist.view?id=' + playlistId + AMPERSAND + ERRATA,
 
95
            callback: {
 
96
                success: callback
 
97
            }
 
98
        });
 
99
    },
 
100
    getSongs: function(callback) {
 
101
        this.sendRequest({
 
102
            request: 'getSongs.view?' + ERRATA,
 
103
            callback: {
 
104
                failure: function() { Y.Global.fire(ONEERROR); },
 
105
                success: callback
 
106
            }
 
107
        });
 
108
    },
 
109
    getRandomSongs: function(nResults, callback) {
 
110
        var url = null;
 
111
        if (!nResults) {
 
112
            url = GETRANDOMSONGSVIEW + ERRATA;
 
113
        } else {
 
114
            url = GETRANDOMSONGSVIEW + SIZE + "=" + nResults + AMPERSAND + ERRATA;
 
115
        }
 
116
        this.sendRequest({
 
117
            request: url,
 
118
            callback: {
 
119
                failure: function() { Y.Global.fire(ONEERROR); },
 
120
                success: callback
 
121
            }
 
122
        });
 
123
    },
 
124
    getAlbums: function(artistId, callback) {
 
125
        var url = null;
 
126
        if (!artistId) {
 
127
            url = 'getAlbums.view?' + ERRATA;
 
128
        } else {
 
129
            url = GETMUSICDIRECTORYVIEW + artistId + AMPERSAND + ERRATA;
 
130
        }
 
131
        this.sendRequest({
 
132
            request: url,
 
133
            callback: {
 
134
                failure: function() { Y.Global.fire(ONEERROR); },
 
135
                success: callback
 
136
            }
 
137
        });
 
138
    },
 
139
    getAlbum: function(albumId, callback) {
 
140
        this.sendRequest({
 
141
            request: GETMUSICDIRECTORYVIEW + albumId + AMPERSAND + ERRATA,
 
142
            callback: {
 
143
                failure: function() { Y.Global.fire(ONEERROR); },
 
144
                success: callback
 
145
            }
 
146
        });
 
147
    },
 
148
    getStreamingURI: function(song) {
 
149
        if (song === undefined) {
 
150
            return null;
 
151
        } else {
 
152
            return STREAMING_URL + '/rest/stream.view?id=' + song.id + '&u=' + STREAMING_USER + '&p=' + STREAMING_PASS + AMPERSAND + ERRATA;
 
153
        }
 
154
    },
 
155
    getAlbumArt: function(song, image) {
 
156
        var defaultURL = MEDIA_URL + 'img/default-album-art.png',
 
157
        url;
 
158
 
 
159
        image.set("alt", EMPTY);
 
160
        if (song.coverArt === undefined) {
 
161
            image.set(SRC, defaultURL);
 
162
            return;
 
163
        }
 
164
        url = 'getCoverArt.view?id=' + song.coverArt + AMPERSAND + ERRATA;
 
165
        image.set(SRC, this.get('source') + url);
 
166
    },
 
167
    search: function(term, callback) {
 
168
        this.sendRequest({
 
169
            request: 'search.view?any=' + term + AMPERSAND + ERRATA,
 
170
            callback: {
 
171
                success: callback
 
172
            }
 
173
        });
 
174
    }
 
175
}, {
 
176
    ATTRS: {
 
177
        plugins: [
 
178
            {fn: Y.Plugin.DataSourceCache, cfg: { max: 3 }}
 
179
        ],
 
180
        source: { value: '/api/music/1.0/' }
 
181
    }
 
182
});
 
183
 
 
184
namespace.PlaylistsDS = Y.Base.create('playlistsds', Y.DataSource.IO, [], {
 
185
    /* This is perverse, I know, but it prevents DRY, so hooray. */
 
186
    _defDataFn: function(e) {
 
187
        var data = e.data,
 
188
        meta = e.meta,
 
189
        response = {
 
190
            results: (Y.Lang.isArray(data)) ? data: [data],
 
191
            meta: (meta) ? meta : {}
 
192
        };
 
193
        try {
 
194
            response.json = Y.JSON.parse(e.data.responseText)['subsonic-response'];
 
195
            if (response.json.error) {
 
196
                Y.Global.fire(ONEERROR, {
 
197
                    message: response.json.error.message
 
198
                });
 
199
                Y.Do.Halt('An error in the API caused a halt');
 
200
                return;
 
201
            }
 
202
        } catch(ex) {}
 
203
        this.fire('response', Y.mix({
 
204
            'response': response}, e));
 
205
    },
 
206
    getPlaylists: function(callback) {
 
207
        this.sendRequest({
 
208
            request: 'getPlaylists.view?' + ERRATA,
 
209
            callback: {
 
210
                failure: function() { Y.Global.fire(ONEERROR); },
 
211
                success: callback
 
212
            }
 
213
        });
 
214
    }
 
215
}, {
 
216
    ATTRS: {
 
217
        plugins: [
 
218
            {fn: Y.Plugin.DataSourceCache, cfg: { max: 3 }}
 
219
        ],
 
220
        source: { value: '/api/music/1.0/' }
 
221
    }
 
222
});
 
223
 
 
224
 
 
225
}, '@VERSION@', {
 
226
    "requires": [
 
227
        "datasource-local",
 
228
        "datasource-io",
 
229
        "datasource-get",
 
230
        "datasource-function",
 
231
        "datasource-cache",
 
232
        "datasource-jsonschema",
 
233
        "datasource-xmlschema",
 
234
        "datasource-arrayschema",
 
235
        "datasource-textschema",
 
236
        "datasource-polling"
 
237
    ]
 
238
});