@20syldev/api 2.9.0 → 3.2.0

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://api.sylvain.pro"><img src="https://api.sylvain.pro/favicon.ico" alt="Logo" width="25%" height="auto"/></a>
 
   # API Personnelle
-  [![Version](https://custom-icon-badges.demolab.com/badge/Version%20:-v2.9.0-6479ee?logo=api.sylvain.pro&labelColor=23272A)](https://github.com/20syldev/api/releases/latest)
+  [![Version](https://custom-icon-badges.demolab.com/badge/Version%20:-v3.2.0-6479ee?logo=api.sylvain.pro&labelColor=23272A)](https://github.com/20syldev/api/releases/latest)
 </div>
 
 ---
@@ -10,7 +10,7 @@
 ## À propos de l'API
 Voici mon API personnelle, disponible sur le domaine [api.sylvain.pro](https://api.sylvain.pro).
 L'API est développée avec Node.js et hébergée **24h/7j**. Elle est **simple d'utilisation** et a une **documentation** disponible sur [docs.sylvain.pro](https://docs.sylvain.pro) !
-> *Une limite de **1000** requêtes maximum chaque **10 secondes** est fixée.* 
+> *Une limite de **1000** requêtes maximum chaque **10 secondes** est fixée. Elle est baissé pour certains endpoints nécessitant plus de ressources.*
 
 ## Installer le paquet de l'API sur votre machine
 ```console
@@ -23,7 +23,7 @@ Pour utiliser le **paquet** dans votre projet, **créez** un fichier **JavaScrip
 require('@20syldev/api');
 ```
 
-Puis, **démarrez** un serveur [Node.js](http://nodejs.org) pour utiliser l'**API** :
+Puis, **démarrez** un serveur [Node.js](https://nodejs.org) pour utiliser l'**API** :
 ```console
 $ node index.js
 API is running on
@@ -44,7 +44,7 @@ Enfin, **exécutez** le script de build, qui installera les **dépendances** et
 $ npm run build
 ```
 ```console
-> @20syldev/api@2.9.0 build
+> @20syldev/api@3.2.0 build
 > npm install && node app.js
 
 [...]

package/app.js

@@ -1,10 +1,12 @@
-import { createCanvas } from 'canvas';
 import cors from 'cors';
 import dotenv from 'dotenv';
+import express from 'express';
+import fetch from 'node-fetch';
+import ical from 'ical.js';
+import { createCanvas } from 'canvas';
 import { randomBytes, getHashes, createHash } from 'crypto';
-import express, { urlencoded, json } from 'express';
+import { urlencoded, json } from 'express';
 import { factorial } from 'mathjs';
-import fetch from 'node-fetch';
 import { dirname, join } from 'path';
 import { toDataURL } from 'qrcode';
 import { fileURLToPath } from 'url';
@@ -15,13 +17,15 @@ const __dirname = dirname(__filename);
 const app = express();
 
 // Define allowed versions & endpoints for each version
-const versions = ['v1', 'v2'];
+const versions = ['v1', 'v2', 'v3'];
 const endpoints = {
     v1: ['algorithms', 'captcha', 'color', 'convert', 'domain', 'infos', 'personal', 'qrcode', 'token', 'username', 'website'],
-    v2: ['algorithms', 'captcha', 'chat', 'color', 'convert', 'domain', 'hash', 'infos', 'personal', 'qrcode', 'tic-tac-toe', 'token', 'username', 'website']
+    v2: ['algorithms', 'captcha', 'chat', 'color', 'convert', 'domain', 'hash', 'infos', 'personal', 'qrcode', 'tic-tac-toe', 'token', 'username', 'website'],
+    v3: ['algorithms', 'captcha', 'chat', 'color', 'convert', 'date', 'domain', 'hash', 'hyperplanning', 'infos', 'levenshtein', 'personal', 'qrcode', 'tic-tac-toe', 'time', 'token', 'username', 'website']
 };
 
-// Arrowed functions (math & random)
+// Arrowed functions (formatting, math & random)
+const formatDate = d => new Date(d.getTime() - d.getTimezoneOffset() * 60000).toISOString().replace('Z', '');
 const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
 const genID = () => {
     const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
@@ -35,7 +39,46 @@ const random = (arr) => arr[Math.floor(Math.random() * arr.length)];
 const logs = [], chat = [], privateChats = {}, sessions = {}, rateLimits = {}, games = {};
 
 // Define global variables
-let lastFetch = 0, requests = 0, resetTime = Date.now() + 10000;
+let contributions, lastFetch = 0, requests = 0, resetTime = Date.now() + 10000;
+
+// ----------- ----------- MAIN FUNCTIONS ----------- ----------- //
+
+/**
+ * Check the game result of a Tic-Tac-Toe game.
+ * 
+ * @param {Array} moves - The moves of the game.
+ * @returns {Object} - The result of the game.
+ */
+function checkGame(moves) {
+    let board = Array(3).fill().map(() => Array(3).fill(null));
+    let playerSymbols = {};
+    let playersOrder = [];
+
+    moves.forEach(({ username, move }) => {
+        if (!playerSymbols[username]) {
+            playersOrder.push(username);
+            playerSymbols[username] = playersOrder.length === 1 ? 'X' : 'O';
+        }
+        let [row, col] = move.split('-').map(Number);
+        board[row - 1][col - 1] = playerSymbols[username];
+    });
+
+    const checkWinner = (symbol) => {
+        for (let i = 0; i < 3; i++) {
+            if (board[i][0] === symbol && board[i][1] === symbol && board[i][2] === symbol) return true;
+            if (board[0][i] === symbol && board[1][i] === symbol && board[2][i] === symbol) return true;
+        }
+        if (board[0][0] === symbol && board[1][1] === symbol && board[2][2] === symbol) return true;
+        if (board[0][2] === symbol && board[1][1] === symbol && board[2][0] === symbol) return true;
+        return false;
+    };
+
+    let winner = Object.keys(playerSymbols).find(player => checkWinner(playerSymbols[player]));
+    let isTie = !winner && moves.length === 9;
+    let loser = winner && playersOrder.length === 2 ? playersOrder.find(player => player !== winner) : null;
+
+    return { winner, loser, tie: isTie };
+}
 
 // ----------- ----------- MIDDLEWARES SETUP ----------- ----------- //
 
@@ -93,7 +136,7 @@ app.use((req, res, next) => {
 // Internal Server Error
 app.use((err, req, res, next) => {
     console.error(err.stack);
-    res.status(500).json({
+    res.status(500).jsonResponse({
         message: 'Internal Server Error',
         error: err.message,
         documentation: 'https://docs.sylvain.pro',
@@ -148,7 +191,8 @@ app.get('/', (req, res) => {
         logs: 'https://api.sylvain.pro/logs',
         versions: { 
             v1: 'https://api.sylvain.pro/v1',
-            v2: 'https://api.sylvain.pro/v2'
+            v2: 'https://api.sylvain.pro/v2',
+            v3: 'https://api.sylvain.pro/v3'
         }
     });
 });
@@ -157,6 +201,7 @@ app.get('/', (req, res) => {
 app.get('/v1', (req, res) => {
     res.jsonResponse({
         version: 'v1',
+        documentation: 'https://docs.sylvain.pro/v1',
         endpoints: {
             get: {
                 algorithm: '/v1/algorithms?method={algorithm}&value={value}(&value2={value2})',
@@ -180,6 +225,7 @@ app.get('/v1', (req, res) => {
 app.get('/v2', (req, res) => {
     res.jsonResponse({
         version: 'v2',
+        documentation: 'https://docs.sylvain.pro/v2',
         endpoints: {
             get: {
                 algorithm: '/v2/algorithms?method={algorithm}&value={value}(&value2={value2})',
@@ -209,6 +255,43 @@ app.get('/v2', (req, res) => {
     });
 });
 
+// Display v3 endpoints
+app.get('/v3', (req, res) => {
+    res.jsonResponse({
+        version: 'v3',
+        documentation: 'https://docs.sylvain.pro/v3',
+        endpoints: {
+            get: {
+                algorithm: '/v3/algorithms?method={algorithm}&value={value}(&value2={value2})',
+                captcha: '/v3/captcha?text={text}',
+                chat: '/v3/chat',
+                color: '/v3/color',
+                convert: '/v3/convert?value={value}&from={unit}&to={unit}',
+                domain: '/v3/domain',
+                infos: '/v3/infos',
+                levenshtein: '/v3/levenshtein?str1={string}&str2={string}',
+                personal: '/v3/personal',
+                qrcode: '/v3/qrcode?url={URL}',
+                time: '/v3/time(?type={type}&start={timestamp}&end={timestamp}&format={format}&timezone={timezone})',
+                username: '/v3/username'
+            },
+            post: {
+                chat: {
+                    chat: '/v3/chat',
+                    private: '/v3/chat/private'
+                },
+                hash: '/v3/hash',
+                hyperplanning: '/v3/hyperplanning',
+                tic_tac_toe: {
+                    tic_tac_toe: '/v3/tic-tac-toe',
+                    fetch: '/v3/tic-tac-toe/fetch'
+                },
+                token: '/v3/token'
+            }
+        }
+    });
+});
+
 // Display logs
 app.get('/logs', (req, res) => res.jsonResponse(logs));
 
@@ -450,6 +533,11 @@ app.get('/:version/domain', (req, res) => {
     });
 });
 
+// GET planning error
+app.get('/:version/hyperplanning', (req, res) => {
+    res.jsonResponse({ error: 'This endpoint only supports POST requests.' });
+});
+
 // GET hash error
 app.get('/:version/hash', (req, res) => {
     res.jsonResponse({ error: 'This endpoint only supports POST requests.' });
@@ -466,6 +554,29 @@ app.get('/:version/infos', (req, res) => {
     });
 });
 
+// Calculate Levenshtein distance
+app.get('/:version/levenshtein', (req, res) => {
+    const { str1, str2 } = req.query;
+
+    if (!str1 || typeof str1 !== 'string') return res.jsonResponse({ error: 'Please provide a first string (?str1={string})' });
+    if (!str2 || typeof str2 !== 'string') return res.jsonResponse({ error: 'Please provide a second string (&str2={string})' });
+
+    if (str1.length > 1000) return res.jsonResponse({ error: 'First string exceeds 1000 characters.' });
+    if (str2.length > 1000) return res.jsonResponse({ error: 'Second string exceeds 1000 characters.' });
+
+    const lev = (a, b) => {
+        const m = Array.from({ length: a.length + 1 }, (_, i) => [i]);
+        for (let j = 0; j <= b.length; j++) m[0][j] = j;
+        for (let i = 1; i <= a.length; i++)
+            for (let j = 1; j <= b.length; j++)
+                m[i][j] = Math.min(m[i - 1][j] + 1, m[i][j - 1] + 1, m[i - 1][j - 1] + (a[i - 1] !== b[j - 1]));
+
+        return m[a.length][b.length];
+    };
+
+    res.jsonResponse({ str1, str2, distance: lev(str1, str2) });
+});
+
 // Generate personal data
 app.get('/:version/personal', (req, res) => {
     const people = [
@@ -600,6 +711,59 @@ app.get('/:version/tic-tac-toe/fetch', (req, res) => {
     res.jsonResponse({ error: 'This endpoint only supports POST requests.' });
 });
 
+// Display or generate time informations
+app.get('/:version/time', (req, res) => {
+    const { type = 'live', start, end, format, timezone } = req.query;
+
+    const validFormats = ['iso', 'utc', 'timestamp', 'locale', 'date', 'time', 'year', 'month', 'day', 'hour', 'minute', 'second', 'ms', 'dayOfWeek', 'dayOfYear', 'weekNumber', 'timezone', 'timezoneOffset'];
+    const validTimezones = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'];
+
+    if (type !== 'live' && type !== 'random') return res.jsonResponse({ error: 'Please provide a valid type (?type={type})' });
+    if (start && !Date.parse(start)) return res.jsonResponse({ error: 'Please provide a valid start date (?start={YYYY-MM-DD})' });
+    if (end && !Date.parse(end)) return res.jsonResponse({ error: 'Please provide a valid end date (?end={YYYY-MM-DD})' });
+    if (format && !validFormats.includes(format)) return res.jsonResponse({ error: 'Please provide a valid format (?format={format})' });
+    if (timezone && !validTimezones.includes(timezone)) return res.jsonResponse({ error: 'Please provide a valid timezone (?timezone={timezone})' });
+
+    const getTimeFormats = (date, timezoneOption) => {
+        return {
+            iso: date.toISOString(),
+            utc: date.toUTCString(),
+            timestamp: date.getTime(),
+            locale: date.toLocaleString('en-US', { timeZone: timezoneOption, timeZoneName: 'long' }),
+            date: date.toLocaleDateString('en-US', { timeZone: timezoneOption }),
+            time: date.toLocaleTimeString('en-US', { timeZone: timezoneOption }),
+            year: date.getFullYear(),
+            month: date.getMonth() + 1,
+            day: date.getDate(),
+            hour: date.getHours(),
+            minute: date.getMinutes(),
+            second: date.getSeconds(),
+            ms: date.getMilliseconds(),
+            dayOfWeek: date.getDay(),
+            dayOfYear: Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 86400000),
+            weekNumber: Math.ceil((((date - new Date(date.getFullYear(), 0, 0)) / 86400000) + 1) / 7),
+            timezone: timezoneOption,
+            timezoneOffset: date.getTimezoneOffset()
+        };
+    };
+
+    if (type === 'random') {
+        const startDate = new Date(start || '1900-01-01').getTime();
+        const endDate = new Date(end || '2100-12-31').getTime();
+        const randomDate = new Date(start ? startDate : startDate + Math.random() * (endDate - startDate));
+        const timezoneOption = timezone || validTimezones[Math.floor(Math.random() * 5)];
+        const formats = getTimeFormats(randomDate, timezoneOption);
+
+        return res.jsonResponse(format && formats[format] ? { date: formats[format] } : formats);
+    }
+
+    const now = new Date();
+    const timezoneOption = timezone || 'UTC';
+    const formats = getTimeFormats(now, timezoneOption);
+
+    res.jsonResponse(format && formats[format] ? { date: formats[format] } : formats);
+});
+
 // GET token error
 app.get('/:version/token', (req, res) => {
     res.jsonResponse({ error: 'This endpoint only supports POST requests.' });
@@ -684,6 +848,7 @@ app.get('/:version/website', async (req, res) => {
     res.jsonResponse({
         versions: {
             api: process.env.API,
+            cdn: process.env.CDN,
             coop_api: process.env.COOP_API,
             coop_status: process.env.COOP_STATUS,
             chat: process.env.CHAT,
@@ -696,6 +861,7 @@ app.get('/:version/website', async (req, res) => {
             gemsync: process.env.GEMSYNC,
             gitsite: process.env.GITSITE,
             logs: process.env.LOGS,
+            minify: process.env.MINIFY,
             morpion: process.env.MORPION,
             nitrogen: process.env.NITROGEN,
             old_database: process.env.OLD_DATABASE,
@@ -708,8 +874,9 @@ app.get('/:version/website', async (req, res) => {
             wrkit: process.env.WRKIT,
             zpki: process.env.ZPKI
         },
-        updated_projects: process.env.RECENT.split(' '),
-        new_projects: process.env.NEW.split(' '),
+        updated_projects: process.env.RECENT !== undefined ? process.env.RECENT.split(' ') : [],
+        new_projects: process.env.NEW !== undefined ? process.env.NEW.split(' ') : [],
+        sub_domains: process.env.DOMAINS !== undefined ? process.env.DOMAINS.split(' ') : [],
         stats: {
             os: process.env.STATS1,
             front: process.env.STATS2,
@@ -784,6 +951,49 @@ app.post('/:version/chat/private', (req, res) => {
     return res.jsonResponse({ error: 'Invalid or expired token.' });
 });
 
+// Display a planning from an ICS file
+app.post('/:version/hyperplanning', async (req, res) => {
+    const { url, detail } = req.body;
+
+    if (!url) res.jsonResponse({ error: 'Please provide a valid ICS file URL.' });
+
+    try {
+        const response = await fetch(url);
+        if (!response.ok || !(response.headers.get('content-type') || '').includes('text/calendar')) return res.jsonResponse({ error: 'Invalid ICS file format.' });
+
+        const events = new ical.Component(ical.parse(await response.text()))
+            .getAllSubcomponents('vevent')
+            .map(e => {
+                const evt = new ical.Event(e);
+                const summary = evt.summary.split(' ').filter(part => part !== '-');
+                const start = formatDate(evt.startDate.toJSDate());
+                const end = formatDate(evt.endDate.toJSDate());
+
+                if (detail === 'full') {
+                    const desc = evt.description.split('\n').map(l => l.trim());
+                    const extract = (p) => (desc.find(l => l.startsWith(p)) || '').replace(p, '').trim();
+
+                    return {
+                        summary,
+                        subject: extract('Matière :'),
+                        teacher: extract('Enseignant :'),
+                        classes: extract('Promotions :').split(', ').map(c => c.trim()),
+                        type: extract('Salle :') || undefined,
+                        start,
+                        end
+                    };
+                }
+                if (detail === 'list') return { summary, start, end };
+
+                return { summary: evt.summary, start, end };
+            })
+            .sort((a, b) => new Date(a.start) - new Date(b.start))
+            .filter(e => new Date(e.start) >= new Date());
+
+        res.jsonResponse(events);
+    } catch { res.jsonResponse({ error: 'Failed to parse ICS file.' }); }
+});
+
 // Store tic tac toe games
 app.post('/:version/tic-tac-toe', (req, res) => {
     const { username, move, session, game } = req.body;
@@ -811,15 +1021,21 @@ app.post('/:version/tic-tac-toe', (req, res) => {
     games[game] = games[game] || [];
 
     const players = [...new Set(games[game].map(play => play.username))];
-    if (players.length >= 2 && !players.includes(username)) {
-        return res.jsonResponse({ error: 'Game is full, you can only watch.' });
-    }
-
+    if (players.length >= 2 && !players.includes(username)) return res.jsonResponse({ error: 'Game is full, you can only watch.' });
     if (games[game].length > 0 && games[game][games[game].length - 1].username === username) return res.jsonResponse({ error: 'Please wait for the other player to make a move.' });
     if (games[game].some(play => play.move === move)) return res.jsonResponse({ error: 'Move already made. Please choose a different move.' });
 
     games[game].push(play);
-    setTimeout(() => { delete games[game]; }, 3600000);
+
+    const result = checkGame(games[game]);
+    if (result.winner || result.tie) {
+        setTimeout(() => delete games[game], 600000);
+        return res.jsonResponse({
+            message: `Move sent successfully. ${result.winner ? result.winner + ' wins. ' + result.loser + ' loses.' : 'It\'s a tie.'}`,
+            ...result
+        });
+    }
+    if (!result.winner && !result.tie) setTimeout(() => delete games[game], 3600000);
 
     sessions[u] = sessions[u] || { user: session, last: now };
     sessions[u].last = now;
@@ -847,10 +1063,13 @@ app.post('/:version/tic-tac-toe/fetch', (req, res) => {
 
     if (!games[ID]) games[ID] = [];
 
-    const data = games[ID], last = data.length ? data[data.length - 1].username : null;
-    const players = [...new Set(data.map(p => p.username))], turn = players.find(p => p !== last);
+    const data = games[ID];
+    const last = data.length ? data[data.length - 1].username : null;
+    const players = [...new Set(data.map(p => p.username))];
+    const turn = players.find(p => p !== last);
+    const result = data.length ? checkGame(data) : {};
 
-    res.jsonResponse({ game: data, turn, ID });
+    res.jsonResponse({ game: data, turn, ID, ...result });
 });
 
 // Generate hash

package/package.json

@@ -1,12 +1,14 @@
 {
-    "version": "2.9.0",
+    "version": "3.2.0",
     "name": "@20syldev/api",
     "description": "Node.js API with multiple features. Check the documentation at https://docs.sylvain.pro",
     "main": "app.js",
     "type": "module",
     "scripts": {
         "start": "node app.js",
+        "dev": "nodemon app.js",
         "build": "npm install && node app.js",
+        "lint": "prettier --write .",
         "upgrade:minor": "npm upgrade",
         "upgrade:major": "npx npm-check-updates -u && npm install",
         "upgrade:build": "npm upgrade && npm install && node app.js"
@@ -16,6 +18,7 @@
         "cors": "latest",
         "dotenv": "latest",
         "express": "latest",
+        "ical.js": "latest",
         "mathjs": "latest",
         "node-fetch": "latest",
         "prettier": "latest",