lupine.api 1.0.41

package/src/admin-api/admin-page.ts

@@ -0,0 +1,135 @@
+import { ServerResponse } from 'http';
+import { IApiBase, Logger, apiCache, ServerRequest, ApiRouter, ApiHelper } from 'lupine.api';
+
+const logger = new Logger('admin-page');
+export class AdminPage implements IApiBase {
+  protected router = new ApiRouter();
+  adminUser: any;
+
+  constructor() {
+    this.mountDashboard();
+  }
+
+  public getRouter(): ApiRouter {
+    return this.router;
+  }
+
+  protected mountDashboard() {
+    this.router.use('/list', this.list.bind(this));
+    this.router.use('/add', this.add.bind(this));
+    this.router.use('/save', this.save.bind(this));
+    this.router.use('/get/:id', this.getRecord.bind(this));
+    this.router.use('/delete/:id', this.delete.bind(this));
+  }
+
+  async list(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const result = await db.selectObject('$__s_page');
+    const response = {
+      status: Array.isArray(result) ? 'ok' : 'error',
+      message: 'Menu List.',
+      result: result,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async add(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const data = req.locals.json() as any;
+    delete data['id'];
+    const result = await db.insertObject('$__st_user', data);
+    const response = {
+      status: Array.isArray(result) ? 'ok' : 'error',
+      message: 'User List.',
+      result: result,
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async save(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const data = req.locals.json() as any;
+
+    const id = data['id'];
+    if (!data['idReadonly']) {
+      // save as
+      const result = await db.selectObject('$__s_page', ['menuid'], {
+        menuid: id,
+      });
+      if (result && result.length > 0) {
+        const response = {
+          status: 'ID_EXISTS',
+          message: `Menu id: ${id} exists`,
+        };
+        ApiHelper.sendJson(req, res, response);
+        return true;
+      }
+    }
+
+    await db.deleteObject('$__s_page', { menuid: id });
+    const result = await db.insertObject('$__s_page', {
+      menuid: id,
+      title: data['title'],
+      note: data['note'],
+      package: data['package'],
+      items: JSON.stringify(data['items']),
+      updateduserid: 1,
+      updatedstamp: new Date().toISOString(),
+    });
+    const response = {
+      status: 'ok',
+      result: result,
+      message: 'Menu Saved.',
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async getRecord(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const id = req.locals.urlParameters.get('id', '');
+
+    const response = {
+      status: 'error',
+      message: 'Get a menu item.',
+      result: {},
+    };
+    if (id) {
+      const result = await db.selectObject('$__s_page', undefined, {
+        menuid: id,
+      });
+      if (result && result.length > 0) {
+        response.result = {
+          menuid: result[0]['menuid'],
+          title: result[0]['title'],
+          note: result[0]['note'],
+          package: result[0]['package'],
+          items: JSON.parse(result[0]['items']),
+        };
+      }
+      response.status = 'ok';
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+
+  async delete(req: ServerRequest, res: ServerResponse) {
+    const db = apiCache.getDb();
+    const id = req.locals.urlParameters.get('id', '');
+
+    const response = {
+      status: 'ok',
+      message: 'Delete a page.',
+      result: null,
+    };
+    if (id) {
+      const result = await db.deleteObject('$__s_page', { menuid: id });
+      response.result = result;
+      response.status = 'ok';
+    }
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+}

package/src/admin-api/admin-performance.ts

@@ -0,0 +1,128 @@
+import cluster from 'cluster';
+import os, { userInfo } from 'os';
+import { ServerResponse } from 'http';
+import {
+  // Logger,
+  ServerRequest,
+  ApiHelper,
+  JsonObject,
+  formatBytes,
+  DateUtils,
+  getRequestCount,
+  ApiRouter,
+  IApiBase,
+  Logger,
+  AppCacheKeys,
+  AppCacheGlobal,
+  getAppCache,
+} from 'lupine.api';
+import { adminHelper } from './admin-helper';
+import { needDevAdminSession } from './admin-auth';
+
+// #https://github.com/sebhildebrandt/systeminformation
+export class AdminPerformance implements IApiBase {
+  private logger = new Logger('performance-api');
+  protected router = new ApiRouter();
+
+  constructor() {
+    this.mountDashboard();
+  }
+
+  public getRouter(): ApiRouter {
+    return this.router;
+  }
+
+  protected mountDashboard() {
+    // called by FE
+    this.router.use('/data', this.performanceData.bind(this));
+  }
+
+  async performanceData(req: ServerRequest, res: ServerResponse) {
+    const json = adminHelper.getDevAdminFromCookie(req, res, true);
+    if (!json) {
+      return false;
+    }
+    const response: JsonObject = {
+      status: 'ok',
+      results: {
+        appInfo: {
+          debug: getAppCache().get(AppCacheGlobal, AppCacheKeys.APP_DEBUG),
+          // apiVersion: getApiVersion(),
+          appStartTime: getAppCache().get(AppCacheGlobal, AppCacheKeys.START_TIME),
+          runningTime: DateUtils.diffString(new Date(), getAppCache().get(AppCacheGlobal, AppCacheKeys.START_TIME)),
+          // request info
+          // process info
+          inProcessingRequests: getRequestCount(),
+          isPrimary: cluster.isPrimary,
+          workerId: cluster.worker ? cluster.worker.id : 0,
+        },
+        totalmem: formatBytes(os.totalmem()),
+        freemem: formatBytes(os.freemem()),
+        memory: {
+          arrayBuffers: formatBytes(process.memoryUsage().arrayBuffers),
+          external: formatBytes(process.memoryUsage().external),
+          heapTotal: formatBytes(process.memoryUsage().heapTotal),
+          heapUsed: formatBytes(process.memoryUsage().heapUsed),
+          rss: formatBytes(process.memoryUsage().rss),
+        },
+        // diskLayout: os.versions(),
+        uptime: os.uptime(),
+        loadavg: os.loadavg(),
+        platform: os.platform(),
+        release: os.release(),
+        hostname: os.hostname(),
+        type: os.type(),
+        homedir: os.homedir(),
+        tmpdir: os.tmpdir(),
+        userInfo: {
+          username: userInfo().username,
+          uid: userInfo().uid,
+          gid: userInfo().gid,
+          shell: userInfo().shell,
+          homedir: userInfo().homedir,
+        },
+        machine: os.machine(),
+        // networkInterfaces: os.networkInterfaces(),
+        endianness: os.endianness(),
+        arch: os.arch(),
+        // cpuSystemUsage: process.cpuUsage().system,
+        // cpuUserUsage: process.cpuUsage().user,
+        availableMemory: process.availableMemory(),
+        constrainedMemory: process.constrainedMemory(),
+        resourceUsage: {
+          userCPUTime: process.resourceUsage().userCPUTime,
+          systemCPUTime: process.resourceUsage().systemCPUTime,
+          maxRSS: process.resourceUsage().maxRSS,
+          sharedMemorySize: process.resourceUsage().sharedMemorySize,
+          unsharedDataSize: process.resourceUsage().unsharedDataSize,
+          unsharedStackSize: process.resourceUsage().unsharedStackSize,
+          minorPageFault: process.resourceUsage().minorPageFault,
+          majorPageFault: process.resourceUsage().majorPageFault,
+          swappedOut: process.resourceUsage().swappedOut,
+          fsRead: process.resourceUsage().fsRead,
+          fsWrite: process.resourceUsage().fsWrite,
+          ipcSent: process.resourceUsage().ipcSent,
+          ipcReceived: process.resourceUsage().ipcReceived,
+          signalsCount: process.resourceUsage().signalsCount,
+          voluntaryContextSwitches: process.resourceUsage().voluntaryContextSwitches,
+          involuntaryContextSwitches: process.resourceUsage().involuntaryContextSwitches,
+        },
+        cpu: os.loadavg(),
+        cpuCount: os.cpus().length,
+        cpus: os.cpus().map((c) => ({
+          model: c.model,
+          speed: c.speed,
+          times: c.times,
+        })),
+        process: {
+          ...(process as any),
+          mainModule: undefined,
+          moduleLoadList: undefined,
+          config: undefined,
+        },
+      },
+    };
+    ApiHelper.sendJson(req, res, response);
+    return true;
+  }
+}