Swik 1440 improve slide links in notifications

components/Deck/ActivityFeedPanel/ActivityItem.js

@@ -7,6 +7,7 @@ import {connectToStores} from 'fluxible-addons-react';
 import cheerio from 'cheerio';
 import DeckTreeStore from '../../../stores/DeckTreeStore';
 import Util from '../../common/Util';
+import {getLanguageName} from '../../../common'; 
 
 class ActivityItem extends React.Component {
     handleLike() {
@@ -70,7 +71,7 @@ class ActivityItem extends React.Component {
                             {node.author ? node.author.displayName || node.author.username : 'unknown'}
                         </a> {'translated '} {nodeRef} {' to '}
                         {/*<a href={'/slideview/' + node.translation_info.content_id}>{node.translation_info.language}</a>*/}
-                        <a href={viewPath}>{node.translation_info.language}</a>
+                        {getLanguageName(node.translation_info.language)}
                         <br/>
                         {DateDiv}
                     </div>

components/Deck/ActivityFeedPanel/util/ActivityFeedUtil.js

@@ -67,6 +67,8 @@ class ActivityFeedUtil {
         let msPerYear = msPerDay * 365;
 
         let elapsed = nowTime - thenTime;
+        if (elapsed < 0)
+            elapsed = 0;
 
         if (elapsed < msPerMinute) {
             return Math.round(elapsed/1000) + ' seconds ago';

components/User/UserNotificationsPanel/UserNotificationsItem.js

@@ -2,10 +2,12 @@ import PropTypes from 'prop-types';
 import React from 'react';
 import {formatDate} from '../../Deck/ActivityFeedPanel/util/ActivityFeedUtil';
 import {List, Icon, Button} from 'semantic-ui-react';
+import { isEmpty } from '../../../common.js';
 import classNames from 'classnames/bind';
 import cheerio from 'cheerio';
 import readUserNotification from '../../../actions/user/notifications/readUserNotification';
 import deleteUserNotification from '../../../actions/user/notifications/deleteUserNotification';
+import {getLanguageName} from '../../../common'; 
 
 class UserNotificationsItem extends React.Component {
     handleMarkAsRead(notification) {
@@ -41,7 +43,15 @@ class UserNotificationsItem extends React.Component {
             notification.user_id = undefined;
         }
 
-        let viewPath = ((notification.content_kind === 'slide') ? '/slideview/' : '/deck/') + notification.content_id;
+        let viewPath = '';
+        if (!isEmpty(notification.content_root_id) && !isEmpty(notification.path)) {
+            viewPath = notification.path;
+        } else if (notification.content_kind === 'deck') {
+            viewPath = '/deck/' + notification.content_id;
+        } else {
+            viewPath = '/slideview/' + notification.content_id;
+        }
+
         const cheerioContentName = (notification.content_name !== undefined) ? cheerio.load(notification.content_name).text() : '';
         if (notification.content_kind === 'group')
             viewPath = '/user/' + this.props.username + '/groups/overview';
@@ -55,7 +65,7 @@ class UserNotificationsItem extends React.Component {
                         </a> {'translated ' + notification.content_kind + ' '}
                         <a href={viewPath}>{cheerioContentName}</a>{' to '}
                         {/*<a href={'/slideview/' + notification.translation_info.content_id}>{notification.translation_info.language}</a>*/}
-                        <a href={viewPath}>{notification.translation_info.language}</a>
+                        {getLanguageName(notification.translation_info.language)}
                     </div>
                 );
                 break;

services/notifications.js

@@ -1,5 +1,6 @@
 import {Microservices} from '../configs/microservices';
 import rp from 'request-promise';
+import Util from '../components/common/Util';
 const log = require('../configs/log').log;
 
 export default {
@@ -15,10 +16,40 @@ export default {
         }
 
         if (resource === 'notifications.list'){
-
             rp.get({uri: Microservices.notification.uri + '/notifications/' + uid + '?metaonly=false'}).then((res) => {
                 let notifications = JSON.parse(res).items;
-                callback(null, {notifications: notifications});
+
+                //create path for slides and subdecks- GET DECK DATA for content_root_id FROM DECK SERVICE
+                let deckTreePromises = [];
+                for(let notification of notifications){
+                    if (notification.content_root_id && notification.content_id.split('-')[0] !== notification.content_root_id.split('-')[0]) {
+                        deckTreePromises.push(
+                            rp.get({
+                                uri: `${Microservices.deck.uri}/decktree/${notification.content_root_id}`,
+                                json: true
+                            })
+                        );
+                    }
+                }
+
+                Promise.all(deckTreePromises).then( (data) => {
+                    let deckTrees = data;
+                    for (let i = 0; i < deckTrees.length; i++) {
+                        let deckTree = makePathForTree(deckTrees[i], []);
+                        let deckId = deckTree.id;
+                        let flatTree = flattenTree(deckTree);
+                        for (let j = 0; j < notifications.length; j++) {
+                            if (notifications[j].content_root_id && notifications[j].content_root_id.split('-')[0] === deckId.split('-')[0]) {
+                                notifications[j].path = getPath(notifications[j].content_id, notifications[j].content_kind, deckId, flatTree);
+                            }
+                        }
+                    }
+
+                    callback(null, {notifications: notifications});
+                }).catch( (err) => {
+                    console.log(err);
+                    callback(null, {notifications: []});
+                });
             }).catch((err) => {
                 console.log(err);
                 callback(null, {notifications: []});
@@ -116,3 +147,80 @@ export default {
     // create: (req, resource, params, body, config, callback) => {},
 
 };
+
+//return the position of the node in the deck
+function getPath(sid, type, deckId, flatTree){
+    let path = '';
+    for (let i = 0; i < flatTree.length; i++) {
+        if (flatTree[i].type === type && flatTree[i].id === sid) {
+            path = flatTree[i].path;
+            let nodeSelector = {id: deckId, stype: type, sid: sid, spath: path};
+            let nodeURL = Util.makeNodeURL(nodeSelector, 'deck', 'view', undefined, undefined, true);
+
+            return nodeURL;
+        }
+    }
+    return path;
+}
+
+//flat tree is used to avoid complex recursive functions on tree
+//it is a trade off: updating the tree needs this to be synchronized
+//this also propagates themes from decks to slide children
+function flattenTree(deckTree, theme) {
+    if (!theme) theme = deckTree.theme;
+
+    let list = [];
+    list.push({
+        id: deckTree.id,
+        title: deckTree.title,
+        type: deckTree.type,
+        path: deckTree.path,
+        language: deckTree.language,
+        theme: theme
+    });
+
+    if (deckTree.type === 'deck') {
+        deckTree.children.forEach((item) => {
+            let theme = item.theme;
+            if (item.type === 'slide') theme = deckTree.theme;
+
+            list = list.concat(flattenTree(item, theme));
+        });
+    }
+    return list;
+}
+
+//deckTree: original deckTree from service without path
+//path: array of binary id:position
+function makePathForTree(deckTree, path) {
+    let nodePath = makeSelectorPathString(path);
+    let newTree = {
+        id: deckTree.id,
+        title: deckTree.title,
+        type: deckTree.type,
+        path: nodePath,
+        theme: deckTree.theme,
+        language: deckTree.language,
+        selected: false,
+        editable: false,
+        onAction: 0
+    };
+    if (deckTree.type === 'deck') {
+        newTree.children = [];
+        newTree.expanded = true;
+        deckTree.children.forEach((item, index) => {
+            newTree.children.push(makePathForTree(item, path.concat([[item.id, index + 1]])) );
+        });
+    }
+    return newTree;
+}
+
+//parses the nodePath and builds a selector path for navigation
+function makeSelectorPathString(nodePath) {
+    let out = [], slectorPath = '';
+    nodePath.forEach((element) => {
+        out.push(element.join(':'));
+    });
+    slectorPath = out.join(';');
+    return slectorPath;
+}