musora-content-services 1.0.118 → 1.0.120

package/docs/sanity.js.html

@@ -58,13 +58,17 @@ import {
     getFieldsForContentType,
     filtersToGroq,
     getUpcomingEventsTypes,
-    getNewReleasesTypes,
     showsTypes,
-    contentMetadata
+    getNewReleasesTypes,
 } from "../contentTypeConfig";
+
+import {
+    processMetadata,
+} from "../contentMetaData";
+
 import {globalConfig} from "./config";
 
-import { fetchAllCompletedStates, fetchCurrentSongComplete } from './railcontent.js';
+import { fetchUserPermissions, fetchAllCompletedStates, fetchCurrentSongComplete } from './railcontent.js';
 import {arrayToStringRepresentation, FilterBuilder} from "../filterBuilder";
 
 /**
@@ -264,8 +268,7 @@ export async function fetchSongFilterOptions(brand) {
       {"type": "Full Song Only", "count": count(*[_type == 'song' && brand == '${brand}' && instrumentless == false]._id)},
       {"type": "Instrument Removed", "count": count(*[_type == 'song' && brand == '${brand}' && instrumentless == true]._id)}
     ]
-  }
-`;
+  }`;
 
   return fetchSanity(query, true);
 }
@@ -543,58 +546,51 @@ export async function fetchAll(brand, type, {
 
     // Determine the group by clause
     let query = "";
+    let entityFieldsString = "";
+    let filter = "";
     if (groupBy !== "" && isGroupByOneToOne) {
-        let webUrlPath = 'artists';
-        query = `
-        {
-            "total": count(*[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id == ${groupBy}._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]),
-            "entity": *[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id == ${groupBy}._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]
-            {
+        const webUrlPath = 'artists';
+        const lessonsFilter = `_type == '${type}' && brand == '${brand}' && ^._id == ${groupBy}._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}`;
+        entityFieldsString = `
                 'id': _id,
                 'type': _type,
                 name,
                 'head_shot_picture_url': thumbnail_url.asset->url,
                 'web_url_path': '/${brand}/${webUrlPath}/'+name+'?included_fieds[]=type,${type}',
-                'all_lessons_count': count(*[_type == '${type}' && brand == '${brand}' && ^._id == ${groupBy}._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id),
-                'lessons': *[_type == '${type}' && brand == '${brand}' && ^._id == ${groupBy}._ref ${searchFilter} ${includedFieldsFilter} ${progressFilter}]{
+                'all_lessons_count': count(*[${lessonsFilter}]._id),
+                'lessons': *[${lessonsFilter}]{
                     ${fieldsString},
                     ${groupBy}
                 }[0...20]
-            }
-            |order(${sortOrder})
-            [${start}...${end}]
-        }`;
+        `;
+        filter = `_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id == ${groupBy}._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0`;
     } else if (groupBy !== "") {
-        let webUrlPath = (groupBy == 'genre')?'/genres':'';
-        query = `
-        {
-            "total": count(*[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]),
-            "entity": *[_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0]
-            {
+        const webUrlPath = (groupBy == 'genre')?'/genres':'';
+        const lessonsFilter = `brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}`;
+        entityFieldsString = `
                 'id': _id,
                 'type': _type,
                 name,
                 'head_shot_picture_url': thumbnail_url.asset->url,
                 'web_url_path': select(defined(web_url_path)=> web_url_path +'?included_fieds[]=type,${type}',!defined(web_url_path)=> '/${brand}${webUrlPath}/'+name+'/${webUrlPathType}'),
-                'all_lessons_count': count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id),
-                'lessons': *[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]{
+                'all_lessons_count': count(*[${lessonsFilter}]._id),
+                'lessons': *[${lessonsFilter}]{
                     ${fieldsString},
                     ${groupBy}
-                }[0...20]
-            }
-            |order(${sortOrder})
-            [${start}...${end}]
-        }`;
+                }[0...20]`;
+        filter = `_type == '${groupBy}' && count(*[brand == '${brand}' && ^._id in ${groupBy}[]._ref ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}]._id) > 0`;
     } else {
-        query = `
-        {
-            "entity": *[brand == "${brand}" ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}] | order(${sortOrder}) [${start}...${end}] {
-                ${fieldsString},
-            },
-            "total": count(*[brand == "${brand}" ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}])
-        }
-    `;
+        filter = `brand == "${brand}" ${typeFilter} ${searchFilter} ${includedFieldsFilter} ${progressFilter}`
+        entityFieldsString = fieldsString;
     }
+    query = buildEntityAndTotalQuery(
+        filter,
+        entityFieldsString,
+        {
+            sortOrder: sortOrder,
+            start: start,
+            end: end,
+        });
 
     return fetchSanity(query, true);
 }
@@ -645,40 +641,39 @@ export function getSortOrder(sort= '-published_on', groupBy)
 */
 export async function fetchAllFilterOptions(
     brand,
-    filters,
+    filters = [],
     style,
     artist,
     contentType,
     term,
     progressIds = undefined
 ) {
+    filters = Array.isArray(filters) ? filters : [];
     const includedFieldsFilter = filters?.length > 0 ? filtersToGroq(filters) : undefined;
 
     const progressFilter = progressIds !== undefined ?
         `&& railcontent_id in [${progressIds.join(',')}]` : "";
 
     const commonFilter = `_type == '${contentType}' && brand == "${brand}"${style ? ` && '${style}' in genre[]->name` : ''}${artist ? ` && artist->name == '${artist}'` : ''} ${progressFilter} ${includedFieldsFilter ? includedFieldsFilter : ''}`;
+    const metaData = processMetadata(brand, contentType, true);
+    const allowableFilters = metaData?.allowableFilters || [];
+
+    const dynamicFilterOptions = allowableFilters.map(filter => {
+        // Create a modified common filter for each allowable filter
+        let includedFieldsFilterWithoutSelectedOption = filters?.length > 0 ? filtersToGroq(filters, filter) : undefined;
+        const commonFilterWithoutSelectedOption = `_type == '${contentType}' && brand == "${brand}"${(style && filter !== "style") ? ` && '${style}' in genre[]->name` : ''}${(artist && filter !== "artist") ? ` && artist->name == '${artist}'` : ''} ${includedFieldsFilterWithoutSelectedOption ? includedFieldsFilterWithoutSelectedOption : ''}`;
+
+        // Call getFilterOptions with the modified common filter
+        return getFilterOptions(filter, commonFilterWithoutSelectedOption,  contentType);
+    }).join(' ');
+
     const query = `
         {
           "meta": {
             "totalResults": count(*[${commonFilter}
               ${term ? ` && (title match "${term}" || album match "${term}" || artist->name match "${term}" || genre[]->name match "${term}")` : ''}]),
             "filterOptions": {
-              "difficulty": [
-                  {"type": "Introductory", "count": count(*[${commonFilter} && difficulty_string == "Introductory"])},
-                  {"type": "Beginner", "count": count(*[${commonFilter} && difficulty_string == "Beginner"])},
-                  {"type": "Intermediate", "count": count(*[${commonFilter} && difficulty_string == "Intermediate" ])},
-                  {"type": "Advanced", "count": count(*[${commonFilter} && difficulty_string == "Advanced" ])},
-                  {"type": "Expert", "count": count(*[${commonFilter} && difficulty_string == "Expert" ])}
-              ][count > 0],
-              "instrumentless": [
-                  {"type": "Full Song Only", "count": count(*[${commonFilter} && instrumentless == false ])},
-                  {"type": "Instrument Removed", "count": count(*[${commonFilter} && instrumentless == true ])}
-              ][count > 0],
-              "genre": *[_type == 'genre' && '${contentType}' in filter_types] {
-                "type": name,
-                "count": count(*[${commonFilter} && references(^._id)])
-              }[count > 0]
+              ${dynamicFilterOptions}
             }
         }
       }`;
@@ -877,8 +872,6 @@ function getChildrenToDepth(parent, depth = 1)
     return allChildrenIds;
 }
 
-
-
 /**
 * Fetch the next and previous lessons for a specific lesson by Railcontent ID.
 * @param {string} railcontentId - The Railcontent ID of the current lesson.
@@ -1021,13 +1014,15 @@ export async function fetchAllPacks(brand, sort = "-published_on", searchTerm =
   const sortOrder = getSortOrder(sort);
   const filter = `_type == 'pack' && brand == '${brand}' && title match "${searchTerm}*"`
   const filterParams = {};
+  const fields = getFieldsForContentType('pack');
   const query = buildQuery(
     filter,
     filterParams,
     getFieldsForContentType('pack'),
-      {
-          sortOrder: sortOrder,
-      }
+    {
+      logo_image_url: 'logo_image_url.asset->url',
+      sortOrder: sortOrder,
+    }
   );
   return fetchSanity(query, true);
 }
@@ -1298,13 +1293,13 @@ export async function fetchGenreLessons(brand, name, contentType, {
 }
 
 
-
 /**
- * Fetch data from the Sanity API based on a provided query.
  *
  * @param {string} query - The GROQ query to execute against the Sanity API.
  * @param {boolean} isList - Whether to return an array or a single result.
- * @returns {Promise<Object|null>} - A promise that resolves to the fetched data or null if an error occurs or no results are found.
+ * @param {Function} [customPostProcess=null] - custom post process callback
+ * @param {boolean} [processNeedAccess=true] - execute the needs_access callback
+ * @returns {Promise<*|null>} - A promise that resolves to the fetched data or null if an error occurs or no results are found.
  *
  * @example
  * const query = `*[_type == "song"]{title, artist->name}`;
@@ -1312,7 +1307,13 @@ export async function fetchGenreLessons(brand, name, contentType, {
  *   .then(data => console.log(data))
  *   .catch(error => console.error(error));
  */
-export async function fetchSanity(query, isList) {
+
+export async function fetchSanity(query,
+                                  isList,
+                                  { customPostProcess = null,
+                                    processNeedAccess = true,} = {}
+) {
+
   // Check the config object before proceeding
   if (!checkSanityConfig(globalConfig)) {
       return null;
@@ -1340,7 +1341,9 @@ export async function fetchSanity(query, isList) {
           if (globalConfig.sanityConfig.debug) {
               console.log("fetchSanity Results:", result);
           }
-          return isList ? result.result : result.result[0];
+          let results = isList ? result.result : result.result[0];
+          results = processNeedAccess ? await needsAccessDecorator(results) : results;
+          return customPostProcess ? customPostProcess(results) : results;
       } else {
           throw new Error('No results found');
       }
@@ -1350,6 +1353,41 @@ export async function fetchSanity(query, isList) {
   }
 }
 
+async function needsAccessDecorator(results)
+{
+    if (globalConfig.sanityConfig.useDummyRailContentMethods) return results;
+    let userPermissions = await getUserPermissions();
+    userPermissions = new Set(userPermissions);
+    if (Array.isArray(results)) {
+        results.forEach((result) => {
+            result['need_access'] = doesUserNeedAccessToContent(result, userPermissions);
+        });
+    } else {
+        results['need_access'] = doesUserNeedAccessToContent(results, userPermissions);
+    }
+    return results;
+}
+
+function doesUserNeedAccessToContent(result, userPermissions)
+{
+    const permissions =  new Set(result.permission_id ?? []);
+    if (permissions.length === 0) {
+        return false;
+    }
+    for (let permission of permissions) {
+        if (userPermissions.has(permission)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+async function getUserPermissions()
+{
+    return await fetchUserPermissions();
+}
+
+
 /**
  * Fetch CatalogueMetadata from Sanity. This information may be duplicated in the contentTypeConfig.js.
  * It's an ongoing discussion (Aug 2024), but it's been included here if necessary
@@ -1401,7 +1439,7 @@ export async function fetchShowsData(brand) {
 }
 
 /**
- * Fetch metadata from the contentTypeConfig.js based on brand and type.
+ * Fetch metadata from the contentMetaData.js based on brand and type.
  *
  * @param {string} brand - The brand for which to fetch metadata.
  * @param {string} type - The type for which to fetch metadata.
@@ -1512,27 +1550,88 @@ function     buildEntityAndTotalQuery(
     }`;
     return query;
 }
-function processMetadata(brand, type, withFilters = false) {
-    const metadataElement = contentMetadata[brand]?.[type];
-    if (!metadataElement) {
-        return null;
+
+
+function getFilterOptions(option, commonFilter,contentType){
+    let filterGroq = '';
+    switch (option) {
+        case "difficulty":
+            filterGroq = ` 
+                "difficulty": [
+        {"type": "Introductory", "count": count(*[${commonFilter} && difficulty_string == "Introductory"])},
+        {"type": "Beginner", "count": count(*[${commonFilter} && difficulty_string == "Beginner"])},
+        {"type": "Intermediate", "count": count(*[${commonFilter} && difficulty_string == "Intermediate" ])},
+        {"type": "Advanced", "count": count(*[${commonFilter} && difficulty_string == "Advanced" ])},
+        {"type": "Expert", "count": count(*[${commonFilter} && difficulty_string == "Expert" ])}
+        ][count > 0],`;
+            break;
+        case "genre":
+        case "essential":
+        case "focus":
+        case "theory":
+        case "topic":
+        case "lifestyle":
+        case "creativity":
+            filterGroq = `
+            "${option}": *[_type == '${option}' && '${contentType}' in filter_types] {
+            "type": name,
+                "count": count(*[${commonFilter} && references(^._id)])
+        }[count > 0],`;
+            break;
+        case "instrumentless":
+            filterGroq = `
+            "${option}":  [
+                  {"type": "Full Song Only", "count": count(*[${commonFilter} && instrumentless == false ])},
+                  {"type": "Instrument Removed", "count": count(*[${commonFilter} && instrumentless == true ])}
+              ][count > 0],`;
+            break;
+        case "gear":
+            filterGroq = `
+            "${option}":  [
+                  {"type": "Practice Pad", "count": count(*[${commonFilter} && gear match 'Practice Pad' ])},
+                  {"type": "Drum-Set", "count": count(*[${commonFilter} && gear match 'Drum-Set'])}
+              ][count > 0],`;
+            break;
+        case "bpm":
+            filterGroq = `
+            "${option}":  [
+                  {"type": "50-90", "count": count(*[${commonFilter} && bpm > 50 && bpm < 91])},
+                  {"type": "91-120", "count": count(*[${commonFilter} && bpm > 90 && bpm < 121])},
+                  {"type": "121-150", "count": count(*[${commonFilter} && bpm > 120 && bpm < 151])},
+                  {"type": "151-180", "count": count(*[${commonFilter} && bpm > 150 && bpm < 181])},
+                  {"type": "180+", "count": count(*[${commonFilter} && bpm > 180])},
+              ][count > 0],`;
+            break;
+        default:
+            filterGroq = "";
+            break;
     }
-    const processedData = {
-        type,
-        thumbnailUrl: metadataElement.thumbnailUrl || null,
-        name: metadataElement.name || null,
-        description: metadataElement.description || null
-    };
-
-    if (withFilters) {
-        Object.keys(metadataElement).forEach(key => {
-            if ( !['thumbnailUrl', 'name', 'description'].includes(key) ) {
-                processedData[key] = metadataElement[key];
-            }
-        });
+
+    return filterGroq;
+}
+
+function cleanUpGroq(query) {
+    // Split the query into clauses based on the logical operators
+    const clauses = query.split(/(\s*&&|\s*\|\|)/).map(clause => clause.trim());
+
+    // Filter out empty clauses
+    const filteredClauses = clauses.filter(clause => clause.length > 0);
+
+    // Check if there are valid conditions in the clauses
+    const hasConditions = filteredClauses.some(clause => !clause.match(/^\s*&&\s*|\s*\|\|\s*$/));
+
+    if (!hasConditions) {
+        // If no valid conditions, return an empty string or the original query
+        return '';
     }
 
-    return processedData;
+    // Remove occurrences of '&& ()'
+    const cleanedQuery = filteredClauses.join(' ')
+        .replace(/&&\s*\(\)/g, '')
+        .replace(/(\s*&&|\s*\|\|)(?=\s*[\s()]*$|(?=\s*&&|\s*\|\|))/g, '')
+        .trim();
+
+    return cleanedQuery;
 }
 
 
@@ -1553,7 +1652,7 @@ function processMetadata(brand, type, withFilters = false) {
 <br class="clear">
 
 <footer>
-    Documentation generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 4.0.3</a> on Tue Sep 24 2024 20:13:55 GMT+0000 (Coordinated Universal Time) using the <a href="https://github.com/clenemt/docdash">docdash</a> theme.
+    Documentation generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 4.0.3</a> on Fri Sep 27 2024 21:58:51 GMT+0000 (Coordinated Universal Time) using the <a href="https://github.com/clenemt/docdash">docdash</a> theme.
 </footer>
 
 <script>prettyPrint();</script>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "1.0.118",
+  "version": "1.0.120",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "scripts": {

package/src/contentTypeConfig.js

@@ -95,6 +95,11 @@ let contentTypeConfig = {
             '"instructors": instructor[]->name',
             '"header_image_url": thumbnail.asset->url',
             '"logo_image_url": logo_image_url.asset->url',
+            '"award": award.asset->url',
+            `"award_template": award_template[]{
+                streak_minimum,
+                "template" : template.asset->url,
+            }`,
         ]
     },
     'course': {

package/src/filterBuilder.js

@@ -22,7 +22,8 @@ export class FilterBuilder {
         this.getFutureContentOnly = getFutureContentOnly;
         this.getFutureScheduledContentsOnly = getFutureScheduledContentsOnly;
         this.filter = filter;
-        this.debug = process.env.DEBUG === 'true' || false;
+        // this.debug = process.env.DEBUG === 'true' || false;
+        this.debug = false;
     }
 
 

package/src/services/sanity.js

@@ -873,7 +873,7 @@ export async function fetchLessonContent(railContentId) {
           "thumbnail_url":thumbnail.asset->url, 
           "url": web_url_path, 
           soundslice_slug,
-          description,
+          "description": description[0].children[0].text,
           "chapters": chapter[]{
             chapter_description,
             chapter_timecode,
@@ -889,6 +889,7 @@ export async function fetchLessonContent(railContentId) {
             "id":_id,
             name,
             short_bio,
+            "biography": short_bio[0].children[0].text, 
             web_url_path,
             "coach_card_image": coach_card_image.asset->url,
           },
@@ -1072,6 +1073,8 @@ export async function fetchChallengeOverview(id) {
       difficulty_string,
       difficulty,
       "type": _type,
+      is_always_unlocked,
+      is_bonus_content,
     }
   } [0...1]`;
   return fetchSanity(query, false);

package/test/sanityQueryService.test.js

@@ -433,6 +433,16 @@ describe('Sanity Queries', function () {
         expect(response.tabs.length).toBeGreaterThan(0);
     });
 
+    test('fetchChallengesV2Fields', async () => {
+        const id = 402197;
+        const response = await fetchChallengeOverview(id);
+        log(response);
+        expect(response.award).toBeDefined();
+        expect(response.award_template).toBeDefined();
+        expect(response.lessons[0].is_always_unlocked).toBeDefined();
+        expect(response.lessons[0].is_bonus_content).toBeDefined();
+    });
+
 });
 
 describe('Filter Builder', function () {
@@ -618,6 +628,7 @@ describe('Filter Builder', function () {
     });
 });
 
+
 describe('MetaData', function () {
 
     test('customBrandTypeExists', async () => {