增加版本和文档对应接口

src/config.ts

@@ -27,7 +27,8 @@ export default {
   localDb: {
     dir: resolve(__dirname, '../db'),
     user: 'dbUser.json',
-    doc: 'dbDoc.json'
+    doc: 'dbDoc.json',
+    tag: 'dbTag.json'
   },
   secrestKey: 'liaomo'
 };

src/controllers/document.ts

@@ -1,42 +1,161 @@
 import { Context } from 'koa';
+import CODE from '@utils/code';
 import services from '../services';
 
 export interface InterfaceDocument {
   method: number
   title: string
   url: string
-  requestList: InterfaceRequestList[]
-}
+  tag: string
+  requestList?: InterfaceRequestList[]
+  responseSuccess?: string
+  responseError?: string
+  _id?: string,
+};
 interface InterfaceRequestList {
   title: string
   type: string
   require: boolean
   defaultValue?: string
   content?: string
+};
+
+export interface InterfacePage {
+  page: number
+  size: number
+};
+
+export interface InterfaceTag {
+  name: string
+  _id?: string
+}
+
+export interface InterfaceDocumentList {
+  _id: string
 }
 
-export const putDocument = async (ctx: Context) => {
+const putDocument = async (ctx: Context) => {
+  const { method, title, url, requestList = [], tag }: InterfaceDocument = ctx.request.body;
+  if (!method || !title || !url || !tag) {
+    ctx.status = 400;
+    ctx.body = ctx.$response(null, '必填项参数缺失', false, CODE.MISS_PARAMS);
+    return;
+  }
+  const errorRequestList = requestList.filter(el => (!el.title || !el.type));
+  if (errorRequestList.length) {
+    ctx.status = 400;
+    ctx.body = ctx.$response(null, '必填项参数缺失', false, CODE.MISS_PARAMS);
+    return;
+  };
+  const data = await services.document.putDocument(ctx, ctx.request.body);
+  ctx.body = ctx.$response(data.data, data.message, data.success, data.code);
+};
+
+const getDocument = async (ctx:Context) => {
+  const { id } = ctx.params;
+  if (!id) {
+    ctx.status = 400;
+    ctx.body = ctx.$response(null, '数据不存在', false, CODE.MISS_PARAMS);
+    return;
+  };
+  const data = await services.document.getDocument(ctx, id);
+  ctx.body = ctx.$response(data.data, data.message, data.success, data.code);
+};
+
+const getDocumentList = async (ctx:Context) => {
+  const { _id } = ctx.query;
+  const data = await services.document.getDocumentList(ctx, { _id });
+  ctx.body = ctx.$response(data.data, data.message, data.success, data.code);
+};
+
+const deleteDocument = async (ctx:Context) => {
+  const { id } = ctx.params;
+  if (!id) {
+    ctx.status = 400;
+    ctx.body = ctx.$response(null, '数据不存在', false, CODE.MISS_PARAMS);
+    return;
+  };
+  const data = await services.document.deleteDocument(ctx, id);
+  ctx.body = ctx.$response(data.data, data.message, data.success, data.code);
+};
+
+const updateDocument = async (ctx:Context) => {
+  const { id: _id } = ctx.params;
   const { method, title, url, requestList = [] }: InterfaceDocument = ctx.request.body;
+  if (!_id) {
+    ctx.status = 400;
+    ctx.body = ctx.$response(null, '数据不存在', false, CODE.MISS_PARAMS);
+    return;
+  };
+
   if (!method || !title || !url) {
     ctx.status = 400;
-    ctx.body = ctx.$response(null, '必填项参数缺失', false, 400000);
-    return
+    ctx.body = ctx.$response(null, '必填项参数缺失', false, CODE.MISS_PARAMS);
+    return;
   }
   const errorRequestList = requestList.filter(el => (!el.title || !el.type));
-  console.log(errorRequestList);
   if (errorRequestList.length) {
     ctx.status = 400;
-    ctx.body = ctx.$response(null, '必填项参数缺失', false, 400000);
-    return
+    ctx.body = ctx.$response(null, '必填项参数缺失', false, CODE.MISS_PARAMS);
+    return;
+  };
+  const data = await services.document.updateDocument(ctx, { _id, ...ctx.request.body });
+  ctx.body = ctx.$response(data.data, data.message, data.success, data.code);
+};
+
+const putTag = async (ctx:Context) => {
+  const { name }: InterfaceTag = ctx.request.body;
+  if (!name) {
+    ctx.status = 400;
+    ctx.body = ctx.$response(null, '必填项参数缺失', false, CODE.MISS_PARAMS);
+    return;
+  };
+  const data = await services.document.putTag(ctx, ctx.request.body);
+  ctx.body = ctx.$response(data.data, data.message, data.success, data.code);
+};
+
+const updateTag = async (ctx:Context) => {
+  const { id: _id } = ctx.params;
+  const { name }: InterfaceTag = ctx.request.body;
+  console.log(name, _id);
+  if (!name || !_id) {
+    ctx.status = 400;
+    ctx.body = ctx.$response(null, '必填项参数缺失', false, CODE.MISS_PARAMS);
+    return;
+  };
+  const data = await services.document.updateTag(ctx, { _id, ...ctx.request.body });
+  ctx.body = ctx.$response(data.data, data.message, data.success, data.code);
+};
+
+const getTagList = async (ctx:Context) => {
+  const { page, size } = ctx.query;
+  const params = {
+    page: page || 1,
+    size: size || 10
   }
-  const data = await services.document.putDocument(ctx, ctx.request.body)
-  ctx.body = ctx.$response(data.data, data.message, data.success, data.code)
+  const data = await services.document.getTagList(ctx, params);
+  ctx.body = ctx.$response(data.data, data.message, data.success, data.code);
 };
 
-// export const getDocument = async (ctx:Context) => {
-//   const { id } = ctx.query
-// }
+const deleteTag = async (ctx:Context) => {
+  const { id } = ctx.params;
+  if (!id) {
+    ctx.status = 400;
+    ctx.body = ctx.$response(null, '数据不存在', false, CODE.MISS_PARAMS);
+    return;
+  };
+  const data = await services.document.deleteTag(ctx, id);
+  ctx.body = ctx.$response(data.data, data.message, data.success, data.code);
+};
 
 export default {
-  putDocument
-}
+  putDocument,
+  getDocument,
+  getDocumentList,
+  deleteDocument,
+  updateDocument,
+  putTag,
+  updateTag,
+  getTagList,
+  deleteTag
+};

src/middlewares/localDb.ts

@@ -4,7 +4,8 @@ import config from '@config';
 
 export interface InterfaceDB {
   user: Nedb
-  doc: Nedb
+  doc: Nedb,
+  tag: Nedb
 };
 
 const { localDb } = config;
@@ -19,6 +20,10 @@ const db: InterfaceDB = {
   doc: new Nedb({
     filename: filename(localDb.doc),
     autoload: true
+  }),
+  tag: new Nedb({
+    filename: filename(localDb.tag),
+    autoload: true
   })
 };
 

src/router.ts

@@ -10,6 +10,14 @@ apiRouter.post('/login', controllers.user.login);
 apiRouter.get('/logout', controllers.user.logout);
 apiRouter.get('/user-info', controllers.user.userInfo);
 apiRouter.put('/document', controllers.document.putDocument);
+apiRouter.get('/document/:id', controllers.document.getDocument);
+apiRouter.get('/document', controllers.document.getDocumentList);
+apiRouter.delete('/document/:id', controllers.document.deleteDocument);
+apiRouter.post('/document/:id', controllers.document.updateDocument);
+apiRouter.put('/tag', controllers.document.putTag);
+apiRouter.post('/tag/:id', controllers.document.updateTag);
+apiRouter.get('/tag', controllers.document.getTagList);
+apiRouter.delete('/tag/:id', controllers.document.deleteTag);
 // 主路由
 const router = new Router<DefaultState, Context>();
 router.get('/', controllers.home);

src/services/document.ts

@@ -1,44 +1,350 @@
 import { Context } from 'koa';
 import { InterfaceResponseData } from '@utils/response';
-import { InterfaceDocument } from '@/controllers/document';
-import CODE from '@utils/code';
+import { InterfaceDocument, InterfacePage, InterfaceTag, InterfaceDocumentList } from '@/controllers/document';
+import { CODE, decipher, cipher, mapDocMethod } from '@/utils';
 
 const putDocument = async (ctx: Context, params: InterfaceDocument) :Promise<InterfaceResponseData> => {
+  const reData: InterfaceResponseData = {
+    data: null,
+    message: '',
+    success: false,
+    code: 400000
+  };
   return new Promise(resolve => {
-    const reData: InterfaceResponseData = {
-      data: null,
-      message: '',
-      success: false,
-      code: 400000
-    }
     ctx.$db.doc.findOne({ url: params.url }, (err, findDoc) => {
       if (err) {
-        ctx.$log.error(err)
-        ctx.status = 500
-        return
-      }
+        ctx.$log.error(err);
+        ctx.status = 500;
+        resolve(reData);
+        return;
+      };
       if (findDoc) {
-        reData.message = 'url已存在'
-        reData.code = CODE.EXIST_PARAMS
-        resolve(reData)
-        return
-      }
-      ctx.$db.doc.insert(params, (err, saveDoc) => {
+        reData.message = 'url已存在';
+        reData.code = CODE.EXIST_PARAMS;
+        resolve(reData);
+        return;
+      };
+      ctx.$db.tag.findOne({ _id: params.tag }, (err, findTag) => {
+        if (err) {
+          ctx.$log.error(err);
+          ctx.status = 500;
+          resolve(reData);
+          return;
+        };
+        if (!findTag) {
+          reData.message = '版本不存在';
+          reData.code = CODE.ERR_PARAMS;
+          resolve(reData);
+          return;
+        };
+        ctx.$db.doc.insert(params, (err, saveDoc) => {
+          if (err) {
+            ctx.$log.error(err);
+            ctx.status = 500;
+            resolve(reData);
+            return;
+          };
+          reData.data = saveDoc;
+          reData.message = '保存成功';
+          reData.success = true;
+          reData.code = CODE.SUCCESS;
+          resolve(reData);
+        });
+      });
+    });
+  });
+};
+
+const getDocument = async (ctx: Context, id: string) :Promise<InterfaceResponseData> => {
+  const decodeId = decipher(id);
+  const reData: InterfaceResponseData = {
+    data: null,
+    message: '',
+    success: false,
+    code: 400000
+  };
+  return new Promise(resolve => {
+    ctx.$db.doc.findOne({ _id: decodeId }, (err, findDoc) => {
+      if (err) {
+        ctx.$log.error(err);
+        ctx.status = 500;
+        resolve(reData);
+        return;
+      };
+      findDoc._id = id;
+      findDoc.method_des = mapDocMethod[findDoc.method];
+      reData.data = findDoc;
+      reData.message = '成功';
+      reData.success = true;
+      reData.code = CODE.SUCCESS;
+      resolve(reData);
+    });
+  });
+};
+
+const getDocumentList = async (ctx: Context, params: InterfaceDocumentList) :Promise<InterfaceResponseData> => {
+  const reData: InterfaceResponseData = {
+    data: null,
+    message: '',
+    success: false,
+    code: 400000
+  };
+  return new Promise(resolve => {
+    ctx.$db.doc.find({ tag: params._id }).sort({ url: 1 }).exec((err, docs) => {
+        if (err) {
+          ctx.$log.error(err);
+          ctx.status = 500;
+          resolve(reData);
+          return;
+        };
+        docs.forEach(el => {
+          el._id = cipher(el._id);
+          el.method_des = mapDocMethod[el.method];
+        });
+        reData.data = docs;
+        reData.message = '成功';
+        reData.success = true;
+        reData.code = CODE.SUCCESS;
+        ctx.$db.doc.count({}, (err, count) => {
+          if (err) {
+            ctx.$log.error(err);
+            ctx.status = 500;
+            resolve(reData);
+            return;
+          };
+          reData.data.total = count;
+          resolve(reData);
+        });
+    });
+  });
+};
+
+const deleteDocument = async (ctx: Context, id: string) :Promise<InterfaceResponseData> => {
+  const decodeId = decipher(id);
+  const reData: InterfaceResponseData = {
+    data: null,
+    message: '',
+    success: false,
+    code: 400000
+  };
+  return new Promise(resolve => {
+    ctx.$db.doc.remove({ _id: decodeId }, {}, (err) => {
+      if (err) {
+        ctx.$log.error(err);
+        ctx.status = 500;
+        resolve(reData);
+        return;
+      };
+      reData.data = null;
+      reData.message = '删除成功';
+      reData.success = true;
+      reData.code = CODE.SUCCESS;
+      resolve(reData);
+    });
+  });
+};
+
+const updateDocument = async (ctx:Context, { _id, tag, ...params }: InterfaceDocument) :Promise<InterfaceResponseData> => {
+  const decodeId = decipher(_id || '');
+  const reData: InterfaceResponseData = {
+    data: null,
+    message: '',
+    success: false,
+    code: 400000
+  };
+  return new Promise(resolve => {
+    ctx.$db.tag.findOne({ _id: tag }, (err, findTag) => {
+      if (err) {
+        ctx.$log.error(err);
+        ctx.status = 500;
+        resolve(reData);
+        return;
+      };
+      if (!findTag) {
+        reData.message = '版本不存在';
+        reData.code = CODE.ERR_PARAMS;
+        resolve(reData);
+        return;
+      };
+      ctx.$db.doc.update({ _id: decodeId }, { $set: { ...params }}, {}, err => {
         if (err) {
-          ctx.$log.error(err)
-          ctx.status = 500
-          return
+          ctx.$log.error(err);
+          ctx.status = 500;
+          resolve(reData);
+          return;
+        };
+          reData.data = null;
+          reData.message = '更新成功';
+          reData.success = true;
+          reData.code = CODE.SUCCESS;
+          resolve(reData);
+      });
+    });
+  });
+};
+
+const putTag = async (ctx:Context, params: InterfaceTag) :Promise<InterfaceResponseData> => {
+  const reData: InterfaceResponseData = {
+    data: null,
+    message: '',
+    success: false,
+    code: 400000
+  };
+  return new Promise(resolve => {
+    ctx.$db.tag.findOne({ name: params.name }, (err, findTag) => {
+      if (err) {
+        ctx.$log.error(err)
+        ctx.status = 500;
+        resolve(reData);
+        return;
+      };
+      if (findTag) {
+        reData.message = '版本已经存在';
+        reData.code = CODE.EXIST_PARAMS;
+        reData.success = false;
+        resolve(reData);
+        return;
+      };
+      ctx.$db.tag.insert(params, (err, saveTag) => {
+        if (err) {
+          ctx.$log.error(err);
+          ctx.status = 500;
+          resolve(reData);
+          return;
+        };
+        reData.data = saveTag;
+        reData.message = '保存成功';
+        reData.success = true;
+        reData.code = CODE.SUCCESS;
+        resolve(reData);
+      });
+    });
+  });
+};
+
+const updateTag = async (ctx:Context, { _id, ...params }: InterfaceTag) :Promise<InterfaceResponseData> => {
+  const reData: InterfaceResponseData = {
+    data: null,
+    message: '',
+    success: false,
+    code: 400000
+  };
+  return new Promise(resolve => {
+    ctx.$db.tag.findOne({ _id }, (err, findTag) => {
+      if (err) {
+        ctx.$log.error(err);
+        ctx.status = 500;
+        resolve(reData);
+        return;
+      };
+      if (!findTag) {
+        reData.message = '数据不存在';
+        reData.code = CODE.ERR_PARAMS;
+        reData.success = false;
+        resolve(reData);
+        return;
+      };
+      ctx.$db.tag.findOne({ name: params.name }, (err, findTagName) => {
+        if (err) {
+          ctx.$log.error(err);
+          ctx.status = 500;
+          resolve(reData);
+          return;
+        }
+        if (findTagName) {
+          reData.message = '版本已经存在';
+          reData.code = CODE.EXIST_PARAMS;
+          reData.success = false;
+          resolve(reData);
+          return;
         }
-        reData.data = saveDoc;
-        reData.message = '保存成功'
-        reData.success = true
-        reData.code = CODE.SUCCESS
-        resolve(reData)
+        ctx.$db.tag.update({ _id }, { $set: { ...params }}, {}, err => {
+          if (err) {
+            ctx.$log.error(err);
+            ctx.status = 500;
+            resolve(reData);
+            return;
+          };
+          reData.message = '保存成功';
+          reData.success = true;
+          reData.code = CODE.SUCCESS;
+          resolve(reData);
+        });
       })
-    })
-  })
+
+    });
+  });
+};
+
+const getTagList = async (ctx: Context, params: InterfacePage) :Promise<InterfaceResponseData> => {
+  const reData: InterfaceResponseData = {
+    data: null,
+    message: '',
+    success: false,
+    code: 400000
+  };
+  return new Promise(resolve => {
+    ctx.$db.tag.find({}).sort({ url: 1 }).skip((params.page - 1) * params.size).limit(params.size).exec((err, tags) => {
+        if (err) {
+          ctx.$log.error(err);
+          ctx.status = 500;
+          resolve(reData);
+          return;
+        };
+        reData.data = {
+          list: tags,
+          page: params.page,
+          size: params.size
+        };
+        reData.message = '成功';
+        reData.success = true;
+        reData.code = CODE.SUCCESS;
+        ctx.$db.tag.count({}, (err, count) => {
+          if (err) {
+            ctx.$log.error(err);
+            ctx.status = 500;
+            resolve(reData);
+            return;
+          };
+          reData.data.total = count;
+          resolve(reData);
+        });
+    });
+  });
+};
+
+const deleteTag = async (ctx: Context, id: string) :Promise<InterfaceResponseData> => {
+  const reData: InterfaceResponseData = {
+    data: null,
+    message: '',
+    success: false,
+    code: 400000
+  };
+  return new Promise(resolve => {
+    ctx.$db.tag.remove({ _id: id }, {}, (err) => {
+      if (err) {
+        ctx.$log.error(err);
+        ctx.status = 500;
+        resolve(reData);
+        return;
+      };
+      reData.data = null;
+      reData.message = '删除成功';
+      reData.success = true;
+      reData.code = CODE.SUCCESS;
+      resolve(reData);
+    });
+  });
 };
 
 export default {
-  putDocument
+  putDocument,
+  getDocument,
+  getDocumentList,
+  deleteDocument,
+  updateDocument,
+  putTag,
+  updateTag,
+  getTagList,
+  deleteTag
 }

src/services/user.ts

@@ -15,6 +15,7 @@ const register = async (ctx: Context, params: InterfaceRegisterParams) :Promise<
       if (err) {
         ctx.$log.error(err)
         ctx.status = 500
+        resolve(reData);
         return
       }
       if (findUser) {
@@ -27,6 +28,7 @@ const register = async (ctx: Context, params: InterfaceRegisterParams) :Promise<
         if (err) {
           ctx.$log.error(err)
           ctx.status = 500
+          resolve(reData);
           return
         }
         reData.data = saveUser;
@@ -52,8 +54,9 @@ const login = async (ctx: Context, params: InterfaceRegisterParams) :Promise<Int
   return new Promise(resolve => {
     ctx.$db.user.findOne({ username: params.username }, (err, findUser) => {
       if (err) {
-        ctx.$log.error(err)
-        ctx.status = 500
+        ctx.$log.error(err);
+        ctx.status = 500;
+        resolve(reData);
         return
       }
       if (!findUser) {

src/typings/index.d.ts

@@ -1,7 +1,7 @@
 import { Application, Context, DefaultContext } from 'koa';
 import { IMiddleware } from 'koa-router';
 import { RedisClient } from 'redis';
-import response from '@utils/response';
+import { responseHandle } from '@utils/response';
 import { InterfaceDB } from '../middlewares/localDb';
 
 interface interfaceRedis {
@@ -25,7 +25,7 @@ interface interfaceLog {
 declare module 'koa' {
   export interface Context extends DefaultContext {
     $redis: interfaceRedis
-    $response: response
+    $response: responseHandle
     $log: interfaceLog
     $db: InterfaceDB
   }

src/utils/cipher.ts

@@ -4,7 +4,7 @@ import config from '@config';
 const algorithm = 'aes-192-cbc';
 const salt = '123';
 const key = scryptSync(config.secrestKey, salt, 24);
-const iv = Buffer.alloc(16, '11')
+const iv = Buffer.alloc(16, '11');
 
 export const cipher = (data: string) => {
   const cipher = createCipheriv(algorithm, key, iv);
@@ -17,5 +17,5 @@ export const decipher = (data: string) => {
   const decipher = createDecipheriv(algorithm, key, iv);
   let dec = decipher.update(data, 'hex', 'utf8');
   dec += decipher.final('utf8');
-  return dec
-}
+  return dec;
+};

src/utils/code.ts

@@ -1,9 +1,11 @@
-const CODE = {
+
+export const CODE = {
   SUCCESS: 200, // 成功
   NOT_LOGIN: 400001, // 未登录
   LOGINING: 400002, // 已登录
   MISS_PARAMS: 400400, //参数缺失
   EXIST_PARAMS: 400401, // 唯一参数已存在
   ERR_PARAMS: 400402 //参数错误
-}
+};
+
 export default CODE;

src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './code';
+export * from './mapping';
+export * from './cipher';
+export * from './observer';

src/utils/observer.ts

@@ -64,4 +64,6 @@ class Observer {
   };
 };
 
-export default new Observer();
+export const observer = new Observer();
+
+export default observer;

src/utils/response.ts

@@ -6,7 +6,7 @@ export interface InterfaceResponseData {
   code?: number
 }
 export interface responseHandle {
-  (responseData): { data: any, message: string, success: boolean, code: number }
+  (...InterfaceResponseData): { data: any, message: string, success: boolean, code: number }
 }
 
 const responseHandle: responseHandle = (data, message = 'success', success = true, code = CODE.SUCCESS) => {