Merge branch 'master' into SWIK-1848_tag_recommendation

actions/collections/addNewCollection.js

@@ -0,0 +1,21 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+import UserProfileStore from '../../stores/UserProfileStore';
+
+export default function addNewCollection(context, payload, done) {
+    log.info(context);
+
+    // enrich payload with jwt
+    payload.jwt = context.getStore(UserProfileStore).jwt;
+
+    context.service.create('deckgroups.create', payload, {timeout: 20 * 1000}, (err, res) => {
+        if (err) {
+            log.error(context, {filepath: __filename});
+            context.dispatch('ADD_COLLECTION_FAILURE', err);
+        } else {
+            context.dispatch('ADD_COLLECTION_SUCCESS', res);
+        }
+
+        done();
+    });
+}

actions/collections/addSelectedCollection.js

@@ -0,0 +1,8 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+
+export default function addSelectedCollection(context, payload, done) {
+    log.info(context);
+    context.dispatch('ADD_SELECTED_COLLECTION', payload);
+    done();
+}

actions/collections/deleteCollection.js

@@ -0,0 +1,21 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+import UserProfileStore from '../../stores/UserProfileStore';
+
+export default function deleteCollection(context, payload, done) {
+    log.info(context);
+
+    // enrich payload with jwt
+    payload.jwt = context.getStore(UserProfileStore).jwt;
+
+    context.dispatch('SET_COLLECTIONS_LOADING'); // show loading indicator
+
+    context.service.delete('deckgroups.item', payload, {timeout: 20 * 1000}, (err, res) => {
+        if (err) {
+            log.error(context, {filepath: __filename});
+            context.dispatch('DELETE_COLLECTION_FAILURE', err);
+            return;
+        }
+        context.dispatch('DELETE_COLLECTION_SUCCESS', {id: payload.id});
+    });
+}

actions/collections/loadCollection.js

@@ -0,0 +1,35 @@
+import async from 'async';
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+import notFoundError from '../error/notFoundError';
+import loadCollectionDetails from './loadCollectionDetails';
+import fetchUser from '../../actions/user/userprofile/fetchUser';
+import UserProfileStore from '../../stores/UserProfileStore';
+
+// loads deck collection details and user info
+export default function loadCollection(context, payload, done) {
+    log.info(context);
+
+    // load required actions in parallel
+    async.parallel([
+        (callback) => {
+            context.executeAction(fetchUser, {
+                params: {
+                    username: context.getStore(UserProfileStore).getState().username
+                }
+            }, callback);
+        },
+        (callback) => {
+            context.executeAction(loadCollectionDetails, payload, callback);
+        }
+    ], (err, results) => {
+        if (err) {
+            log.error(context, {filepath: __filename});
+            context.executeAction(serviceUnavailable, payload, done);
+            return;
+        }
+
+        done();
+    });
+
+}

actions/collections/loadCollectionDetails.js

@@ -0,0 +1,26 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+import notFoundError from '../error/notFoundError';
+
+// loads a deck collection
+export default function loadCollectionDetails(context, payload, done) {
+    log.info(context);
+
+    context.dispatch('SET_COLLECTIONS_LOADING'); // show loading indicator
+
+    context.service.read('deckgroups.get', payload, {timeout: 20 * 1000}, (err, res) => {
+        if (err) {
+            if(err.statusCode === 404){
+                context.executeAction(notFoundError, {}, done);
+                return;
+            }
+            log.error(context, {filepath: __filename});
+            context.dispatch('LOAD_COLLECTION_DETAILS_FAILURE', err);
+        } else {
+            res.sortBy = (payload.query.sort) ? payload.query.sort : 'order';
+            context.dispatch('LOAD_COLLECTION_DETAILS_SUCCESS', res);
+        }
+
+        done();
+    });
+}

actions/collections/loadDeckCollections.js

@@ -0,0 +1,43 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+import UserProfileStore from '../../stores/UserProfileStore';
+
+// loads deck groups assigned by the current user to a deck
+export default function loadDeckCollections(context, payload, done) {
+    log.info(context);
+
+    // enrich payload with user id
+    if(payload.params){
+        payload.params.userId = context.getStore(UserProfileStore).userid;
+        payload.params.jwt = context.getStore(UserProfileStore).jwt;
+    } else {
+        payload.userId = context.getStore(UserProfileStore).userid;
+        payload.jwt = context.getStore(UserProfileStore).jwt;
+    }
+
+    context.dispatch('UPDATE_COLLECTIONS_LOADING', true);
+
+    // first get user groups that the user is member of 
+    context.service.read('usergroup.member', payload, {timeout: 20 * 1000}, (err, usergroups) => {
+        if(err){
+            log.error(context, {filepath: __filename});
+            done();
+        } else {
+
+            // then get deck collection options
+            payload.usergroups = usergroups;
+            context.service.read('deckgroups.forDeck', payload, {timeout: 20 * 1000}, (err, res) => {
+                if (err) {
+                    log.error(context, {filepath: __filename});
+                    context.dispatch('LOAD_COLLECTIONS_FAILURE', err);
+                } else {
+                    context.dispatch('LOAD_COLLECTIONS_SUCCESS', res);
+                }
+
+                context.dispatch('UPDATE_COLLECTIONS_LOADING', false);
+
+                done();
+            });
+        }
+    }); 
+}

actions/collections/loadUserCollections.js

@@ -0,0 +1,65 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+import UserProfileStore from '../../stores/UserProfileStore';
+
+// loads deck collections created by the current user or his user groups
+export default function loadUserCollections(context, payload, done) {
+    log.info(context);
+
+    context.dispatch('SET_COLLECTIONS_LOADING'); // show loading indicator
+
+    // request deck collections for the loggedin user
+    if(context.getStore(UserProfileStore).userid === context.getStore(UserProfileStore).user.id){
+
+        // enrich payload with user id and authToken
+        if(payload.params){
+            payload.params.userId = context.getStore(UserProfileStore).userid;
+            payload.params.jwt = context.getStore(UserProfileStore).jwt;
+        } else {
+            payload.userId = context.getStore(UserProfileStore).userid;
+            payload.jwt = context.getStore(UserProfileStore).jwt;
+        }
+
+        // first get user groups that the user is member of 
+        context.service.read('usergroup.member', payload, {timeout: 20 * 1000}, (err, usergroups) => {
+            if(err){
+                log.error(context, {filepath: __filename});
+                done();
+            } else {
+
+                // then get deck collection corresponding to the loggedin user and his user groups
+                payload.usergroups = usergroups;
+                context.service.read('deckgroups.forUser', payload, {timeout: 20 * 1000}, (err, res) => {
+                    if (err) {
+                        log.error(context, {filepath: __filename});
+                        context.dispatch('LOAD_USER_COLLECTIONS_FAILURE', err);
+                    } else {
+                        context.dispatch('LOAD_USER_COLLECTIONS_SUCCESS', res);
+                    }
+
+                    done();
+                });
+            }
+        }); 
+
+    // request deck collections for a user that is not the logged in one
+    } else {
+        if(payload.params){
+            payload.params.userId = context.getStore(UserProfileStore).user.id;
+        } else {
+            payload.userId = context.getStore(UserProfileStore).user.id;
+        }
+
+        // just get the deck collections for this user
+        context.service.read('deckgroups.forUser', payload, {timeout: 20 * 1000}, (err, res) => {
+            if (err) {
+                log.error(context, {filepath: __filename});
+                context.dispatch('LOAD_USER_COLLECTIONS_FAILURE', err);
+            } else {
+                context.dispatch('LOAD_USER_COLLECTIONS_SUCCESS', res);
+            }
+
+            done();
+        });
+    }    
+}

actions/collections/removeSelectedCollection.js

@@ -0,0 +1,8 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+
+export default function removeSelectedCollections(context, payload, done) {
+    log.info(context);
+    context.dispatch('REMOVE_SELECTED_COLLECTION', payload);
+    done();
+}

actions/collections/updateCollectionDeckOrder.js

@@ -0,0 +1,29 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+import UserProfileStore from '../../stores/UserProfileStore';
+import { navigateAction } from 'fluxible-router';
+
+export default function updateCollectionDeckOrder(context, payload, done) {
+    log.info(context);
+
+    // enrich payload with jwt
+    payload.jwt = context.getStore(UserProfileStore).jwt;
+
+    context.service.update('deckgroups.deckOrder', payload, {timeout: 20 * 1000}, (err, res) => {
+        if (err) {
+            log.error(context, {filepath: __filename});
+            context.dispatch('UPDATE_COLLECTION_DECK_ORDER_FAILURE', err);
+        } else {
+            context.dispatch('UPDATE_COLLECTION_DECK_ORDER_SUCCESS', res);
+
+            // redirect when new order has been saved
+            context.executeAction(navigateAction, {
+                url: `/collection/${payload.id}?sort=order`, 
+            });
+        }
+
+
+
+        done();
+    });
+}

actions/collections/updateCollectionDecks.js

@@ -0,0 +1,31 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+import UserProfileStore from '../../stores/UserProfileStore';
+
+export default function updateCollectionDecks(context, payload, done) {
+    log.info(context);
+
+    // enrich payload with jwt
+    payload.userId = context.getStore(UserProfileStore).userid;
+    payload.jwt = context.getStore(UserProfileStore).jwt;
+
+    // first get user groups that the user is member of 
+    context.service.read('usergroup.member', payload, {timeout: 20 * 1000}, (err, usergroups) => {
+        if(err){
+            log.error(context, {filepath: __filename});
+            done();
+        } else {
+
+            payload.usergroups = usergroups;
+            context.service.update('deckgroups.decks', payload, {timeout: 20 * 1000}, (err, res) => {
+                if (err) {
+                    console.log(err);
+                    log.error(context, {filepath: __filename});
+                    context.dispatch('UPDATE_DECKS_OF_DECK_GROUP_ERROR', err);
+                }
+
+                done();
+            });
+        }
+    });
+}

actions/collections/updateCollectionMetadata.js

@@ -0,0 +1,22 @@
+const log = require('../log/clog');
+import serviceUnavailable from '../error/serviceUnavailable';
+import UserProfileStore from '../../stores/UserProfileStore';
+
+export default function updateCollectionDecks(context, payload, done) {
+    log.info(context);
+
+    // enrich payload with jwt
+    payload.userId = context.getStore(UserProfileStore).userid;
+    payload.jwt = context.getStore(UserProfileStore).jwt;
+
+    context.service.update('deckgroups.metadata', payload, {timeout: 20 * 1000}, (err, res) => {
+        if (err) {
+            console.log(err);
+            log.error(context, {filepath: __filename});
+            context.dispatch('UPDATE_COLLECTION_METADATA_ERROR', err);
+        } else {
+            context.dispatch('UPDATE_COLLECTION_METADATA', res);
+        }
+        done();
+    });
+}

actions/loadDeckEdit.js

@@ -3,6 +3,8 @@ import slideIdTypeError from './error/slideIdTypeError';
 import { AllowedPattern } from './error/util/allowedPattern';
 import UserProfileStore from '../stores/UserProfileStore';
 import serviceUnavailable from './error/serviceUnavailable';
+import loadUserCollections from './collections/loadUserCollections';
+import loadDeckCollections from './collections/loadDeckCollections';
 const log = require('./log/clog');
 
 export default function loadDeckEdit(context, payload, done) {
@@ -14,7 +16,14 @@ export default function loadDeckEdit(context, payload, done) {
         return;
     }
 
+    // load deck collections of the current user
+    context.executeAction(loadUserCollections, payload, done);
+
+    // load deck groups assigned to the current deck
+    context.executeAction(loadDeckCollections, payload, done);
+
     payload.params.jwt = context.getStore(UserProfileStore).jwt;
+
     context.service.read('deck.properties', payload, {timeout: 20 * 1000}, (err, res) => {
         if (err) {
             log.error(context, {filepath: __filename});

actions/user/userprofile/chooseAction.js

@@ -3,11 +3,12 @@ import fetchUser from './fetchUser';
 import { fetchUserDecks } from './fetchUserDecks';
 import notFoundError from '../../error/notFoundError';
 const log = require('../../log/clog');
+import loadUserCollections from '../../collections/loadUserCollections'; 
 import { shortTitle } from '../../../configs/general';
 import UserProfileStore from '../../../stores/UserProfileStore';
 
 export const categories = { //Do NOT alter the order of these items! Just add your items. Used in UserProfile and CategoryBox components
-    categories: ['settings', 'groups'],
+    categories: ['settings', 'groups', 'collections'],
     settings: ['profile', 'account', 'integrations'],
     groups: ['overview', 'edit']
 };
@@ -66,6 +67,10 @@ export function chooseAction(context, payload, done) {
                     context.dispatch('USER_CATEGORY', {category: payload.params.category, item: payload.params.item});
                     callback();
                     break;
+                case categories.categories[2]:
+                    context.dispatch('USER_CATEGORY', {category: payload.params.category, item: payload.params.item});
+                    context.executeAction(loadUserCollections, {}, callback);
+                    break;
                 case undefined:
                     context.executeAction(fetchUserDecks, {params: {username: payload.params.username}}, callback);
                     break;

actions/user/userprofile/fetchUser.js

@@ -46,7 +46,8 @@ export default function fetchUser(context, payload, done) {
             }
         } else {
             if(!isEmpty(payload.params.category)){
-                if(context.getStore(UserProfileStore).username === payload.params.username)
+                if(context.getStore(UserProfileStore).username === payload.params.username 
+                    || payload.params.category === 'collections')  // allow route /{username}/collections
                     res.category = isEmpty(payload.params.category) ? '' : payload.params.category;
                 else{
                     context.executeAction(notFoundError, {}, done);