@steedos/accounts 3.0.0-beta.9 → 3.0.0-beta.90

package/src/core/index.ts

@@ -1,226 +1,286 @@
-import { getSteedosConfig } from '@steedos/objectql'
-import { db } from '../db';
-import * as _ from 'lodash';
-import chalk from 'chalk';
-const clone = require('clone');
+import { getSteedosConfig } from "@steedos/objectql";
+import { db } from "../db";
+import * as _ from "lodash";
+import chalk from "chalk";
+const clone = require("clone");
 
 declare var MailQueue;
 declare var SMSQueue;
 
 const config = getSteedosConfig();
 
-export const getSettings = async ()=>{
-    let tenant = {
-        name: "Steedos",
-        logo_url: undefined,
-        background_url: undefined,
-        enable_create_tenant: true,
-        enable_register: true,
-        enable_forget_password: true,
-        enable_password_login: true,
-        enable_mobile_code_login: false,
-        enable_email_code_login: false,
-        enable_bind_mobile: false,
-        enable_bind_email: false,
-      }
+export const getSettings = async () => {
+  let tenant = {
+    name: "Steedos",
+    logo_url: undefined,
+    background_url: undefined,
+    enable_create_tenant: true,
+    enable_register: true,
+    enable_forget_password: true,
+    enable_password_login: true,
+    enable_mobile_code_login: false,
+    enable_email_code_login: false,
+    enable_bind_mobile: false,
+    enable_bind_email: false,
+  };
+
+  if (config.tenant) {
+    _.assignIn(tenant, config.tenant);
+  }
 
-      if (config.tenant) {
-          _.assignIn(tenant, config.tenant)
+  if (config.tenant && config.tenant._id) {
+    let spaceDoc = await db.findOne("spaces", config.tenant._id, {
+      fields: [
+        "name",
+        "avatar",
+        "avatar_dark",
+        "background",
+        "enable_register",
+      ],
+    });
+    let steedosService = getSteedosService();
+    if (steedosService && spaceDoc) {
+      _.assignIn(tenant, spaceDoc);
+      if (spaceDoc.avatar_dark) {
+        tenant.logo_url =
+          steedosService +
+          "api/v6/files/cfs.avatars.filerecord/" +
+          spaceDoc.avatar_dark;
+      } else if (spaceDoc.avatar) {
+        tenant.logo_url =
+          steedosService +
+          "api/v6/files/cfs.avatars.filerecord/" +
+          spaceDoc.avatar;
       }
-      
-      if (config.tenant && config.tenant._id) {
-        let spaceDoc = await db.findOne("spaces", config.tenant._id, {fields: ["name", "avatar", "avatar_dark", "background", "enable_register"]})
-        let steedosService = getSteedosService();
-        if (steedosService && spaceDoc) {
-            _.assignIn(tenant, spaceDoc);
-          if (spaceDoc.avatar_dark) {
-            tenant.logo_url = steedosService + "api/files/avatars/" + spaceDoc.avatar_dark
-          } else if (spaceDoc.avatar) {
-            tenant.logo_url = steedosService + "api/files/avatars/" + spaceDoc.avatar
-          } 
-          if (spaceDoc.background) {
-            tenant.background_url = steedosService + "api/files/avatars/" + spaceDoc.background
-          }
-        }
+      if (spaceDoc.background) {
+        tenant.background_url =
+          steedosService +
+          "api/v6/files/cfs.avatars.filerecord/" +
+          spaceDoc.background;
       }
+    }
+  }
 
-      const _tenant = clone(tenant);
+  const _tenant = clone(tenant);
 
-      delete _tenant['tokenSecret'];
-      delete _tenant['accessTokenExpiresIn']
-      delete _tenant['refreshTokenExpiresIn']
+  delete _tenant["tokenSecret"];
+  delete _tenant["accessTokenExpiresIn"];
+  delete _tenant["refreshTokenExpiresIn"];
 
-      return {
-        tenant: _tenant,
-        password: config.password?config.password:{},
-        root_url: process.env.ROOT_URL
-      }
-}
+  return {
+    tenant: _tenant,
+    password: config.password ? config.password : {},
+    root_url: process.env.ROOT_URL,
+  };
+};
 
-export const getTenant = async (spaceId)=>{
-    if (!spaceId){
-        return {};
-    }
-    
-    const spaceDoc = await db.findOne("spaces", spaceId, {fields: ["name", "avatar", "avatar_dark", "background", "enable_register"]})
+export const getTenant = async (spaceId) => {
+  if (!spaceId) {
+    return {};
+  }
 
-    if(!spaceDoc){
-      return {}
+  const spaceDoc = await db.findOne("spaces", spaceId, {
+    fields: ["name", "avatar", "avatar_dark", "background", "enable_register"],
+  });
+
+  if (!spaceDoc) {
+    return {};
+  }
+  let steedosService = getSteedosService();
+  if (steedosService) {
+    if (spaceDoc.avatar_dark) {
+      spaceDoc.logo_url =
+        steedosService +
+        "api/v6/files/cfs.avatars.filerecord/" +
+        spaceDoc.avatar_dark;
+    } else if (spaceDoc.avatar) {
+      spaceDoc.logo_url =
+        steedosService +
+        "api/v6/files/cfs.avatars.filerecord/" +
+        spaceDoc.avatar;
     }
-    let steedosService = getSteedosService();
-    if (steedosService) {
-      if (spaceDoc.avatar_dark) {
-        spaceDoc.logo_url = steedosService + "api/files/avatars/" + spaceDoc.avatar_dark
-      } else if (spaceDoc.avatar) {
-        spaceDoc.logo_url = steedosService + "api/files/avatars/" + spaceDoc.avatar
-      } 
-      if (spaceDoc.background) {
-        spaceDoc.background_url = steedosService + "api/files/avatars/" + spaceDoc.background
-      }
+    if (spaceDoc.background) {
+      spaceDoc.background_url =
+        steedosService +
+        "api/v6/files/cfs.avatars.filerecord/" +
+        spaceDoc.background;
     }
+  }
 
-    return spaceDoc;
-}
+  return spaceDoc;
+};
 
-export const spaceExists = async(spaceId)=>{
-  const spaceDoc = await db.findOne("spaces", spaceId, {fields: ["name", "avatar", "avatar_dark", "background", "enable_register"]})
-  if(spaceDoc){
+export const spaceExists = async (spaceId) => {
+  const spaceDoc = await db.findOne("spaces", spaceId, {
+    fields: ["name", "avatar", "avatar_dark", "background", "enable_register"],
+  });
+  if (spaceDoc) {
     return true;
   }
   return false;
-}
+};
 
-export const getMergedTenant = async (spaceId?)=>{
-    const settings: any = await getSettings();
-    const tenant: any = await getTenant(spaceId);
-    return Object.assign({}, settings.tenant, tenant);
-}
+export const getMergedTenant = async (spaceId?) => {
+  const settings: any = await getSettings();
+  const tenant: any = await getTenant(spaceId);
+  return Object.assign({}, settings.tenant, tenant);
+};
 
-export const canRegister = async (spaceId, action)=>{
-    const tenant: any = await getMergedTenant(spaceId);
-    if(action === 'emailSignupAccount' && !tenant.enable_email_code_login){
-      return false
-    }else if(action === 'mobileSignupAccount' && !tenant.enable_mobile_code_login){
-      return false
-    }else if(action === 'withPassword'){
-      return tenant.enable_register && tenant.enable_password_login && tenant.disabled_account_register != true
-    }
-    return tenant.enable_register && tenant.disabled_account_register != true;
-}
+export const canRegister = async (spaceId, action) => {
+  const tenant: any = await getMergedTenant(spaceId);
+  if (action === "emailSignupAccount" && !tenant.enable_email_code_login) {
+    return false;
+  } else if (
+    action === "mobileSignupAccount" &&
+    !tenant.enable_mobile_code_login
+  ) {
+    return false;
+  } else if (action === "withPassword") {
+    return (
+      tenant.enable_register &&
+      tenant.enable_password_login &&
+      tenant.disabled_account_register != true
+    );
+  }
+  return tenant.enable_register && tenant.disabled_account_register != true;
+};
 
-export const loginWithCode = async (spaceId)=>{
+export const loginWithCode = async (spaceId) => {
   let loginWithCode = false;
   const tenant: any = await getMergedTenant(spaceId);
-  if(tenant.enable_mobile_code_login || tenant.enable_email_code_login){
+  if (tenant.enable_mobile_code_login || tenant.enable_email_code_login) {
     loginWithCode = true;
   }
   return loginWithCode;
-}
+};
 
-export const canPasswordLogin = async ()=>{
+export const canPasswordLogin = async () => {
   const tenant: any = await getMergedTenant();
   return tenant.enable_password_login;
-}
+};
 
-function isEmpty(str){
-  if(!str){
+function isEmpty(str) {
+  if (!str) {
     return true;
   }
 
-  if(str === 'undefined'){
+  if (str === "undefined") {
     return true;
   }
 
-  if(_.isString(str) && str.startsWith("${")){
+  if (_.isString(str) && str.startsWith("${")) {
     return true;
   }
 
   return false;
 }
 
-export const canSendEmail = ()=>{
+export const canSendEmail = () => {
   const config = getSteedosConfig().email || {};
   let canSend = true;
   if (!config) {
     canSend = false;
-  }else if (isEmpty(config.from)) {
+  } else if (isEmpty(config.from)) {
     canSend = false;
-  }else if (isEmpty(config.url) && (isEmpty(config.host) || isEmpty(config.port) || isEmpty(config.username) || isEmpty(config.password))) {
+  } else if (
+    isEmpty(config.url) &&
+    (isEmpty(config.host) ||
+      isEmpty(config.port) ||
+      isEmpty(config.username) ||
+      isEmpty(config.password))
+  ) {
     canSend = false;
   }
   return canSend;
-}
+};
 
 //TODO twilio
-export const canSendSMS = ()=>{
+export const canSendSMS = () => {
   const config = (getSteedosConfig().sms || {}).qcloud || {};
   let canSend = true;
   if (!config) {
     canSend = false;
-  }else if (isEmpty(config.sdkappid) || isEmpty(config.appkey) || isEmpty(config.signname)) {
+  } else if (
+    isEmpty(config.sdkappid) ||
+    isEmpty(config.appkey) ||
+    isEmpty(config.signname)
+  ) {
     canSend = false;
   }
   return canSend;
-}
+};
 
 export const getRootUrlPathPrefix = (rootUrl) => {
   if (rootUrl) {
-      var parsedUrl = require('url').parse(rootUrl);
-      if (!parsedUrl.host || ['http:', 'https:'].indexOf(parsedUrl.protocol) === -1) {
-          throw Error("$ROOT_URL, if specified, must be an URL");
-      }
-      var pathPrefix = parsedUrl.pathname;
-      if (pathPrefix.slice(-1) === '/') {
-          pathPrefix = pathPrefix.slice(0, -1);
-      }
-      return pathPrefix;
+    var parsedUrl = require("url").parse(rootUrl);
+    if (
+      !parsedUrl.host ||
+      ["http:", "https:"].indexOf(parsedUrl.protocol) === -1
+    ) {
+      throw Error("$ROOT_URL, if specified, must be an URL");
+    }
+    var pathPrefix = parsedUrl.pathname;
+    if (pathPrefix.slice(-1) === "/") {
+      pathPrefix = pathPrefix.slice(0, -1);
+    }
+    return pathPrefix;
   } else {
-      return "";
+    return "";
   }
-}
+};
 
-export const getSteedosService = ()=>{
+export const getSteedosService = () => {
   let steedosService = getRootUrlPathPrefix(process.env.ROOT_URL);
   if (config.webservices && config.webservices.steedos) {
     if (!config.webservices.steedos.endsWith("/"))
-      config.webservices.steedos += "/"
+      config.webservices.steedos += "/";
     steedosService = config.webservices.steedos;
   }
-  if (!steedosService.endsWith("/"))
-    steedosService += "/" ;
+  if (!steedosService.endsWith("/")) steedosService += "/";
   return steedosService;
-}
+};
 
 export const sendMail = async (mail: any): Promise<void> => {
-  const {to, subject, html} = mail;
+  const { to, subject, html } = mail;
   const config = getSteedosConfig().email || {};
   let canSend = canSendEmail();
   //如果没有配置发送邮件服务，则打印log
-  console.log(chalk.green(`MAIL: ${to}, ${subject}`))
-  if(!canSend){
-      console.log(chalk.red("ERROR sending mail, please set email configs in steedos.config.js"));
-      return;
-  }else{
-      MailQueue.send({
-          to: to,
-          from: config.from || "华炎魔方",
-          subject: subject,
-          html: html
-      });
+  console.log(chalk.green(`MAIL: ${to}, ${subject}`));
+  if (!canSend) {
+    console.log(
+      chalk.red(
+        "ERROR sending mail, please set email configs in steedos.config.js",
+      ),
+    );
+    return;
+  } else {
+    MailQueue.send({
+      to: to,
+      from: config.from || "华炎魔方",
+      subject: subject,
+      html: html,
+    });
   }
 };
 
 export const sendSMS = async (sms: any): Promise<void> => {
-  const {mobile, message, spaceId} = sms;
+  const { mobile, message, spaceId } = sms;
   let canSend = canSendSMS();
-  console.log(chalk.green(`SMS: ${mobile}, ${message}`))
-  if(!canSend){
-      console.log(chalk.red("ERROR sending sms, Please set sms configs in steedos.config.js"))
-      return;
-  }else{
-      SMSQueue.send({
-          RecNum: mobile,
-          msg: message
-      }, spaceId)
+  console.log(chalk.green(`SMS: ${mobile}, ${message}`));
+  if (!canSend) {
+    console.log(
+      chalk.red(
+        "ERROR sending sms, Please set sms configs in steedos.config.js",
+      ),
+    );
+    return;
+  } else {
+    SMSQueue.send(
+      {
+        RecNum: mobile,
+        msg: message,
+      },
+      spaceId,
+    );
   }
-}
+};

package/src/rest-express/endpoints/logout.ts

@@ -3,80 +3,82 @@
  * @Date: 2022-03-28 09:35:34
  * @LastEditors: baozhoutao@steedos.com
  * @LastEditTime: 2024-01-23 14:24:35
- * @Description: 
+ * @Description:
  */
-import * as express from 'express';
-import { get, isEmpty, map } from 'lodash';
-import { AccountsServer } from '../../server';
-import { sendError } from '../utils/send-error';
-import { clearAuthCookies } from '../utils/steedos-auth';
-import { getObject } from '@steedos/objectql';
-import * as requestIp from 'request-ip';
-import { getUserAgent } from '../utils/get-user-agent';
-import isMobile from 'ismobilejs';
-import { getSteedosSchema } from '@steedos/objectql'
-export const logout = (accountsServer: AccountsServer) => async (
-  req: express.Request,
-  res: express.Response
-) => { 
-  
-  let authToken =
-    get(req.cookies, 'X-Auth-Token') ||
-    get(req.headers, 'Authorization') ||
-    get(req.headers, 'authorization');
+import * as express from "express";
+import { get, isEmpty, map } from "lodash";
+import { AccountsServer } from "../../server";
+import { sendError } from "../utils/send-error";
+import { clearAuthCookies } from "../utils/steedos-auth";
+import { getObject } from "@steedos/objectql";
+import * as requestIp from "request-ip";
+import { getUserAgent } from "../utils/get-user-agent";
+import isMobile from "ismobilejs";
+import { getSteedosSchema } from "@steedos/objectql";
+export const logout =
+  (accountsServer: AccountsServer) =>
+  async (req: express.Request, res: express.Response) => {
+    let authToken =
+      get(req.cookies, "X-Auth-Token") ||
+      get(req.headers, "Authorization") ||
+      get(req.headers, "authorization");
 
-  authToken = authToken && authToken.replace('Bearer ', 'token');
-  authToken = authToken && authToken.split(',').length >1?authToken.split(',')[0]:authToken;
+    authToken = authToken && authToken.replace("Bearer ", "token");
+    authToken =
+      authToken && authToken.split(",").length > 1
+        ? authToken.split(",")[0]
+        : authToken;
 
-  clearAuthCookies(req, res);
-  let session = null;
-  try {
-    session = await accountsServer.logout(authToken);
-  } catch (err) {
-    //sendError(res, err);
-  }finally{
-    let userAgent = getUserAgent(req) || '';
-    const ip = requestIp.getClientIp(req);
-    let status = 'success';
-    let message = '';
-    let is_phone = false;
-    let is_tablet = false;
-    if (userAgent) {
-      try {
-        const { phone, tablet } = isMobile(userAgent);
-        is_phone = phone;
-        is_tablet = tablet;
-      } catch (Exception) {
-        console.log(`Exception`, Exception);
+    clearAuthCookies(req, res);
+    let session = null;
+    try {
+      session = await accountsServer.logout(authToken);
+    } catch (err) {
+      //sendError(res, err);
+    } finally {
+      let userAgent = getUserAgent(req) || "";
+      const ip = requestIp.getClientIp(req);
+      let status = "success";
+      let message = "";
+      let is_phone = false;
+      let is_tablet = false;
+      if (userAgent) {
+        try {
+          const { phone, tablet } = isMobile(userAgent);
+          is_phone = phone;
+          is_tablet = tablet;
+        } catch (Exception) {
+          console.log(`Exception`, Exception);
+        }
       }
-    }
-    await getObject('operation_logs').insert({
-      name: '注销',
-      type: 'logout',
-      remote_user: session?.userId,
-      remote_addr: ip,
-      http_user_agent: userAgent,
-      is_mobile: is_phone,
-      is_tablet,
-      object: 'users',
-      status: status,
-      create: new Date(),
-      space: session?.space,
-      message: message,
-      data: JSON.stringify({
-        authToken: authToken,
-        session: session
-      }),
-      related_to: {
-        o: "users",
-        ids: [session?.userId]
+      await getObject("operation_logs").insert({
+        name: "注销",
+        type: "logout",
+        remote_user: session?.userId,
+        remote_addr: ip,
+        http_user_agent: userAgent,
+        is_mobile: is_phone,
+        is_tablet,
+        object: "users",
+        status: status,
+        create: new Date(),
+        space: session?.space,
+        message: message,
+        data: JSON.stringify({
+          authToken: authToken,
+          session: session,
+        }),
+        related_to: {
+          o: "users",
+          ids: [session?.userId],
+        },
+      });
+      if (authToken) {
+        const broker = getSteedosSchema().broker;
+        broker.broadcast("$user.logout", {
+          authToken: authToken,
+        });
       }
-    });
-
-    const broker = getSteedosSchema().broker;
-    broker.broadcast("$user.logout", {
-      authToken: authToken
-    });
-  }
-  res.json(null);
-};
+    }
+    res.json(null);
+  };