Source: course/index.js

  1. /**
  2.  * @module course
  3.  */
  4. const courseRepo = require("../../repositories/course");
  5. const coursePhaseRepo = require("../../repositories/course/phase");
  6. const log = require("../../util/log");
  7. const filtering = require("../filtering");
  8. const cache = require("../cache");
  9. const _ = require('lodash');
  11. /**
  12.  * Fetch similar course records by provided course and course-phase
  13.  * records. If the provided course has multiple phases, one is picked
  14.  * to avoid duplicate results.
  15.  * Returns an array of course records with a default maximum size of 5.
  16.  * @param {Object} course
  17.  * @param {Number} [maximum=5] default is 5
  18.  * @return {Array} similar course records
  19.  */
  20. const fetchSimilarCourseRecords = async (course, maximum) => {
  21.     let findRecords = [];
  22.     if (cache.has("courses")) {
  23.         const cachedVal = cache.get("courses");
  24.         log.info("Course %s: Fetching similar courses from CACHE", course.id);
  25.         const matching = [];
  26.         cachedVal.forEach(e => {
  27.             if (
  28.                 (e.capabilityId === course.capabilityId) &&
  29.                 (e.categoryId === course.categoryId) &&
  30.                 (e.competencyId === course.competencyId) &&
  31.                 (e.phases[0] === course.phases[0])
  32.             ) {
  33.                 matching.push(e);
  34.             }
  35.         });
  36.         findRecords = matching;
  37.     } else {
  38.         log.info("Course %s: Fetching similar courses from DB", course.id);
  39.         const findWithPhaseResult = await courseRepo.findByFilters({
  40.             capabilityId: course.capabilityId,
  41.             categoryId: course.categoryId,
  42.             competencyId: course.competencyId,
  43.             // if a course has multiple phases, one of them is picked for search
  44.             phaseId: course.phases[0],
  45.         });
  46.         findRecords = findWithPhaseResult.rows;
  47.     }
  49.     // TODO: fetch more
  51.     const filteredRecords = findRecords.filter(e => e.id !== course.id);
  53.     log.info("Course %s: Found %s similar course(s), returning %s",
  54.         course.id, filteredRecords.length,
  55.         ((filteredRecords.length > 5) ? (maximum ? maximum : 5) : filteredRecords.length));
  57.     // return maximum 5 by default
  58.     return filteredRecords.slice(0, (maximum ? maximum : 5));
  59. };
  61. /**
  62.  * Fetches all info related to course and resolves
  63.  * all identifiers to values in the database.
  64.  * Returns resolved course object.
  65.  * @param {Number} courseId
  66.  * @return {Object} course
  67.  */
  68. const fetchAndResolveCourse = async (courseId) => {
  69.     log.info("Course %s: Fetching all info", courseId);
  70.     if (cache.has(`course-${courseId}`)) {
  71.         log.info("Course %s: Fetched all info from CACHE", courseId);
  72.         return cache.get(`course-${courseId}`);
  73.     } else {
  74.         throw new Error(`No course found by id '${courseId}'`);
  75.     }
  76. };
  78. /**
  79.  * Fetch courses based on input filters.
  80.  * Fetches from cache if possible
  81.  * @param {Object} filters
  82.  * @return {Array} matching course objects
  83.  */
  84. const fetchByFilters = async (filters) => {
  85.     if (cache.has("courses")) {
  86.         const cachedVal = cache.get("courses");
  87.         const matching = [];
  88.         const safeKey = _.escapeRegExp(filters.keyword);
  89.         const regex = RegExp(safeKey ? safeKey : '', 'i');
  90.         cachedVal.forEach(e => {
  91.             if (
  92.                 (
  93.                     !filters.capability ||
  94.                     parseInt(filters.capability, 10) === -1 ||
  95.                     e.capabilityId === parseInt(filters.capability, 10)
  96.                 ) &&
  97.                 (
  98.                     !filters.category ||
  99.                     parseInt(filters.category, 10) === -1 ||
  100.                     e.categoryId === parseInt(filters.category, 10)
  101.                 ) &&
  102.                 (
  103.                     !filters.competency ||
  104.                     parseInt(filters.competency, 10) === -1 ||
  105.                     e.competencyId === parseInt(filters.competency, 10)
  106.                 ) &&
  107.                 (
  108.                     !filters.phase ||
  109.                     parseInt(filters.phase, 10) === -1 ||
  110.                     e.phases.includes(parseInt(filters.phase, 10))
  111.                 ) &&
  112.                 (
  113.                     regex.test(e.title)
  114.                 )
  115.             ) {
  116.                 matching.push(e);
  117.             }
  118.         });
  119.         log.info("Fetched %s courses with %s filters from CACHE", matching.length, JSON.stringify(filters));
  120.         return matching;
  121.     } else {
  122.         const findResult = await courseRepo.findByFiltersAndKeywordJoint({
  123.             filters: {
  124.                 capabilityId: filters.capability ? parseInt(filters.capability, 10) : -1,
  125.                 categoryId: filters.category ? parseInt(filters.category, 10) : -1,
  126.                 competencyId: filters.competency ? parseInt(filters.competency, 10) : -1,
  127.                 phaseId: filters.phase ? parseInt(filters.phase, 10) : -1,
  128.             },
  129.             keyword: filters.keyword ? filters.keyword : '',
  130.         });
  131.         log.info("Fetched %s courses with %s filters from DB", findResult.rows.length, JSON.stringify(filters));
  132.         return findResult.rows;
  133.     }
  134. };
  136. /**
  137.  * Fetch call courses.
  138.  * Fetches from cache if possible, otherwise
  139.  * fetches from database and caches values
  140.  * for future use.
  141.  */
  142. const fetchAll = async () => {
  143.     if (cache.has("courses")) {
  144.         return cache.get("courses");
  145.     } else {
  146.         const courses = await fetchByFilters({});
  147.         cache.set("courses", courses);
  148.         courses.forEach(e => {
  149.             cache.set(`course-${e.id}`, e);
  150.         });
  151.         return (courses);
  152.     }
  153. };
  155. /**
  156.  * Fetch all courses that have unique titles.
  157.  * Fetches all courses then filters and sorts
  158.  * by the titles.
  159.  * @return {Array} courses
  160.  */
  161. const fetchAllWithUniqueTitles = async () => {
  162.     const allCourses = await fetchAll();
  163.     return filtering.filterAndSortByTitle(allCourses);
  164. };
  166. /**
  167.  * Add a new course: insert new course object to the database,
  168.  * and immediately attempt to update the cache with the new object.
  169.  * The course object is only cached if it can successfully be updated
  170.  * from the LinkedIn Learning API.
  171.  * @param {Object} course
  172.  */
  173. const addNewCourse = async (course) => {
  174.     const insertionResult = await courseRepo.insert({
  175.         title: course.title,
  176.         hyperlink: course.hyperlink,
  177.         capabilityId: parseInt(course.capability, 10),
  178.         categoryId: parseInt(course.category, 10),
  179.         competencyId: parseInt(course.competency, 10),
  180.         urn: course.urn,
  181.     });
  182.     const courseId = insertionResult.rows[0].id;
  183.     if (Array.isArray(course.phases)) {
  184.         for await (const phase of course.phases) {
  185.             await coursePhaseRepo.insert({
  186.                 courseId,
  187.                 phaseId: parseInt(phase, 10),
  188.             });
  189.         }
  190.     } else {
  191.         await coursePhaseRepo.insert({
  192.             courseId,
  193.             phaseId: parseInt(course.phases, 10),
  194.         });
  195.     }
  196.     log.info("Course %d: Successfully inserted new record to database", courseId);
  197.     log.info("Course %d: Caching new course...", courseId);
  198.     const findResult = await courseRepo.findByIdWithFullInfo(courseId);
  199.     const temp = findResult.rows[0];
  200.     cache.set(`course-${courseId}`, temp);
  201.     await cache.updateFromAPI(`course-${courseId}`);
  202.     log.info("Course %d: Cache updated with new course.", courseId);
  203.     return courseId;
  204. };
  206. /**
  207.  * Update a course: update a stored course object in the database,
  208.  * and immediately attempt to update the cache with the object.
  209.  * The course object is only cached if it can successfully be updated
  210.  * from the LinkedIn Learning API.
  211.  * @param {Object} course
  212.  */
  213. const updateCourse = async (course) => {
  214.     const courseId = parseInt(course.id, 10);
  215.     await courseRepo.update({
  216.         title: course.title,
  217.         hyperlink: course.hyperlink,
  218.         capabilityId: parseInt(course.capability, 10),
  219.         categoryId: parseInt(course.category, 10),
  220.         competencyId: parseInt(course.competency, 10),
  221.         urn: course.urn,
  222.         id: courseId,
  223.     });
  224.     await coursePhaseRepo.removeByCourseId(courseId);
  225.     if (Array.isArray(course.phases)) {
  226.         for await (const phase of course.phases) {
  227.             await coursePhaseRepo.insert({
  228.                 courseId,
  229.                 phaseId: parseInt(phase, 10),
  230.             });
  231.         }
  232.     } else {
  233.         await coursePhaseRepo.insert({
  234.             courseId,
  235.             phaseId: parseInt(course.phases, 10),
  236.         });
  237.     }
  238.     log.info("Course %d: Successfully updated record in database", courseId);
  239.     log.info("Course %d: Caching updated course...", courseId);
  240.     const findResult = await courseRepo.findByIdWithFullInfo(courseId);
  241.     const temp = findResult.rows[0];
  242.     const coursesArray = cache.get("courses");
  243.     const index = coursesArray.findIndex((e) => {
  244.         return e.id === courseId;
  245.     });
  246.     coursesArray[index] = temp;
  247.     cache.set(`course-${courseId}`, temp);
  248.     cache.set("courses", coursesArray);
  249.     log.info("Course %d: Cache updated with updated course.", courseId);
  250. };
  252. /**
  253.  * Delete a course from the database and efficiently remove it
  254.  * from the cache so full flushing of cache can be avoided.
  255.  * @param {Number} id
  256.  */
  257. const deleteCourse = async (id) => {
  258.     log.info("Course %d: Deleting course with all details...", id);
  259.     await courseRepo.removeById(id);
  260.     await coursePhaseRepo.removeByCourseId(id);
  261.     log.info("Course %d: Deleting course from cache...", id);
  262.     cache.del(`course-${id}`);
  263.     const coursesArray = cache.get("courses");
  264.     const index = coursesArray.findIndex((e) => {
  265.         return e.id === parseInt(id, 10);
  266.     });
  267.     coursesArray.splice(index, 1);
  268.     cache.set("courses", coursesArray);
  269.     log.info("Course %d: Deleted course from cache...", id);
  270.     log.info("Course %d: Deleted course with all details...", id);
  271. };
  273. module.exports = {
  274.     fetchSimilarCourseRecords,
  275.     fetchAndResolveCourse,
  276.     fetchByFilters,
  277.     fetchAll,
  278.     fetchAllWithUniqueTitles,
  279.     addNewCourse,
  280.     updateCourse,
  281.     deleteCourse,
  282. };