Source: linkedin_learning/index.js

  1. /**
  2.  * @module linkedinLearning
  3.  */
  4. const got = require("got");
  5. const log = require("../../util/log");
  6. const {differenceInDays} = require("date-fns");
  7. const config = require("../../config").linkedinLearningAPI;
  9. const learningObjectRepository = require("../../repositories/learning_object");
  11. /**
  12.  * Number of failed API token renewals.
  13.  * Functions use this to avoid repeating
  14.  * unauthorised API requests
  15.  */
  16. let failedRenewals = 0;
  18. /**
  19.  * Attempt to renew LinkedIn Learning API token.
  20.  * Update failedRenewals counter based on result.
  21.  */
  22. const renewAccessToken = async () => {
  23.     log.info("LinkedIn-L API: Attempting to renew access token..");
  25.     try {
  26.         const response = await got.post("https://www.linkedin.com/oauth/v2/accessToken", {
  27.             responseType: "json",
  28.             searchParams: {
  29.                 "grant_type": "client_credentials",
  30.                 "client_id": process.env.LINKEDIN_LEARNING_ID,
  31.                 "client_secret": process.env.LINKEDIN_LEARNING_SECRET,
  32.             },
  33.         });
  35.         if (response.statusCode === 200) {
  36.             process.env.LINKEDIN_LEARNING_TOKEN = response.body.access_token;
  37.             failedRenewals = 0;
  38.             log.info("LinkedIn-L API: Successfully renewed access token.");
  39.         } else {
  40.             ++failedRenewals;
  41.             log.error("LinkedIn-L API: Failed to renew access token, statusCode: %s, statusMsg: %s",
  42.                 response.statusCode, response.statusMessage);
  43.         }
  44.     } catch (error) {
  45.         ++failedRenewals;
  46.         log.error("LinkedIn-L API: Failed to POST token renewal endpoint, err:" + error.message);
  47.     }
  48. };
  50. /**
  51.  * Attempt to fetch learningObject from LinkedIn Learning API
  52.  * based on its Unique Resource Identifier (URN) if respective
  53.  * object in database is out of date.
  54.  * If the API response is 401 Unauthorised and there haven't been
  55.  * any failed renewals, reattempts with a renewed token.
  56.  * Logs attempt details including whether the cached value is up to date.
  57.  * Returns undefined on failure.
  58.  * @param {String} urn
  59.  * @return {Object} learningObject or undefined
  60.  */
  61. const fetchLearningObject = async (urn) => {
  62.     const findResult = await learningObjectRepository.findByURN(urn);
  63.     if (findResult.rows.length > 0) {
  64.         const lastUpdated = new Date(findResult.rows[0].timestamp);
  65.         if (differenceInDays((new Date()), lastUpdated) < config.ttl) {
  66.             log.info("LinkedIn-L API: Found up to date learning object (%s) in database", urn);
  67.             return findResult.rows[0].data;
  68.         }
  69.         log.info("LinkedIn-L API: Found outdated learning object (%s) in database, re-fetching...", urn);
  70.     }
  72.     log.info("LinkedIn-L API: Attempting to fetch learning obj(%s)..", urn);
  74.     const meta = [
  75.         "urn",
  76.         "title:(value)",
  77.     ];
  79.     const details = [
  80.         "urls:(webLaunch)",
  81.         "shortDescriptionIncludingHtml:(value)",
  82.         "images:(primary)",
  83.         "descriptionIncludingHtml:(value)",
  84.         "timeToComplete:(duration)",
  85.     ];
  87.     try {
  88.         const response = await got("https://api.linkedin.com/v2/learningAssets/" + urn, {
  89.             responseType: "json",
  90.             headers: {
  91.                 Authorization: getOAuthToken(),
  92.             },
  93.             searchParams: {
  94.                 "fields": `${meta.join()},details:(${details.join()})`,
  95.                 "expandDepth": 1,
  96.                 "targetLocale.language": "en",
  97.             },
  98.             hooks: {
  99.                 afterResponse: [
  100.                     async (response, retryWithNewToken) => {
  101.                         if (response.statusCode === 401 && failedRenewals === 0) { // Unauthorized
  102.                             log.error("LinkedIn-L API: failed to authenticate for learning asset endpoint. " +
  103.                                 "Attempting to retry with a new access token..");
  104.                             await renewAccessToken();
  106.                             // Retry
  107.                             log.info("LinkedIn-L API: Retrying with new access token...");
  108.                             return retryWithNewToken();
  109.                         }
  111.                         // No changes otherwise
  112.                         return response;
  113.                     },
  114.                 ],
  115.                 beforeRetry: [
  116.                     async (options) => {
  117.                         options.headers.Authorization = getOAuthToken();
  118.                     },
  119.                 ],
  120.             },
  121.         });
  122.         if (response.statusCode === 200) {
  123.             log.info("LinkedIn-L API: Successfully fetched learning asset.");
  124.             await learningObjectRepository.insert({
  125.                 urn,
  126.                 timestamp: (new Date()).toUTCString(),
  127.                 data: JSON.stringify(response.body),
  128.             });
  129.             return response.body;
  130.         }
  131.     } catch (error) {
  132.         log.error("LinkedIn-L API: Failed to GET learning asset (%s) endpoint, err: " + error.message, urn);
  133.     }
  134. };
  136. /**
  137.  * Attempt to fetch matching URN to given learningObject from LinkedIn Learning API.
  138.  * In order for a URN to be considered matching, the user input hyperlink must match
  139.  * the full path of the API object's hyperlink.
  140.  * If the API response is 401 Unauthorised and there haven't been
  141.  * any failed renewals, reattempts with a renewed token.
  142.  * Logs attempt details including degree of match.
  143.  * Returns undefined on failure.
  144.  * @param {Object} learningObject must have title & hyperlink
  145.  * @param {String} type learning object type COURSE / VIDEO
  146.  * @return {String} URN or undefined
  147.  */
  148. const fetchURNByContent = async (learningObject, type) => {
  149.     log.info("LinkedIn-L API: Attempting to find matching URN for %s (%s)", type, learningObject.data.title);
  150.     try {
  151.         const response = await got("https://api.linkedin.com/v2/learningAssets", {
  152.             responseType: "json",
  153.             headers: {
  154.                 Authorization: getOAuthToken(),
  155.             },
  156.             searchParams: {
  157.                 "q": "criteria",
  158.                 "start": 0,
  159.                 "count": 10,
  160.                 "assetRetrievalCriteria.includeRetired": false,
  161.                 "assetRetrievalCriteria.expandDepth": 1,
  162.                 "assetFilteringCriteria.keyword": learningObject.data.title,
  163.                 "assetFilteringCriteria.assetTypes[0]": type,
  164.                 "fields": "urn,details:(urls:(webLaunch))",
  165.             },
  166.             hooks: {
  167.                 afterResponse: [
  168.                     async (response, retryWithNewToken) => {
  169.                         if (response.statusCode === 401 && failedRenewals === 0) { // Unauthorized
  170.                             log.error("LinkedIn-L API: failed to authenticate for learning asset endpoint. " +
  171.                                 "Attempting to retry with a new access token..");
  172.                             await renewAccessToken();
  174.                             // Retry
  175.                             log.info("LinkedIn-L API: Retrying with new access token...");
  176.                             return retryWithNewToken();
  177.                         }
  179.                         // No changes otherwise
  180.                         return response;
  181.                     },
  182.                 ],
  183.                 beforeRetry: [
  184.                     async (options) => {
  185.                         options.headers.Authorization = getOAuthToken();
  186.                     },
  187.                 ],
  188.             },
  189.         });
  190.         const elements = response.body.elements;
  191.         for (const e of elements) {
  192.             if (learningObject.data.hyperlink.startsWith(e.details.urls.webLaunch.substring(0, e.details.urls.webLaunch.length -2))) {
  193.                 log.info("LinkedIn-L API: Found matching URN for %s (%s) - (%s)", type, learningObject.data.title, e.urn);
  194.                 return e.urn;
  195.             }
  196.         }
  197.         log.error("LinkedIn-L API: No matching URN found for %s (%s)", type, learningObject.data.title);
  198.     } catch (error) {
  199.         log.error("LinkedIn-L API: Failed to GET learning assets endpoint, err: " + error.message);
  200.     }
  201. };
  203. /**
  204.  * Returns the server's LinkedIn Learning API token in OAuth 2.0 Authorisation header format.
  205.  * @return {String} API token in OAuth 2.0 format
  206.  */
  207. const getOAuthToken = () => {
  208.     return `Bearer ${process.env.LINKEDIN_LEARNING_TOKEN}`;
  209. };
  211. /**
  212.  * TEST FUNCTION: Must only be used for testing purposes.
  213.  * Reset failedRenewals counter to 0.
  214.  */
  215. const resetFailedRenewalsCounter = () => {
  216.     failedRenewals = 0;
  217. };
  219. module.exports = {
  220.     renewAccessToken,
  221.     fetchLearningObject,
  222.     fetchURNByContent,
  223.     resetFailedRenewalsCounter,
  224. };