☰

KIIT-Connect Unlocker

Unlock kiitconnect for free

  1. // ==UserScript==
  2. // @name         KIIT-Connect Unlocker
  3. // @namespace    https://github.com/rohitaryal/kiitconnect-unlocker
  4. // @version      3.0
  5. // @description  Unlock kiitconnect for free
  6. // @author       rohitaryal
  7. // @match        https://www.kiitconnect.com/academic/*
  8. // @icon         https://www.google.com/s2/favicons?sz=64&domain=kiitconnect.com
  9. // @grant        none
  10. // @license      MIT
  11. // ==/UserScript==
  12.  
  13. const debugMode = true;
  14.  
  15. const driveFile = "https://drive.google.com/file/d/";
  16. const driveFolder = "https://drive.google.com/drive/folders/";
  17. const youtubePlaylist = "https://www.kiitconnect.com/player?playlistId=";
  18.  
  19. const pyqsRegex = /academic\/PYQS\/Content\/PYQS\-(cse|csse|csce|it)\-[1-7]/;
  20. const notesRegex = /academic\/PYQS\/Content\/Notes\-(cse|csse|csce|it)\-[1-7]/;
  21.  
  22. class Utils {
  23.   constructor() { }
  24.   /*
  25.    * Get all script that doesn't have src attribute
  26.    */
  27.   static getScripts() {
  28.     let scriptElements = document.querySelectorAll("script:not([src])");
  29.     return [...scriptElements];
  30.   }
  31.  
  32.   /*
  33.    * Copy item to clipboard
  34.    */
  35.   static copy(text) {
  36.     document.body.focus();
  37.     navigator.clipboard.writeText(text);
  38.   }
  39.  
  40.   /*
  41.    * Logger for debug mode
  42.    */
  43.   static log(text) {
  44.     if (debugMode) {
  45.       console.log(text)
  46.     }
  47.   }
  48.  
  49.   /*
  50.    * Clone node and remove its junk and replace with new one
  51.    */
  52.   static replaceNode(node) {
  53.     if (!node) {
  54.       throw new Error("Invalid node provided to clone");
  55.     }
  56.  
  57.     const newNode = node.cloneNode(true);
  58.     node.replaceWith(newNode);
  59.  
  60.     return newNode;
  61.   }
  62.  
  63.   /*
  64.    * Re-Serialize the json in our own way (For PYQS)
  65.    */
  66.   static parsePYQ(data) {
  67.     if (typeof data !== 'object') {
  68.       throw new Error(`Expected 'object' but obtained '${typeof data}' while parsing`);
  69.     }
  70.  
  71.     // Skeleton for subjects pyq, syllabus + some extra detail holder
  72.     let pyqDetails = {
  73.       semester: data.semeseter, // Yes, thats the actual spelling
  74.       branch: data.stream,
  75.       subjects: [],
  76.     };
  77.  
  78.     pyqDetails.subjects = data.data.semesters[0].subjects.map((subject) => {
  79.       // Skeleton for subject detail holder
  80.       let subDetails = {
  81.         subjectName: subject.name,
  82.         subjectCode: subject.SUBCODE,
  83.         folder: driveFolder + subject.folderId, // Makes an accessable drive folder link
  84.         subjectSyllabus: driveFile + subject.syllabus, // Makes an accessable drive file link
  85.         playlist: [],
  86.         papers: [],
  87.       };
  88.  
  89.       // Parse individual playlist
  90.       subDetails.playlist = subject.youtubePlaylist.map((playlist) => {
  91.         return {
  92.           id: playlist.id,
  93.           title: playlist.title,
  94.           videoCount: playlist.noOfVides,
  95.           videoLink: `${youtubePlaylist}id&playlist=${playlist.title}`
  96.         };
  97.       });
  98.  
  99.       // Parse individual pyqs
  100.       subDetails.papers = subject.pyqs.map((paper) => {
  101.         return {
  102.           name: paper.name,
  103.           year: Number(paper.year) || 0,
  104.           solution: driveFile + paper.solution, // Makes an accessable file link
  105.           question: driveFile + paper.Question, // Same
  106.         }
  107.       });
  108.  
  109.       // Sort papers based on years
  110.       subDetails.papers = subDetails.papers.sort((a, b) => a.year - b.year);
  111.  
  112.       return subDetails;
  113.     });
  114.  
  115.     return pyqDetails;
  116.   }
  117.  
  118.   /*
  119.    * Re-Serialize the json in our own way (For Notes)
  120.    */
  121.   static parseNotes(data) {
  122.  
  123.   }
  124.  
  125.   /*
  126.    * Parse script content (For PYQS)
  127.    */
  128.   static parseFromScriptPYQ(scriptContent) {
  129.     // Pre-process and beautufy
  130.     scriptContent = scriptContent.replaceAll(`\\"`, `"`);
  131.     scriptContent = scriptContent.replaceAll(`\\n`, ``);
  132.  
  133.     const parsableContent = scriptContent.slice(
  134.       scriptContent.indexOf(`self.__next_f.push([1,"1e:`) + 26, // <-- 26 is the length of this
  135.       scriptContent.lastIndexOf(`"])`)                          //     string itself.
  136.     );
  137.  
  138.     const jsonContent = JSON.parse(parsableContent)[3].children[3];
  139.  
  140.     return this.parsePYQ(jsonContent);
  141.   }
  142.  
  143.   /*
  144.    * Parse script content (For Notes)
  145.    */
  146.   static parseFromScriptNotes(scriptContent) {
  147.  
  148.   }
  149.  
  150.   /*
  151.    * Replace pyq table + headings with from our own serialized form
  152.    */
  153.   static rewritePYQPage(subjectArray) {
  154.     if (typeof subjectArray !== 'object') {
  155.       throw new Error(`Expected 'object' but obtained '${typeof subjectArray}' while rewriting`);
  156.     }
  157.  
  158.     // After successful injection head will contain this classlist
  159.     // which is an indicator to stop further injection
  160.     if(document.head.classList.contains("injected")) {
  161.       return;
  162.     }
  163.  
  164.     Utils.log("Re-writing the pyq page.")
  165.  
  166.     const parentContainer = [...document.querySelector("main div div").childNodes].slice(1);
  167.     
  168.     for (let i = 0; i < parentContainer.length; i++) {
  169.       let totalRows = parentContainer[i].querySelectorAll("table tbody").length; // Get count of rows
  170.       for (let j = 0; j < subjectArray.length; j++) {
  171.           let totalPapers = subjectArray[j].papers.length;
  172.   
  173.           if (totalRows === totalPapers) {
  174.               let temp = subjectArray[j];
  175.               subjectArray[j] = subjectArray[i];
  176.               subjectArray[i] = temp;
  177.               break;
  178.           }
  179.       }
  180.   }
  181.   
  182.  
  183.     for (let i = 0; i < subjectArray.length; i++) {
  184.       const subject = subjectArray[i];
  185.       const parent = parentContainer[i];
  186.       const [titleDiv, tableContainer] = parent.childNodes;
  187.  
  188.       const syllabusButton = titleDiv.querySelector("a");
  189.       syllabusButton.href = subject.subjectSyllabus;
  190.  
  191.       // New button with folder link
  192.       const folderButton = syllabusButton.cloneNode(true);
  193.       folderButton.innerText = "Open Folder";
  194.       folderButton.href = subject.folder;
  195.  
  196.       
  197.       // Modify title (middle one is TEXT_NODE)
  198.       const title = titleDiv.childNodes[1];
  199.       title.textContent = subject.subjectName;
  200.       
  201.       // Modify the table
  202.       const tableRows = tableContainer.querySelectorAll("table tbody");
  203.  
  204.       for (let j = 0; j < tableRows.length; j++) {
  205.         const row = tableRows[j];
  206.         const paper = subject.papers[j];
  207.  
  208.         const td = row.querySelectorAll("td:not(.hidden)");
  209.  
  210.         // Year of paper
  211.         td[0].textContent = paper.year;
  212.  
  213.         // Link to question paper
  214.         let paperAnchor = td[1].querySelector("a");
  215.         paperAnchor = this.replaceNode(paperAnchor);
  216.  
  217.         paperAnchor.textContent = paper.name;
  218.         paperAnchor.href = paper.question;
  219.         paperAnchor.classList.add("text-cyan-500");
  220.         paperAnchor.classList.remove("text-yellow-500", "cursor-not-allowed");
  221.  
  222.         // Link to solution paper
  223.         let solutionAnchor = td[2].querySelector("a");
  224.  
  225.         // Since solution is the last element
  226.         if(!solutionAnchor)
  227.           continue;
  228.  
  229.         solutionAnchor = this.replaceNode(solutionAnchor);
  230.  
  231.         if (solutionAnchor.classList.contains("text-gray-400")) {
  232.           solutionAnchor.textContent = "Not Available";
  233.         } else {
  234.           solutionAnchor.classList.add("text-cyan-500");
  235.           solutionAnchor.classList.remove("text-yellow-500", "cursor-not-allowed");
  236.  
  237.           solutionAnchor.href = paper.solution
  238.         }
  239.       }
  240.     }
  241.  
  242.     // Mark as succrssful injection
  243.     document.head.classList.add("injected");
  244.   }
  245. }
  246.  
  247. (function () {
  248.   'use strict';
  249.   // Last script will always contain the paper's JSON
  250.   let scriptContent = Utils.getScripts().at(-1).textContent;
  251.  
  252.  
  253.   if (!!location.pathname.match(pyqsRegex)) { // Means we are in 'pyqs' page
  254.     const parsedContent = Utils.parseFromScriptPYQ(scriptContent);
  255.  
  256.     window.addEventListener('load', function () {
  257.       Utils.log("DOMContent has been loaded");
  258.       this.setInterval(function () {
  259.         try {
  260.           Utils.rewritePYQPage(parsedContent.subjects);
  261.         } catch(e) {
  262.           console.log(e)
  263.         }
  264.       }, 2000)
  265.     });
  266.  
  267.   } else if (!!location.pathname.match(notesRegex)) { // Means we are in 'notes' page
  268.  
  269.   }
  270. })();