Eddie Hinkle

nintendo-switch-importer.ts

  1. import * as request from 'request-promise';
  2. import * as moment from 'moment';
  3. import * as fs from 'fs';
  4. import * as cron from 'cron';
  6. // You will need to create the nintendo config file below
  7. interface NintendoConfig {
  8.     "grant_type": string;
  9.     "session_token": string;
  10.     "client_id": string;
  11.     "token_type": 'Bearer';
  12.     "access_token": string;
  13.     "device_id": string;
  14.     "smart_device_id": string;
  15. }
  16. const NINTENDO_CONFIG_FILE = __dirname + '/../nintendo_config.json';
  17. let nintendoConfig = require(NINTENDO_CONFIG_FILE) as NintendoConfig;
  18. const dailySummaryUrl = `https://api-lp1.pctl.srv.nintendo.net/moon/v1/devices/${nintendoConfig.device_id}/daily_summaries`;
  19. const tokenUrlEndpoint = "https://accounts.nintendo.com/connect/1.0.0/api/token";
  21. // You will need to create the Micropub config file below
  22. interface MicropubConfig {
  23.     "endpoint": string;
  24.     "token": string;
  25. }
  26. const MICROPUB_CONFIG_FILE = __dirname + '/../micropub_config.json';
  27. let micropubConfig = require(MICROPUB_CONFIG_FILE) as MicropubConfig;
  29. // How frequently the cron job runs will indicate how accurate the final "Play" post is to the time of game play.
  30. // Essentially "0,30" rounds your game play UP to the closest hour or 30 minute mark.
  31. // Game play that ends at 1:13 gets posted as 1:30.
  32. // Also note, because the script needs to wait until it knows there isn't any more game play going on,
  33. // your 1:30 game play won't be posted until the next increment, in this case 2:00.
  34. new cron.CronJob('0 0,30 * * * *', function () {
  35.     console.log('running routine cron job');
  36.     periodicFetch();
  37. }).start();
  40. console.log('Setting up Cron Job');
  42. function periodicFetch() {
  43.     getDailySummary().then(
  44.     body=> {
  45.         if (body.items !== undefined) {
  47.             // Get previous data
  48.             let previousFetchedData;
  49.             let previousPlayTime;
  51.             try {
  52.                 previousFetchedData = JSON.parse(fs.readFileSync(`${__dirname}/../last_fetched_data.json`, { encoding: 'utf8' }));
  53.             } catch(error) {
  54.                 console.log(`OOPS! Couldn't get previous data`);
  55.                 console.log(error);
  56.             }
  58.             try {
  59.                 previousPlayTime = JSON.parse(fs.readFileSync(`${__dirname}/../previous_play_time.json`, { encoding: 'utf8' }));
  60.             } catch(error) {
  61.                 console.log(`OOPS! Couldn't get previous play time`);
  62.                 previousPlayTime = {};
  63.             }
  65.             // Set current timestamp and write current data to file
  66.             body.fetched_timestamp = moment().format();
  68.             fs.writeFile(__dirname + '/../last_fetched_data.json', JSON.stringify(body), function(err) {
  69.                 if(err) {
  70.                     return console.log(err);
  71.                 }
  72.             });
  74.             // We will want to reverse the day arrays to be in chronological order
  75.             previousFetchedData.items.reverse();
  76.             body.items.reverse();
  77.             body.items.forEach((daySummary, dayIndex) => {
  78.                 daySummary.devicePlayers.forEach((player, playerIndex) => {
  79.                     player.playedApps.forEach((gameData, gameDataIndex) => {
  80.                         let game = daySummary.playedApps.find(app => app.applicationId === gameData.applicationId);
  82.                         let playDate = moment(daySummary.date, "YYYY-MM-DD");
  84.                         let previousPlayedDates = Object.keys(previousPlayTime);
  85.                         let mostRecentPlayedDate = previousPlayedDates.length > 0 ? previousPlayedDates.pop() : null;
  87.                         // Check that this was played today
  88.                         if (mostRecentPlayedDate === null ||
  89.                             moment(mostRecentPlayedDate, "YYYY-MM-DD").isSameOrBefore(playDate, "days")) {
  91.                             // Group the data the same way for the previous data as the current data
  92.                             let previousDataDay = previousFetchedData.items[dayIndex];
  93.                             let previousDataPlayer = previousDataDay.devicePlayers[playerIndex];
  94.                             let previousDataGameData = previousDataPlayer.playedApps[gameDataIndex];
  96.                             let playTimeForDay = (previousPlayTime[playDate.format("YYYY-MM-DD")] !== undefined &&
  97.                                                   previousPlayTime[playDate.format("YYYY-MM-DD")][player.nickname] !== undefined &&
  98.                                                   previousPlayTime[playDate.format("YYYY-MM-DD")][player.nickname][gameData.applicationId] !== undefined) ? parseInt(previousPlayTime[playDate.format("YYYY-MM-DD")][player.nickname][gameData.applicationId]) : 0;
  100.                             // Check that the playing time is the same as the last time we checked.
  101.                             // If so, the game is no longer being played
  102.                             // Also verify the player and the game are the same
  103.                             if ((player.nickname === "Eddie" || player.nickname === "Shared") &&
  104.                                 previousDataPlayer.nickname === player.nickname &&
  105.                                 previousDataGameData.applicationId === gameData.applicationId &&
  106.                                 previousDataGameData.playingTime === gameData.playingTime &&
  107.                                 (gameData.playingTime - playTimeForDay > 0)) {
  109.                                 let current = moment();
  110.                                 let lastPlayedTime =  current.isSame(playDate, "days") ? previousFetchedData.fetched_timestamp : playDate.clone().hour(23).minute(59).second(0).millisecond(0);
  112.                                 let newPost = {
  113.                                     "type": ["h-entry"],
  114.                                     "properties": {
  115.                                         "published": [lastPlayedTime],
  116.                                         "duration": (gameData.playingTime - playTimeForDay),
  117.                                         "play-of": {
  118.                                             "type": "h-cite",
  119.                                             "properties": {
  120.                                                 "name": game.title,
  121.                                                 "url": game.shopUri,
  122.                                                 "featured": game.imageUri.extraLarge,
  123.                                             }
  124.                                         },
  125.                                         "category": ["games"]
  126.                                     }
  127.                                 };
  129.                                 if (player.nickname === "Shared") {
  130.                                     newPost.properties.category.push("https://ashleyhinkle.com/");
  131.                                 }
  133.                                 sendViaMicropub(newPost);
  135.                                 console.log(JSON.stringify(newPost, null, 2));
  137.                                 // Track previous play time used
  138.                                 if (previousPlayTime[playDate.format("YYYY-MM-DD")] === undefined) {
  139.                                     previousPlayTime[playDate.format("YYYY-MM-DD")] = {};
  140.                                 }
  142.                                 if (previousPlayTime[playDate.format("YYYY-MM-DD")][player.nickname] === undefined) {
  143.                                     previousPlayTime[playDate.format("YYYY-MM-DD")][player.nickname] = {};
  144.                                 }
  145.                                 previousPlayTime[playDate.format("YYYY-MM-DD")][player.nickname][gameData.applicationId] = playTimeForDay + gameData.playingTime;
  147.                             }
  148.                         }
  150.                     });
  151.                 });
  152.             });
  154.             fs.writeFile(__dirname + '/../previous_play_time.json', JSON.stringify(previousPlayTime), { encoding: 'utf8' }, function(err) {
  155.                 if(err) {
  156.                     return console.log(err);
  157.                 }
  158.             });
  159.         }
  161.         console.log('success');
  162.     }, error => {
  163.         console.log('uh oh error');
  164.         console.log(error.statusCode);
  166.         if (error.statusCode === 401) {
  167.             console.log("Fetching new access info");
  169.             getNewAccessToken().then(accessInfo => {
  170.                 nintendoConfig.access_token = accessInfo.access_token;
  171.                 nintendoConfig.token_type = accessInfo.token_type;
  172.                 saveNewAccessInfo(nintendoConfig);
  173.                 periodicFetch();
  174.             });
  175.         }
  176.     });
  178. }
  180. function getNewAccessToken() {
  181.     return request.post({
  182.         uri: tokenUrlEndpoint,
  183.         form: {
  184.             "grant_type": nintendoConfig.grant_type,
  185.             "session_token": nintendoConfig.session_token,
  186.             "client_id": nintendoConfig.client_id
  187.         },
  188.         json: true
  189.     });
  190. }
  192. function saveNewAccessInfo(info) {
  193.     fs.writeFile(NINTENDO_CONFIG_FILE, JSON.stringify(info), function(err) {
  194.         if(err) {
  195.             return console.log(err);
  196.         }
  198.         console.log("New Access Info Saved");
  199.     });
  200. }
  202. function getDailySummary() {
  203.     return request.get(dailySummaryUrl, {
  204.         headers: {
  205.             "x-moon-os-language": "en-US",
  206.             "x-moon-app-language": "en-US",
  207.             "authorization": `${nintendoConfig.token_type} ${nintendoConfig.access_token}`,
  208.             "x-moon-app-internal-version": 265,
  209.             "x-moon-app-display-version": "1.7.2",
  210.             "x-moon-app-id": "com.nintendo.znma",
  211.             "x-moon-os": "IOS",
  212.             "x-moon-os-version": "12.1.4",
  213.             "x-moon-model": "iPhone10,3",
  214.             "accept-encoding": "gzip;q=1.0, compress;q=0.5",
  215.             "accept-language": "en-US;q=1.0",
  216.             "user-agent": "moon_ios/1.7.2 (com.nintendo.znma; build:265; iOS 12.1.4) Alamofire/4.7.3",
  217.             "x-moon-timezone": "America/New_York",
  218.             "x-moon-smart-device-id": nintendoConfig.smart_device_id
  219.         },
  220.         json: true
  221.     });
  222. }
  225. function sendViaMicropub(postToSend) {
  226.     request.post(micropubConfig.endpoint, {
  227.         'auth': {
  228.             'bearer': micropubConfig.token
  229.         },
  230.         body: postToSend,
  231.         json: true
  232.     }, (err, data) => {
  233.         if (err != undefined) {
  234.             console.log(`ERROR: ${err}`);
  235.         }
  236.         if (data.statusCode !== 201 && data.statusCode !== 202) {
  237.             console.log("Play Micropub error");
  238.         } else {
  239.             console.log("Successfully created Micropub request");
  240.         }
  241.     });
  242. }
41.77 ℉☀️Frederick, Maryland
posted using quill.p3k.io
Please note: This site is in an active redesign. Some things might be a little off 🧐