Added pads manager.

src/node/db/PadManager.ts

@@ -20,6 +20,7 @@
  */
 
 import {MapArrayType} from "../types/MapType";
+import {PadType} from "../types/PadType";
 
 const CustomError = require('../utils/customError');
 const Pad = require('../db/Pad');
@@ -105,7 +106,7 @@ const padList = new class {
  * @param {string} [authorId] - Optional author ID of the user that initiated the pad creation (if
  *     applicable).
  */
-exports.getPad = async (id: string, text: string|null, authorId:string = '') => {
+exports.getPad = async (id: string, text?: string|null, authorId:string|null = ''):Promise<PadType> => {
   // check if this is a valid padId
   if (!exports.isValidPadId(id)) {
     throw new CustomError(`${id} is not a valid padId`, 'apierror');
@@ -148,6 +149,9 @@ exports.listAllPads = async () => {
   return {padIDs};
 };
 
+
+
+
 // checks if a pad exists
 exports.doesPadExist = async (padId: string) => {
   const value = await db.get(`pad:${padId}`);

src/node/hooks/express/adminsettings.ts

@@ -1,10 +1,17 @@
 'use strict';
 
+
+import {PadQueryResult, PadSearchQuery} from "../../types/PadSearchQuery";
+import {PadType} from "../../types/PadType";
+
 const eejs = require('../../eejs');
 const fsp = require('fs').promises;
 const hooks = require('../../../static/js/pluginfw/hooks');
 const plugins = require('../../../static/js/pluginfw/plugins');
 const settings = require('../../utils/Settings');
+const UpdateCheck = require('../../utils/UpdateCheck');
+const padManager = require('../../db/PadManager');
+const api = require('../../db/API');
 
 exports.expressCreateServer = (hookName:string, {app}:any) => {
   app.get('/admin/settings', (req:any, res:any) => {
@@ -16,14 +23,15 @@ exports.expressCreateServer = (hookName:string, {app}:any) => {
   });
 };
 
+
+const queryPadLimit = 12;
+
+
 exports.socketio = (hookName:string, {io}:any) => {
   io.of('/settings').on('connection', (socket: any ) => {
-    console.log('Admin connected to /admin/settings')
     // @ts-ignore
     const {session: {user: {is_admin: isAdmin} = {}} = {}} = socket.conn.request;
-    console.log('isAdmin', isAdmin)
     if (!isAdmin) return;
-    console.log('Admin authenticated')
 
     socket.on('load', async (query:string):Promise<any> => {
       let data;
@@ -46,6 +54,155 @@ exports.socketio = (hookName:string, {io}:any) => {
       socket.emit('saveprogress', 'saved');
     });
 
+
+    socket.on('help', ()=> {
+      const gitCommit = settings.getGitCommit();
+      const epVersion = settings.getEpVersion();
+
+      const hooks:Map<string, Map<string,string>> = plugins.getHooks('hooks', false);
+      const clientHooks:Map<string, Map<string,string>> = plugins.getHooks('client_hooks', false);
+
+      function mapToObject(map: Map<string,any>) {
+        let obj = Object.create(null);
+        for (let [k,v] of map) {
+          if(v instanceof Map) {
+            obj[k] = mapToObject(v);
+          } else {
+            obj[k] = v;
+          }
+        }
+        return obj;
+      }
+
+      socket.emit('reply:help', {
+        gitCommit,
+        epVersion,
+        installedPlugins: plugins.getPlugins(),
+        installedParts: plugins.getParts(),
+        installedServerHooks: mapToObject(hooks),
+        installedClientHooks: mapToObject(clientHooks),
+        latestVersion: UpdateCheck.getLatestVersion(),
+      })
+    });
+
+
+    socket.on('padLoad', async (query: PadSearchQuery) => {
+      const {padIDs} = await padManager.listAllPads();
+
+      const data:{
+        total: number,
+        results?: PadQueryResult[]
+      } = {
+        total: padIDs.length,
+      };
+      let result: string[] = padIDs;
+      let maxResult;
+
+      // Filter out matches
+      if (query.pattern) {
+        result = result.filter((padName: string) => padName.includes(query.pattern));
+      }
+
+      data.total = result.length;
+
+      maxResult = result.length - 1;
+      if (maxResult < 0) {
+        maxResult = 0;
+      }
+
+      if (query.offset && query.offset < 0) {
+        query.offset = 0;
+      } else if (query.offset > maxResult) {
+        query.offset = maxResult;
+      }
+
+      if (query.limit && query.limit < 0) {
+        query.limit = 0;
+      } else if (query.limit > queryPadLimit) {
+        query.limit = queryPadLimit;
+      }
+
+      if (query.sortBy === 'padName') {
+        result = result.sort((a,b)=>{
+            if(a < b) return query.ascending ? -1 : 1;
+            if(a > b) return query.ascending ? 1 : -1;
+            return 0;
+        }).slice(query.offset, query.offset + query.limit);
+
+        data.results = await Promise.all(result.map(async (padName: string) => {
+            const pad = await padManager.getPad(padName);
+            const revisionNumber = pad.getHeadRevisionNumber()
+            const userCount = api.padUsersCount(padName).padUsersCount;
+            const lastEdited = await pad.getLastEdit();
+
+            return {
+              padName,
+              lastEdited,
+              userCount,
+              revisionNumber
+            }}));
+      } else {
+        const currentWinners: PadQueryResult[] = []
+        let queryOffsetCounter = 0
+        for (let res of result) {
+
+          const pad = await padManager.getPad(res);
+          const padType = {
+            padName: res,
+            lastEdited: await pad.getLastEdit(),
+            userCount: api.padUsersCount(res).padUsersCount,
+            revisionNumber: pad.getHeadRevisionNumber()
+          };
+
+          if (currentWinners.length < query.limit) {
+            if(queryOffsetCounter < query.offset){
+              queryOffsetCounter++
+              continue
+            }
+            currentWinners.push({
+              padName: res,
+              lastEdited: await pad.getLastEdit(),
+              userCount: api.padUsersCount(res).padUsersCount,
+              revisionNumber: pad.getHeadRevisionNumber()
+            })
+          } else {
+            // Kick out worst pad and replace by current pad
+            let worstPad = currentWinners.sort((a, b) => {
+                if (a[query.sortBy] < b[query.sortBy]) return query.ascending ? -1 : 1;
+                if (a[query.sortBy] > b[query.sortBy]) return query.ascending ? 1 : -1;
+                return 0;
+            })
+            if(worstPad[0]&&worstPad[0][query.sortBy] < padType[query.sortBy]){
+              if(queryOffsetCounter < query.offset){
+                queryOffsetCounter++
+                continue
+              }
+              currentWinners.splice(currentWinners.indexOf(worstPad[0]), 1)
+              currentWinners.push({
+                padName: res,
+                lastEdited: await pad.getLastEdit(),
+                userCount: api.padUsersCount(res).padUsersCount,
+                revisionNumber: pad.getHeadRevisionNumber()
+              })
+            }
+          }
+        }
+        data.results = currentWinners;
+      }
+
+        socket.emit('results:padLoad', data);
+    })
+
+
+    socket.on('deletePad', async (padId: string) => {
+      const padExists = await padManager.doesPadExists(padId);
+      if (padExists) {
+        const pad = await padManager.getPad(padId);
+        await pad.remove();
+        socket.emit('results:deletePad', padId);
+      }
+    })
+
     socket.on('restartServer', async () => {
       console.log('Admin request to restart server through a socket on /admin/settings');
       settings.reloadSettings();
@@ -55,3 +212,10 @@ exports.socketio = (hookName:string, {io}:any) => {
     });
   });
 };
+
+
+
+const searchPad = async (query:PadSearchQuery) => {
+
+}
+

src/node/types/PadSearchQuery.ts

@@ -0,0 +1,15 @@
+export type PadSearchQuery = {
+    pattern: string;
+    offset: number;
+    limit: number;
+    ascending: boolean;
+    sortBy: "padName" | "lastEdited" | "userCount" | "revisionNumber";
+}
+
+
+export type PadQueryResult = {
+    padName: string,
+    lastEdited: string,
+    userCount: number,
+    revisionNumber: number
+}

src/node/utils/UpdateCheck.ts

@@ -42,7 +42,7 @@ exports.getLatestVersion = () => {
   return infos?.latestVersion;
 };
 
-exports.needsUpdate = async (cb: Function) => {
+exports.needsUpdate = async (cb?: Function) => {
   await loadEtherpadInformations()
       .then((info:Infos) => {
     if (semver.gt(info.latestVersion, settings.getEpVersion())) {

src/static/js/pluginfw/plugins.js

@@ -9,7 +9,7 @@ const tsort = require('./tsort');
 const pluginUtils = require('./shared');
 const defs = require('./plugin_defs');
 const {manager} = require('./installer');
-const settings = require("../../../node/utils/Settings");
+const settings = require('../../../node/utils/Settings');
 
 const logger = log4js.getLogger('plugins');
 
@@ -28,10 +28,13 @@ exports.prefix = 'ep_';
 
 exports.formatPlugins = () => Object.keys(defs.plugins).join(', ');
 
+exports.getPlugins = () => Object.keys(defs.plugins);
+
 exports.formatParts = () => defs.parts.map((part) => part.full_name).join('\n');
 
-exports.formatHooks = (hookSetName, html) => {
-  let hooks = new Map();
+exports.getParts = () => defs.parts.map((part) => part.full_name);
+
+const sortHooks = (hookSetName, hooks) => {
   for (const [pluginName, def] of Object.entries(defs.plugins)) {
     for (const part of def.parts) {
       for (const [hookName, hookFnName] of Object.entries(part[hookSetName] || {})) {
@@ -49,6 +52,18 @@ exports.formatHooks = (hookSetName, html) => {
       }
     }
   }
+};
+
+
+exports.getHooks = (hookSetName) => {
+  const hooks = new Map();
+  sortHooks(hookSetName, hooks);
+  return hooks;
+};
+
+exports.formatHooks = (hookSetName, html) => {
+  let hooks = new Map();
+  sortHooks(hookSetName, hooks);
   const lines = [];
   const sortStringKeys = (a, b) => String(a[0]).localeCompare(b[0]);
   if (html) lines.push('<dl>');
@@ -107,8 +122,8 @@ exports.update = async () => {
 };
 
 exports.getPackages = async () => {
-  let plugins = manager.list()
-  let newDependencies = {}
+  const plugins = manager.list();
+  const newDependencies = {};
 
   for (const plugin of plugins) {
     if (!plugin.name.startsWith(exports.prefix)) {
@@ -116,7 +131,7 @@ exports.getPackages = async () => {
     }
     plugin.realPath = await fs.realpath(plugin.location);
     plugin.path = plugin.realPath;
-    newDependencies[plugin.name] = plugin
+    newDependencies[plugin.name] = plugin;
   }
 
   newDependencies['ep_etherpad-lite'] = {
@@ -124,7 +139,7 @@ exports.getPackages = async () => {
     version: settings.getEpVersion(),
     path: path.join(settings.root, 'node_modules/ep_etherpad-lite'),
     realPath: path.join(settings.root, 'src'),
-  }
+  };
 
   return newDependencies;
 };