Feat/admin react (#6211)

* Added vite react admin ui.

* Added react i18next.

* Added pads manager.

* Fixed docker build.

* Fixed windows build.

* Fixed installOnWindows script.

* Install only if path exists.

src/node/hooks/express/admin.ts

@@ -1,7 +1,9 @@
 'use strict';
 import {ArgsExpressType} from "../../types/ArgsExpressType";
+import path from "path";
+const settings = require('ep_etherpad-lite/node/utils/Settings');
 
-const eejs = require('../../eejs');
+const ADMIN_PATH = path.join(settings.root, 'src', 'templates', 'admin');
 
 /**
  * Add the admin navigation link
@@ -11,9 +13,19 @@ const eejs = require('../../eejs');
  * @return {*}
  */
 exports.expressCreateServer = (hookName:string, args: ArgsExpressType, cb:Function): any => {
-  args.app.get('/admin', (req:any, res:any) => {
-    if ('/' !== req.path[req.path.length - 1]) return res.redirect('./admin/');
-    res.send(eejs.require('ep_etherpad-lite/templates/admin/index.html', {req}));
-  });
+  args.app.get('/admin/*', (req:any, res:any, next:Function) => {
+      if (req.path.includes('.')) {
+        const relativPath = req.path.split('/admin/')[1];
+        res.sendFile(path.join(ADMIN_PATH, relativPath));
+      } else {
+        res.header('Cache-Control', 'private, no-cache, no-store, must-revalidate');
+        res.header('Expires', '-1');
+        res.header('Pragma', 'no-cache');
+        res.sendFile(path.join(ADMIN_PATH, 'index.html'));
+      }
+    });
+  args.app.get('/admin', (req:any, res:any, next:Function) => {
+      if ('/' !== req.path[req.path.length - 1]) return res.redirect('./admin/');
+  })
   return cb();
 };

src/node/hooks/express/adminplugins.ts

@@ -12,35 +12,7 @@ const installer = require('../../../static/js/pluginfw/installer');
 const pluginDefs = require('../../../static/js/pluginfw/plugin_defs');
 const plugins = require('../../../static/js/pluginfw/plugins');
 const semver = require('semver');
-const UpdateCheck = require('../../utils/UpdateCheck');
 
-exports.expressCreateServer = (hookName:string, args: ArgsExpressType, cb:Function) => {
-  args.app.get('/admin/plugins', (req:any, res:any) => {
-    res.send(eejs.require('ep_etherpad-lite/templates/admin/plugins.html', {
-      plugins: pluginDefs.plugins,
-      req,
-      errors: [],
-    }));
-  });
-
-  args.app.get('/admin/plugins/info', (req:any, res:any) => {
-    const gitCommit = settings.getGitCommit();
-    const epVersion = settings.getEpVersion();
-
-    res.send(eejs.require('ep_etherpad-lite/templates/admin/plugins-info.html', {
-      gitCommit,
-      epVersion,
-      installedPlugins: `<pre>${plugins.formatPlugins().replace(/, /g, '\n')}</pre>`,
-      installedParts: `<pre>${plugins.formatParts()}</pre>`,
-      installedServerHooks: `<div>${plugins.formatHooks('hooks', true)}</div>`,
-      installedClientHooks: `<div>${plugins.formatHooks('client_hooks', true)}</div>`,
-      latestVersion: UpdateCheck.getLatestVersion(),
-      req,
-    }));
-  });
-
-  return cb();
-};
 
 exports.socketio = (hookName:string, args:ArgsExpressType, cb:Function) => {
   const io = args.io.of('/pluginfw/installer');

src/node/hooks/express/adminsettings.ts

@@ -1,20 +1,21 @@
 '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');
+
+
+const queryPadLimit = 12;
 
-exports.expressCreateServer = (hookName:string, {app}:any) => {
-  app.get('/admin/settings', (req:any, res:any) => {
-    res.send(eejs.require('ep_etherpad-lite/templates/admin/settings.html', {
-      req,
-      settings: '',
-      errors: [],
-    }));
-  });
-};
 
 exports.socketio = (hookName:string, {io}:any) => {
   io.of('/settings').on('connection', (socket: any ) => {
@@ -38,10 +39,160 @@ exports.socketio = (hookName:string, {io}:any) => {
     });
 
     socket.on('saveSettings', async (newSettings:string) => {
+      console.log('Admin request to save settings through a socket on /admin/settings');
       await fsp.writeFile(settings.settingsFilename, newSettings);
       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();
@@ -51,3 +202,10 @@ exports.socketio = (hookName:string, {io}:any) => {
     });
   });
 };
+
+
+
+const searchPad = async (query:PadSearchQuery) => {
+
+}
+

src/node/hooks/express/socketio.ts

@@ -76,10 +76,12 @@ export const expressCreateServer = (hookName:string, args:ArgsExpressType, cb:Fu
     maxHttpBufferSize: settings.socketIo.maxHttpBufferSize,
   })
 
-  io.on('connection', (socket:any) => {
+
+  const handleConnection = (socket:Socket) => {
     sockets.add(socket);
     socketsEvents.emit('updated');
     // https://socket.io/docs/v3/faq/index.html
+    // @ts-ignore
     const session = socket.request.session;
     session.connections++;
     session.save();
@@ -87,15 +89,9 @@ export const expressCreateServer = (hookName:string, args:ArgsExpressType, cb:Fu
       sockets.delete(socket);
       socketsEvents.emit('updated');
     });
-  });
+  }
 
-  io.use(socketSessionMiddleware(args));
-
-  // Temporary workaround so all clients go through middleware and handle connection
-  io.of('/pluginfw/installer').use(socketSessionMiddleware(args))
-  io.of('/settings').use(socketSessionMiddleware(args))
-
-  io.use((socket:any, next:Function) => {
+  const renewSession = (socket:any, next:Function) => {
     socket.conn.on('packet', (packet:string) => {
       // Tell express-session that the session is still active. The session store can use these
       // touch events to defer automatic session cleanup, and if express-session is configured with
@@ -106,7 +102,24 @@ export const expressCreateServer = (hookName:string, args:ArgsExpressType, cb:Fu
       if (socket.request.session != null) socket.request.session.touch();
     });
     next();
-  });
+  }
+
+
+  io.on('connection', handleConnection);
+
+  io.use(socketSessionMiddleware(args));
+
+  // Temporary workaround so all clients go through middleware and handle connection
+  io.of('/pluginfw/installer')
+      .on('connection',handleConnection)
+      .use(socketSessionMiddleware(args))
+      .use(renewSession)
+  io.of('/settings')
+      .on('connection',handleConnection)
+      .use(socketSessionMiddleware(args))
+      .use(renewSession)
+
+  io.use(renewSession);
 
   // var socketIOLogger = log4js.getLogger("socket.io");
   // Debug logging now has to be set at an environment level, this is stupid.

src/node/hooks/express/webaccess.ts

@@ -50,7 +50,7 @@ exports.userCanModify = (padId: string, req: SocketClientRequest) => {
 exports.authnFailureDelayMs = 1000;
 
 const checkAccess = async (req:any, res:any, next: Function) => {
-  const requireAdmin = req.path.toLowerCase().startsWith('/admin');
+  const requireAdmin = req.path.toLowerCase().startsWith('/admin-auth');
 
   // ///////////////////////////////////////////////////////////////////////////////////////////////
   // Step 1: Check the preAuthorize hook for early permit/deny (permit is only allowed for non-admin
@@ -126,7 +126,13 @@ const checkAccess = async (req:any, res:any, next: Function) => {
   // completed, or maybe different credentials are required), go to the next step.
   // ///////////////////////////////////////////////////////////////////////////////////////////////
 
-  if (await authorize()) return next();
+  if (await authorize()) {
+    if(requireAdmin) {
+        res.status(200).send('Authorized')
+        return
+    }
+    return next();
+  }
 
   // ///////////////////////////////////////////////////////////////////////////////////////////////
   // Step 3: Authenticate the user. (Or, if already logged in, reauthenticate with different
@@ -163,7 +169,7 @@ const checkAccess = async (req:any, res:any, next: Function) => {
       if (await aCallFirst0('authnFailure', {req, res})) return;
       if (await aCallFirst0('authFailure', {req, res, next})) return;
       // No plugin handled the authentication failure. Fall back to basic authentication.
-      res.header('WWW-Authenticate', 'Basic realm="Protected Area"');
+      //res.header('WWW-Authenticate', 'Basic realm="Protected Area"');
       // Delay the error response for 1s to slow down brute force attacks.
       await new Promise((resolve) => setTimeout(resolve, exports.authnFailureDelayMs));
       res.status(401).send('Authentication Required');
@@ -188,7 +194,13 @@ const checkAccess = async (req:any, res:any, next: Function) => {
   // a login page).
   // ///////////////////////////////////////////////////////////////////////////////////////////////
 
-  if (await authorize()) return next();
+  const auth = await authorize()
+  if (auth && !requireAdmin) return next();
+  if(auth && requireAdmin) {
+    res.status(200).send('Authorized')
+    return
+  }
+
   if (await aCallFirst0('authzFailure', {req, res})) return;
   if (await aCallFirst0('authFailure', {req, res, next})) return;
   // No plugin handled the authorization failure.