Refresh

resources/js/store/modules/feeditems/actions.js

@@ -0,0 +1,228 @@
+import { collect } from "collect.js";
+
+/**
+ * Feed items actions
+ */
+export default {
+    /**
+     * Load feed items for specified feeds
+     */
+    async index({ getters, commit }, documents) {
+        const feeds = collect(documents)
+            .pluck("feeds")
+            .flatten(1)
+            .pluck("id")
+            .all();
+
+        let nextPage = 0;
+        let feedItems = [];
+        const currentlySelectedItem = getters.selectedFeedItem;
+
+        if (feeds.length > 0) {
+            const data = await api.get(route("feed_item.index"), {
+                feeds: feeds,
+            });
+
+            feedItems = data.data;
+            nextPage = data.next_page_url !== null ? data.current_page + 1 : 0;
+        }
+
+        if (currentlySelectedItem) {
+            const itemFeeds = collect(currentlySelectedItem.feeds)
+                .pluck("id")
+                .flatten(1);
+
+            if (itemFeeds.intersect(feeds)) {
+                let collection = collect(feedItems);
+
+                if (!collection.where("id", currentlySelectedItem.id).first()) {
+                    feedItems.push(currentlySelectedItem);
+                }
+            }
+        }
+
+        commit("setNextPage", nextPage);
+        commit("setFeeds", feeds);
+        commit("setFeedItems", feedItems);
+    },
+
+    /**
+     * Infinite loading
+     */
+    async loadMoreFeedItems({ getters, commit }) {
+        if (!getters.nextPage || !getters.feeds) {
+            return;
+        }
+
+        const items = getters.feedItems;
+        const data = await api.get(route("feed_item.index"), {
+            page: getters.nextPage,
+            feeds: getters.feeds,
+        });
+
+        const newItems = [...items, ...data.data];
+
+        commit(
+            "setNextPage",
+            data.next_page_url !== null ? data.current_page + 1 : 0
+        );
+
+        commit("setFeeds", getters.feeds);
+        commit("setFeedItems", newItems);
+    },
+
+    /**
+     * Change selected feed items
+     */
+    async selectFeedItems({ commit }, feedItems) {
+        if (feedItems.length === 1) {
+            const data = await api.get(route("feed_item.show", feedItems[0]));
+            commit("update", { feedItem: feedItems[0], newProperties: data });
+        }
+
+        commit("setSelectedFeedItems", feedItems);
+    },
+
+    /**
+     * Select first unread item in current list
+     */
+    selectFirstUnreadFeedItem({ getters, dispatch }, exclude) {
+        if (!exclude) {
+            exclude = [];
+        }
+
+        const nextFeedItem = collect(getters.feedItems)
+            .where("feed_item_states_count", ">", 0)
+            .whereNotIn("id", exclude)
+            .first();
+
+        if (nextFeedItem) {
+            dispatch("selectFeedItems", [nextFeedItem]);
+        } else {
+            dispatch(
+                "documents/selectFirstDocumentWithUnreadItems",
+                { selectFirstUnread: true },
+                {
+                    root: true,
+                }
+            );
+        }
+    },
+
+    selectNextUnreadFeedItem({ getters, dispatch }, currentId) {
+        if (!currentId) {
+            return dispatch("selectFirstUnreadFeedItem");
+        }
+
+        const nextFeedItem = collect(getters.feedItems)
+            .where("feed_item_states_count", ">", 0)
+            .skipUntil((item) => item.id === currentId)
+            .skip(1)
+            .shift();
+
+        if (nextFeedItem) {
+            dispatch("selectFeedItems", [nextFeedItem]);
+        } else {
+            dispatch(
+                "documents/selectFirstDocumentWithUnreadItems",
+                { selectFirstUnread: true },
+                {
+                    root: true,
+                }
+            );
+        }
+    },
+
+    /**
+     * Mark feed items as read
+     */
+    markAsRead({ dispatch, commit, getters }, data) {
+        const nextPage = getters.nextPage;
+
+        // Avoid unwanted reloading
+        commit("setNextPage", null);
+
+        if ("feed_items" in data) {
+            dispatch("selectNextUnreadFeedItem", data.feed_items[0]);
+        } else if ("documents" in data) {
+            dispatch(
+                "documents/selectFirstDocumentWithUnreadItems",
+                { exclude: data.documents },
+                { root: true }
+            );
+        }
+
+        api.post(route("feed_item.mark_as_read"), data).then(function (
+            response
+        ) {
+            dispatch("updateUnreadFeedItemsCount", response);
+            commit("setNextPage", nextPage);
+        });
+    },
+
+    /**
+     * Change number of unread feed items everywhere it's necessary
+     */
+    updateUnreadFeedItemsCount({ commit, dispatch, getters }, data) {
+        if ("updated_feed_items" in data && data.updated_feed_items !== null) {
+            const feedItems = collect(getters.feedItems).whereIn(
+                "id",
+                data.updated_feed_items
+            );
+
+            feedItems.each(function (feedItem) {
+                commit("update", {
+                    feedItem: feedItem,
+                    newProperties: {
+                        feed_item_states_count: 0,
+                    },
+                });
+            });
+        }
+
+        if ("documents" in data) {
+            for (var documentId in data.documents) {
+                dispatch(
+                    "documents/update",
+                    {
+                        documentId: documentId,
+                        newProperties: {
+                            feed_item_states_count: data.documents[documentId],
+                        },
+                    },
+                    { root: true }
+                );
+            }
+        }
+
+        if ("folders" in data) {
+            for (var folderId in data.folders) {
+                dispatch(
+                    "folders/updateProperties",
+                    {
+                        folderId: folderId,
+                        newProperties: {
+                            feed_item_states_count: data.folders[folderId],
+                        },
+                    },
+                    { root: true }
+                );
+            }
+        }
+
+        if ("groups" in data) {
+            for (var groupId in data.groups) {
+                dispatch(
+                    "groups/updateProperties",
+                    {
+                        groupId: groupId,
+                        newProperties: {
+                            feed_item_states_count: data.groups[groupId],
+                        },
+                    },
+                    { root: true }
+                );
+            }
+        }
+    },
+};

resources/js/store/modules/feeditems/getters.js

@@ -0,0 +1,48 @@
+export default {
+    /**
+     * Feed items present in current selection (folder, document, feed)
+     */
+    feedItems: state => {
+        return state.feedItems;
+    },
+    /**
+     * Return first feed item in current list
+     */
+    feedItem: state => {
+        return collect(state.feedItems).first();
+    },
+    /**
+     * Return currently selected feed items
+     */
+    selectedFeedItems: state => {
+        if(!state.selectedFeedItems) {
+            return [];
+        }
+
+        return state.selectedFeedItems;
+    },
+    /**
+     * Return the first selected feed item
+     */
+    selectedFeedItem: state => {
+        return collect(state.selectedFeedItems).first();
+    },
+    /**
+     * Return next page #
+     */
+    nextPage: state => {
+        return state.nextPage;
+    },
+    /**
+     * Return feeds associated with current feed items
+     */
+    feeds: state => {
+        return state.feeds;
+    },
+    /**
+     * Return a boolean value indicating if we can load more feed items
+     */
+    canLoadMore: state => {
+        return state.nextPage > 1;
+    }
+};

resources/js/store/modules/feeditems/index.js

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

resources/js/store/modules/feeditems/mutations.js

@@ -0,0 +1,52 @@
+export default {
+    /**
+     * Set feed items list
+     * @param {*} state
+     * @param {*} feedItems
+     */
+    setFeedItems(state, feedItems) {
+        state.feedItems = feedItems;
+    },
+
+    /**
+     * Set next page #
+     * @param {*} state
+     * @param {*} page
+     */
+    setNextPage(state, page) {
+        state.nextPage = page;
+    },
+
+    /**
+     * Set feeds associated to current feed items
+     * @param {*} state
+     * @param {*} feeds
+     */
+    setFeeds(state, feeds) {
+        state.feeds = feeds;
+    },
+
+    /**
+     * Set selected feed items
+     * @param {*} state
+     * @param {*} feedItems
+     */
+    setSelectedFeedItems(state, feedItems) {
+        if(!feedItems) {
+            feedItems = [];
+        }
+
+        state.selectedFeedItems = feedItems;
+    },
+
+    /**
+     * Update feed item's properties
+     * @param {*} state
+     * @param {*} param1
+     */
+    update(state, {feedItem, newProperties}) {
+        for(var property in newProperties) {
+            feedItem[property] = newProperties[property];
+        }
+    },
+};

resources/js/store/modules/feeditems/state.js

@@ -0,0 +1,18 @@
+export default {
+    /**
+     * Feed items present in current selection (folder, document, feed)
+     */
+    feedItems: [],
+    /**
+     * Next page #
+     */
+    nextPage: 0,
+    /**
+     * Feeds associated with current feed items
+     */
+    feeds: [],
+    /**
+     * Selected feed items
+     */
+    selectedFeedItems: [],
+};