feat(mapUi): Create mapUi specific service

server/boot/a-services.js

@@ -1,12 +1,15 @@
 import Fetchr from 'fetchr';
 import getUserServices from '../services/user';
 import getMapServices from '../services/map';
+import getMapUiServices from '../services/mapUi';
 
 export default function bootServices(app) {
   const userServices = getUserServices(app);
   const mapServices = getMapServices(app);
+  const mapUiServices = getMapUiServices(app);
 
   Fetchr.registerFetcher(userServices);
   Fetchr.registerFetcher(mapServices);
+  Fetchr.registerFetcher(mapUiServices);
   app.use('/services', Fetchr.middleware());
 }

server/services/mapUi.js

@@ -0,0 +1,56 @@
+import debug from 'debug';
+import { Observable } from 'rx';
+
+import { cachedMap, getMapForLang } from '../utils/map';
+
+const log = debug('fcc:services:mapUi');
+
+export default function mapUiService(app) {
+  const challengeMap = cachedMap(app.models);
+  return {
+    name: 'map-ui',
+    read: function readMapUi(req, resource, { lang = 'en' } = {}, config, cb) {
+      log(`generating mapUi for ${lang}`);
+      return challengeMap.map(getMapForLang(lang))
+        .flatMap(({
+          result: { superBlocks },
+          entities: {
+            superBlock: fullSuperBlockMap,
+            block: fullBlockMap,
+            challenge: fullChallengeMap
+          }
+        }) => {
+          const superBlockMap = superBlocks
+            .map(superBlock => fullSuperBlockMap[superBlock])
+            .reduce((map, { dashedName, blocks, title }) => {
+              map[dashedName] = { blocks, title, dashedName};
+              return map;
+            }, {});
+          const blockMap = Object.keys(fullBlockMap)
+            .map(block => fullBlockMap[block])
+            .reduce((map, { dashedName, title, time, challenges }) => {
+              map[dashedName] = { dashedName, title, time, challenges };
+              return map;
+            }, {});
+          const challengeMap = Object.keys(fullChallengeMap)
+            .map(challenge => fullChallengeMap[challenge])
+            .reduce((map, { dashedName, name, id}) => {
+              map[dashedName] = {name, dashedName, id};
+              return map;
+            }, {});
+
+          return Observable.of({
+            result: { superBlocks },
+            entities: {
+              superBlock: superBlockMap,
+              block: blockMap,
+              challenge: challengeMap
+            }
+          });
+        }).subscribe(
+          mapUi => cb(null, mapUi ),
+          err => { log(err); return cb(err); }
+        );
+    }
+  };
+}

server/utils/map.js

@@ -74,43 +74,43 @@ export function _cachedMap({ Block, Challenge }) {
       }, blocksMap);
     });
   const superBlockMap = blocks.map(blocks => blocks.reduce((map, block) => {
-    if (
-      map[block.superBlock] &&
-      map[block.superBlock].blocks
-    ) {
-      map[block.superBlock].blocks.push(block.dashedName);
-    } else {
-      map[block.superBlock] = {
-        title: _.startCase(block.superBlock),
-        order: block.superOrder,
-        name: nameify(_.startCase(block.superBlock)),
-        dashedName: block.superBlock,
-        blocks: [block.dashedName],
-        message: block.superBlockMessage
-      };
-    }
-    return map;
-  }, {}));
-  const superBlocks = superBlockMap.map(superBlockMap => {
-    return Object.keys(superBlockMap)
-      .map(key => superBlockMap[key])
-      .map(({ dashedName }) => dashedName);
-  });
-  return Observable.combineLatest(
-    superBlockMap,
-    blockMap,
-    challengeMap,
-    superBlocks,
-    (superBlock, block, challenge, superBlocks) => ({
-      entities: {
-        superBlock,
-        block,
-        challenge
-      },
-      result: {
-        superBlocks
-      }
-    })
+        if (
+          map[block.superBlock] &&
+          map[block.superBlock].blocks
+        ) {
+          map[block.superBlock].blocks.push(block.dashedName);
+        } else {
+          map[block.superBlock] = {
+            title: _.startCase(block.superBlock),
+            order: block.superOrder,
+            name: nameify(_.startCase(block.superBlock)),
+            dashedName: block.superBlock,
+            blocks: [block.dashedName],
+            message: block.superBlockMessage
+          };
+        }
+        return map;
+      }, {}));
+      const superBlocks = superBlockMap.map(superBlockMap => {
+        return Object.keys(superBlockMap)
+          .map(key => superBlockMap[key])
+          .map(({ dashedName }) => dashedName);
+      });
+      return Observable.combineLatest(
+        superBlockMap,
+        blockMap,
+        challengeMap,
+        superBlocks,
+        (superBlock, block, challenge, superBlocks) => ({
+          entities: {
+            superBlock,
+            block,
+            challenge
+          },
+          result: {
+            superBlocks
+          }
+        })
   )
     .do(checkMapData)
     .shareReplay();