chore(server): Move api-server in to it's own DIR

api-server/server/utils/map.js

@@ -0,0 +1,241 @@
+import _ from 'lodash';
+import { Observable } from 'rx';
+
+import { unDasherize, nameify } from '../utils';
+import {
+  addNameIdMap as _addNameIdToMap,
+  checkMapData,
+  getFirstChallenge as _getFirstChallenge
+} from '../../common/utils/map.js';
+
+const isDev = process.env.NODE_ENV !== 'production';
+const isBeta = !!process.env.BETA;
+const challengesRegex = /^(bonfire|waypoint|zipline|basejump|checkpoint)/i;
+const addNameIdMap = _.once(_addNameIdToMap);
+const getFirstChallenge = _.once(_getFirstChallenge);
+/*
+ * interface ChallengeMap {
+ *   result: {
+ *     superBlocks: [ ...superBlockDashedName: String ]
+*    },
+ *   entities: {
+ *     superBlock: {
+ *       [ ...superBlockDashedName ]: SuperBlock
+ *     },
+ *     block: {
+ *       [ ...blockDashedNameg ]: Block,
+ *     challenge: {
+ *       [ ...challengeDashedNameg ]: Challenge
+ *     }
+ *   }
+ * }
+ */
+export function _cachedMap({ Block, Challenge }) {
+  const challenges = Challenge.find$({
+    order: [ 'order ASC', 'suborder ASC' ],
+    where: { isPrivate: false }
+  });
+  const challengeMap = challenges
+    .map(
+      challenges => challenges
+        .map(challenge => challenge.toJSON())
+        .reduce((hash, challenge) => {
+          hash[challenge.dashedName] = challenge;
+          return hash;
+        }, {})
+    );
+  const blocks = Block.find$({
+    order: [ 'superOrder ASC', 'order ASC' ],
+    where: { isPrivate: false }
+  });
+  const blockMap = Observable.combineLatest(
+    blocks.map(
+      blocks => blocks
+        .map(block => block.toJSON())
+        .reduce((hash, block) => {
+          hash[block.dashedName] = block;
+          return hash;
+        }, {})
+    ),
+    challenges
+  )
+    .map(([ blocksMap, challenges ]) => {
+      return challenges.reduce((blocksMap, challenge) => {
+        if (blocksMap[challenge.block].challenges) {
+          blocksMap[challenge.block].challenges.push(challenge.dashedName);
+        } else {
+          blocksMap[challenge.block] = {
+            ...blocksMap[challenge.block],
+            challenges: [ challenge.dashedName ]
+          };
+        }
+        return blocksMap;
+      }, 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
+      }
+    })
+  )
+    .do(checkMapData)
+    .shareReplay();
+}
+
+export const cachedMap = _.once(_cachedMap);
+
+// type ObjectId: String;
+// getChallengeById(
+//   map: Observable[map],
+//   id: ObjectId
+// ) => Observable[Challenge] | Void;
+export function getChallengeById(map, id) {
+  return Observable.if(
+    () => !id,
+    map.map(getFirstChallenge),
+    map.map(addNameIdMap)
+      .map(map => {
+        const {
+          entities: { challenge: challengeMap, challengeIdToName }
+        } = map;
+        let finalChallenge;
+        const dashedName = challengeIdToName[id];
+        finalChallenge = challengeMap[dashedName];
+        if (!finalChallenge) {
+          finalChallenge = getFirstChallenge(map);
+        }
+        return finalChallenge;
+      })
+  );
+}
+
+export function getChallengeInfo(map) {
+  return map.map(addNameIdMap)
+    .map(({
+      entities: {
+        challenge: challengeMap,
+        challengeIdToName
+      }
+    }) => ({
+      challengeMap,
+      challengeIdToName
+    }));
+}
+
+// if challenge is not isComingSoon or isBeta => load
+// if challenge is ComingSoon we are in beta||dev => load
+// if challenge is beta and we are in beta||dev => load
+// else hide
+function loadComingSoonOrBetaChallenge({
+  isComingSoon,
+  isBeta: challengeIsBeta
+}) {
+  return !(isComingSoon || challengeIsBeta) || isDev || isBeta;
+}
+
+// this is a hard search
+// falls back to soft search
+export function getChallenge(
+  challengeDashedName,
+  blockDashedName,
+  map) {
+  return map
+    .flatMap(({ entities, result: { superBlocks } }) => {
+      const superBlock = entities.superBlock;
+      const block = entities.block[blockDashedName];
+      const challenge = entities.challenge[challengeDashedName];
+      return Observable.if(
+        () => (
+          !blockDashedName ||
+          !block ||
+          !challenge ||
+          !loadComingSoonOrBetaChallenge(challenge)
+        ),
+        getChallengeByDashedName(challengeDashedName, map),
+        Observable.just({ block, challenge })
+      )
+        .map(({ challenge, block }) => ({
+          redirect: challenge.block !== blockDashedName ?
+            `/challenges/${block.dashedName}/${challenge.dashedName}` :
+            false,
+          entities: {
+            superBlock,
+            challenge: {
+              [challenge.dashedName]: challenge
+            }
+          },
+          result: {
+            block: block.dashedName,
+            challenge: challenge.dashedName,
+            superBlocks
+          }
+        }));
+    });
+}
+
+export function getBlockForChallenge(map, challenge) {
+  return map.map(({ entities: { block } }) => block[challenge.block]);
+}
+
+export function getChallengeByDashedName(dashedName, map) {
+  const challengeName = unDasherize(dashedName)
+    .replace(challengesRegex, '');
+  const testChallengeName = new RegExp(challengeName, 'i');
+
+  return map
+    .map(({ entities }) => entities.challenge)
+    .flatMap(challengeMap => {
+      return Observable.from(Object.keys(challengeMap))
+        .map(key => challengeMap[key]);
+    })
+    .filter(challenge => {
+      return loadComingSoonOrBetaChallenge(challenge) &&
+        testChallengeName.test(challenge.name);
+    })
+    .last({ defaultValue: null })
+    .flatMap(challengeOrNull => {
+      return Observable.if(
+        () => !!challengeOrNull,
+        Observable.just(challengeOrNull),
+        map.map(getFirstChallenge)
+      );
+    })
+    .flatMap(challenge => {
+      return getBlockForChallenge(map, challenge)
+        .map(block => ({ challenge, block }));
+    });
+}
+