move

src/store/modules/albums/actions.js

@@ -0,0 +1,157 @@
+import axios from 'axios'
+import router from '../../../router'
+
+export default {
+  clear(context) {
+    context.commit("clear");
+  },
+  filter(context, term) {
+    return new Promise((resolve) => {
+      axios.get(context.rootGetters.server + "/api/albums/filter/" + term, context.rootGetters.headers).then(res => {
+        resolve(res.data);
+      });
+    })
+  },
+  getNextTo(context, album) {
+    return new Promise(resolve => {
+      let i = context.getters.collection.indexOf(album);
+      if (i > -1 && i < context.getters.collection.length - 1) {
+        resolve(context.getters.collection[++i]);
+      }
+      resolve();
+    });
+  },
+  getPrevTo(context, album) {
+    return new Promise(resolve => {
+      let i = context.getters.collection.indexOf(album);
+      if (i > 0) {
+        resolve(context.getters.collection[--i]);
+      }
+      resolve();
+    })
+
+  },
+  loadAlbums(context, force) {
+    if ((!context.state.eos || force) && !context.state.loading) {
+      context.state.loading = true;
+      axios.get(context.rootGetters.server + "/api/albums/page/" + context.state.page++, context.rootGetters.headers).then((res) => {
+        context.commit("setAlbums", res.data);
+      });
+    }
+  },
+  loadFavourites(context) {
+    axios.get(context.rootGetters.server + "/api/albums/favourites", context.rootGetters.headers).then(res => {
+      if (res.data.length > 0) {
+        context.commit("setAlbums", res.data);
+      }
+    });
+  },
+  loadNewest(context) {
+    axios.get(context.rootGetters.server + "/api/albums/newest/6", context.rootGetters.headers).then((res) => {
+      context.commit("setNewest", res.data);
+    });
+  },
+  loadAlbum(context, id) {
+    context.state.loading = true;
+    return new Promise((resolve) => {
+      axios.get(context.rootGetters.server + "/api/albums/" + id, context.rootGetters.headers).then((res) => {
+        if (res.data != "") {
+          context.commit("setAlbums", [res.data]);
+        } else {
+          context.state.loading = false;
+        }
+        resolve(res.data);
+      })
+    })
+  },
+  resetSelectedAlbum(context) {
+    context.commit("resetSelectedAlbum");
+    router.push("/albums");
+  },
+  move(context, payload) {
+    return new Promise((resolve) => {
+      axios.put(context.rootGetters.server + "/api/albums/" + payload.source + "/move", payload, context.rootGetters.headers).then(res => {
+        resolve(res.data);
+      });
+    })
+  },
+  remove(context, id) {
+    context.commit("remove", id);
+  },
+  selectAlbum(context, album) {
+    if (album.tracks.length == 0) {
+      context.dispatch("loadAlbum", album._id);
+    }
+
+    context.commit('selectAlbum', album);
+    if (context.rootGetters.routerQuery.id != album._id) {
+      let url = "/albums?id=" + album._id;
+      let track = context.rootGetters["tracks/selectedTrack"];
+      if (track._id && track.parentType == "album" && track.parent._id == album._id) {
+        url += "&play=" + track._id
+      }
+      router.push(url);
+    }
+    context.dispatch("preloads");
+  },
+  preloads(context) {
+    // PRELOAD NEXT AND PREV ALBUM
+    let next = context.getters.nextAlbum;
+    if (next._id && next.tracks.length == 0) {
+      context.dispatch("loadAlbum", next._id);
+    }
+    let prev = context.getters.prevAlbum;
+    if (prev._id && prev.tracks.length == 0) {
+      context.dispatch("loadAlbum", prev._id);
+    }
+  },
+  selectAlbumById(context, id) {
+    let album = context.getters.collection.find(item => item._id == id);
+    if (album) {
+      context.dispatch("selectAlbum", album);
+    }
+  },
+  gotoPrevAlbum(context) {
+    let prevAlbum = context.getters.prevAlbum;
+    if (prevAlbum._id) {
+      context.dispatch("selectAlbum", prevAlbum);
+    }
+  },
+  gotoNextAlbum(context) {
+    let nextAlbum = context.getters.nextAlbum;
+    if (nextAlbum._id) {
+      context.dispatch("selectAlbum", nextAlbum);
+    }
+  },
+  uploadNewCover(context, album) {
+    let input = document.createElement('input');
+    input.type = "file";
+    input.accept = "image/jpeg, image/png";
+    input.addEventListener("change", function () {
+      if (input.value) {
+        let formData = new FormData();
+        formData.append("file", input.files[0]);
+        let h = context.rootGetters.headers;
+        h.headers["content-type"] = "multipart/form-data";
+        axios
+          .put(context.rootGetters.server + "/api/albums/" + album._id + "/cover", formData, context.rootGetters.headers)
+          .then(res => {
+            album.covers = res.data;
+          });
+      }
+    });
+    input.click();
+  },
+  resetCover(context, album) {
+    axios.delete(context.rootGetters.server + "/api/albums/" + album._id + "/cover", context.rootGetters.headers).then(() => {
+      album.covers = {}
+    });
+  },
+  updateAlbum(context, album) {
+    let body = {
+      _id: album._id,
+      visibility: album.visibility
+    }
+    axios.put(context.rootGetters.server + "/api/albums/" + album._id, body, context.rootGetters.headers);
+  }
+}

src/store/modules/albums/getters.js

@@ -0,0 +1,36 @@
+export default {
+    collection(state) {
+        return state.collection;
+    },
+    favourites(state, getters, rootState, rootGetters) {
+        return state.collection.filter(f => rootGetters["user/favourites"].map(m => m.itemId).indexOf(f._id) > -1);
+    },
+    nextAlbum(state) {
+        let currentIndex = state.collection.indexOf(state.selectedAlbum);
+        let nextAlbum = {};
+        if (state.collection.length > currentIndex + 1) {
+            nextAlbum = state.collection[currentIndex + 1];
+        }
+        return nextAlbum;
+    },
+    prevAlbum(state) {
+        let currentIndex = state.collection.indexOf(state.selectedAlbum);
+        let prevAlbum = {};
+        if (currentIndex > 0) {
+            prevAlbum = state.collection[currentIndex - 1];
+        }
+        return prevAlbum;
+    },
+    selectedAlbum(state) {
+        return state.selectedAlbum;
+    },
+    loading(state) {
+        return state.loading;
+    },
+    eos(state) {
+        return state.eos;
+    },
+    newest(state) {
+        return state.newest;
+    }
+}

src/store/modules/albums/index.js

@@ -0,0 +1,12 @@
+import state from './state.js';
+import getters from './getters.js';
+import mutations from './mutations.js';
+import actions from './actions.js';
+
+export default {
+    namespaced: true,
+    state,
+    getters,
+    mutations,
+    actions
+}

src/store/modules/albums/mutations.js

@@ -0,0 +1,79 @@
+export default {
+  clear(state) {
+    state.collection = [];
+    state.newest = [];
+    state.loading = false;
+    state.eos = false;
+    state.page = 1;
+  },
+  remove(state, id) {
+    let album = state.collection.find(f => f._id == id);
+    if (album) {
+      let i = state.collection.indexOf(album);
+      state.collection.splice(i, 1);
+    }
+  },
+  resetSelectedAlbum(state) {
+    if (state.selectedAlbum._id)
+      state.selectedAlbum = { tracks: [], covers: {} };
+  },
+  selectAlbum(state, album) {
+    if (state.selectedAlbum._id != album._id) {
+      state.selectedAlbum = album;
+    }
+  },
+  setAlbums(state, albums) {
+    if (albums.length == 0) {
+      state.eos = true;
+      state.loading = false;
+      if (state.page > 1) {
+        state.page--;
+      }
+      return;
+    }
+    albums.forEach(album => {
+      let existsAlbum = state.collection.find(f => f._id == album._id);
+      if (!existsAlbum) {
+        let item = state.collection.find((item) => {
+          if (item.artist_name > album.artist_name
+            || item.artist_name == album.artist_name && item.year > album.year
+            || item.artist_name == album.artist_name && item.year == album.year && item.title > album.title) {
+            return item;
+          }
+        })
+
+        if (!album.covers) {
+          album.covers = {};
+        }
+
+        if (item) {
+          let index = state.collection.indexOf(item);
+          state.collection.splice(index, 0, album);
+        } else {
+          state.collection.push(album);
+        }
+        album.tracks.forEach((track) => {
+          track.parent = album;
+          track.parentType = "album"
+        });
+
+      } else if (existsAlbum && album.tracks.length > 0) {
+        existsAlbum.covers = album.covers || {};
+        existsAlbum.tracks = album.tracks;
+        existsAlbum.tracks.forEach((track) => {
+          track.parent = existsAlbum;
+          track.parentType = "album"
+        });
+      }
+    });
+    state.loading = false;
+  },
+  setNewest(state, albums) {
+    albums.forEach(album => {
+      if (!album.covers) {
+        album.covers = {};
+      }
+    });
+    state.newest = albums;
+  }
+}

src/store/modules/albums/state.js

@@ -0,0 +1,8 @@
+export default {
+    collection: [],
+    newest: [],
+    selectedAlbum: { tracks: [], covers: {} },
+    page: 1,
+    loading: false,
+    eos: false
+}