pull request to fileupload

.gitignore

@@ -7,4 +7,6 @@ node_modules
 app_log
 database
 package-lock.json
-.nyc_output
+.nyc_output
+data/*
+test/devtest

base/base_dao.js

@@ -12,21 +12,21 @@ class BaseDao extends BaseClass {
     /**
      * MySql建表方法
      */
-    async createTable() {
+    async createTable(tableName) {
         try {
             if (db_config.db_type === "mysql") {
-                let drop = `DROP TABLE IF EXISTS ${this.table}`;
+                let drop = `DROP TABLE IF EXISTS ${tableName}`;
                 await mysql.query(drop, [], this.instance);
-                let filepath = path.join(__dirname, "../dao/mysql/sql", this.table + ".sql");
+                let filepath = path.join(__dirname, "../dao/mysql/sql", tableName + ".sql");
                 let sql = fs.readFileSync(filepath).toString();
-                sql = sql.replace("{table}", this.table);
+                sql = sql.replace("{table}", tableName);
                 let args = [];
                 let rows = await mysql.query(sql, args, this.instance);
                 this.logger.debug(`database exec success|sql=${sql}|args=${JSON.stringify(args)}|ret=${JSON.stringify(rows)}`);
                 return rows;
             }
         } catch (err) {
-            this.logger.error(`createTable Error|tableName=${this.table}|err=${err.message}`);
+            this.logger.error(`createTable Error|tableName=${tableName}|err=${err.message}`);
         }
     }
 }

config/index.js

@@ -32,7 +32,7 @@ async function init() {
                 }
             },
             db_config: {
-                db_type: "mysql",
+                db_type: "rocksdb",
                 db_user: {
                     user: "user_test",
                     password: (new Buffer("SEBBaDBJZzk=", "base64").toString()),
@@ -44,8 +44,9 @@ async function init() {
             },
         };
         return;
+    }else{
+        await configLoader.add("app_config.hjson");
     }
-    await configLoader.add("app_config.hjson");
     await configLoader.add("db_config.hjson");
 }
 module.exports = {

dao/index.js

@@ -12,15 +12,16 @@ let loadDao = async (type) => {
         daoMap[daoName] = dao;
     });
 };
-
-
-if (db_config.db_type === "mongo") {
-    loadDao("mongo");
-}
-
-if (db_config.db_type === "mysql") {
-    loadDao("mysql");
+function init() {
+    if (!db_config || db_config.db_type === "rocksdb") {
+        loadDao("rocksdb");
+    } else if (db_config.db_type === "mongo") {
+        loadDao("mongo");
+    } else if (db_config.db_type === "mysql") {
+        loadDao("mysql");
+    }
 }
+init();
 
 let getDao = (daoName) => {
     if (daoMap[daoName]) {
@@ -29,4 +30,5 @@ let getDao = (daoName) => {
         throw new Error("dao not found! daoname:" + daoName);
     }
 };
+getDao.init = init;
 module.exports = getDao;

dao/mysql/authDao.js

@@ -77,7 +77,7 @@ class AuthDao extends BaseDao {
                 return { verify: false };
             }
         } catch (err) {
-            this.logger.error(`verify Error|args=${JSON.stringify(userName, password)}|err=${err.message}`);
+            this.logger.error(`verify Error|args=${JSON.stringify({ userName, password })}|err=${err.message}`);
             throw err;
         }
     }
@@ -96,7 +96,7 @@ class AuthDao extends BaseDao {
             this.logger.debug(`database exec success|sql=${sql}|args=${JSON.stringify(args)}|ret=${JSON.stringify(rows)}`);
             return rows;
         } catch (err) {
-            this.logger.error(`setUser Error|args=${JSON.stringify(userName, password, email)}|err=${err.message}`);
+            this.logger.error(`setUser Error|args=${JSON.stringify({ userName, password, email })}|err=${err.message}`);
             throw err;
         }
     }
@@ -172,7 +172,7 @@ class AuthDao extends BaseDao {
             this.logger.debug(`database exec success|sql=${sql}|args=${JSON.stringify(args)}|ret=${JSON.stringify(rows)}`);
             return rows;
         } catch (err) {
-            this.logger.error(`changePassword Error|email=${userName}|err=${err.message}`);
+            this.logger.error(`changePassword Error|userName=${userName}|err=${err.message}`);
             throw err;
         }
     }

dao/mysql/postDao.js

@@ -0,0 +1,203 @@
+"use strict";
+const database = require("../../utils/mysql_util");
+const { configs } = require("../../config");
+const instance = configs["db_config"]["db_user"];
+const BaseDao = require("../../base/base_dao");
+const assert = require("assert");
+class PostDao extends BaseDao {
+    constructor() {
+        super(...arguments);
+        this.postTable = this.table_prefix + "_post";
+        this.commentTable = this.table_prefix + "_post_comment";
+        this.postHistory = this.table_prefix + "_post_history";
+        this.commentHistory = this.table_prefix + "_post_comment_history";
+        this.instance = instance;
+    }
+    async setComment() {
+        //TODO
+    }
+    async delComment() {
+        //TODO
+    }
+    async getComment() {
+        //TODO
+    }
+    async getPostListByContext() {
+        //TODO
+    }
+    async delPost(postId) {
+        try {
+            let sql = `update ${this.postTable} set f_status = 1 where f_post_id = ?`;
+            let args = [postId];
+            let rows = await database.query(sql, args, instance);
+            this.logger.debug(`database exec success|sql=${sql}|args=${JSON.stringify(args)}|ret=${JSON.stringify(rows)}`);
+            return rows;
+        } catch (err) {
+            this.logger.error(`delete post error|err=${err.message}`);
+            throw err;
+        }
+    }
+    /**
+     * 根据index获取post列表
+     * @param {Object} index 
+     */
+    async getPostList(index) {
+        try {
+            let where = [];
+            let args = [];
+            if (index.userId) {
+                where.push("f_user_id=?");
+                args.push(index.userId);
+            }
+            if (index.type) {
+                where.push("f_type");
+                args.push(index.type);
+            }
+            if (index.title) {
+                where.push(`f_title like '%${index.title.replace(/'/g, "\\'")}%'`);
+            }
+            if (index.tags) {
+                let tags = index.tags.split("|");
+                for (let i = 0; i < tags.length; i++) {
+                    where.push(`f_tags like '%${tags.replace(/'/g, "\\'")}%'`);
+                }
+            }
+            let sql = `select f_post_id,f_create_time,f_edit_time,f_version,f_user_id,f_status from ${this.postTable} where ${where.join(" and ")} order by f_edit_time desc`;
+            let rows = await database.query(sql, args, instance);
+            this.logger.debug(`database exec success|sql=${sql}|args=${JSON.stringify(args)}|ret=${JSON.stringify(rows)}`);
+            return rows.forEach(row => {
+                return {
+                    postId: row.f_post_id,
+                    createTime: row.f_create_time,
+                    editTime: row.f_edit_time,
+                    version: row.f_version,
+                    userId: row.f_user_id,
+                    status:row.f_status
+                };
+            });
+        } catch (err) {
+            this.logger.error(`get post list err|err=${err.message}`);
+            throw err;
+        }
+    }
+    /**
+     * 获取Post内容
+     * @param {string} postId 
+     */
+    async getPost(postId) {
+        try {
+            let postSql = `select * from ${this.postTable} where f_post_id = ?`;
+            let historySql = `select f_create_time from ${this.postHistory} where f_post_id = ?`;
+            let postRows = await database.query(postSql, [postId], instance);
+            if (postRows.length === 0) {
+                throw new Error("文章不存在");
+            }
+            if (postRows[0]["f_staus"] === 1) {
+                throw new Error("文章已删除");
+            }
+            postRows = postRows[0];
+            let histRows = await database.query(historySql, [postId], instance);
+            histRows = histRows.forEach(row => {
+                return (new Date(row["f_create_time"])).getTime();
+            });
+            return {
+                title: postRows["f_title"],
+                type: postRows["f_type"],
+                context: postRows["f_context"],
+                tags: postRows["f_tags"],
+                userId: postRows["f_user_id"],
+                version: postRows["f_version"],
+                hVersions: histRows
+            };
+        } catch (err) {
+            this.logger.error(err);
+            throw err;
+        }
+    }
+
+    async setPost(title, type, context, tags, userId, version, postId) {
+        try {
+            if (postId) {
+                await new Promise((resolve, reject) => {
+                    database.init(instance).getConnection((err, connection) => {
+                        if (err) {
+                            return reject(err);
+                        }
+                        connection.beginTransaction(async err => {
+                            if (err) {
+                                connection.release();
+                                return reject(err);
+                            }
+                            let querySql = (sql, args) => {
+                                return new Promise((resolve, _reject) => {
+                                    connection.query(sql, args, (err, rows) => {
+                                        if (err) {
+                                            return _reject(err);
+                                        }
+                                        resolve(rows);
+                                    });
+                                });
+                            };
+                            let rollback = () => {
+                                return new Promise((resolve, _reject) => {
+                                    connection.rollback(err => {
+                                        if (err) {
+                                            _reject(err);
+                                        }
+                                        resolve();
+                                    });
+                                });
+                            };
+                            let commit = () => {
+                                return new Promise((resolve, _reject) => {
+                                    connection.commit((err) => {
+                                        if (err) {
+                                            _reject(err);
+                                        }
+                                        resolve();
+                                    });
+                                });
+                            };
+                            try {
+                                let getNowContextSql = `select f_context,f_version from ${this.postTable} where f_post_id = ?`;
+                                let newContext = context;
+                                let newVersion = version;
+                                let nowContextRows = await querySql(getNowContextSql, [postId]);
+                                let nowContext = nowContextRows[0]["f_context"];
+                                let nowVersion = nowContextRows[0]["f_version"];
+                                assert(newVersion !== nowVersion, "文章版本号不符合要求");
+                                let setSql = `insert into ${this.postHistory} (f_post_id,f_post_page,f_context,f_version) values (?,?,?,?)`;
+                                await querySql(setSql, [postId, 0, nowContext, nowVersion]);
+                                let updateSql = `update ${this.postTable} set f_title = ?,f_type = ?,f_context = ?,f_tags = ?,f_version = ? where f_post_id = ?`;
+                                await querySql(updateSql, [title, type, newContext, tags, version, postId]);
+                                await commit();
+                                connection.release();
+                                resolve();
+                            } catch (err) {
+                                this.logger.error();
+                                await rollback();
+                                connection.release();
+                                return reject(err);
+                            }
+                        });
+                    });
+                });
+                return postId;
+            } else {
+                let sql = `insert into ${this.postTable} 
+                (f_post_page,f_title,f_type,f_context,f_tags,f_user_id,f_version,f_status) 
+                values 
+                (?,?,?,?,?,?,?,?)`;
+                let args = [1, title, type, context, tags, userId, version, 0];
+                let rows = await database.query(sql, args, instance);
+                let insertId = rows.insertId;
+                return insertId;
+            }
+        } catch (err) {
+            this.logger.error(`${err.message}`);
+            throw err;
+        }
+    }
+}
+
+module.exports = new PostDao();

dao/mysql/sessionDao.js

@@ -50,7 +50,7 @@ class SessionDao extends BaseDao {
             let rows = await database.query(sql, args, instance);
             return rows[0];
         } catch (err) {
-            this.logger.error(err);
+            this.logger.error(`getSession Error|err=${err.message}`);
             throw err;
         }
     }

dao/mysql/sql/t_post.sql

@@ -0,0 +1,15 @@
+CREATE TABLE `{table}` (
+  `f_post_id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'post id',
+  `f_post_page` int(11) NOT NULL COMMENT '页数',
+  `f_title` varchar(255) NOT NULL COMMENT '标题',
+  `f_type` varchar(255) NOT NULL COMMENT '文章类型',
+  `f_context` text NOT NULL COMMENT '文章内容',
+  `f_tags` varchar(255) NOT NULL COMMENT '文章标签',
+  `f_user_id` int(11) NOT NULL COMMENT 'user_auth表的f_id，表示作者',
+  `f_status` int(11) NOT NULL COMMENT '文章状态',
+  `f_version` varchar(255) NOT NULL COMMENT '文章版本',
+  `f_create_time` datetime NOT NULL DEFAULT current_timestamp() COMMENT '创建时间',
+  `f_edit_time` datetime NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '修改时间',
+  PRIMARY KEY (`f_post_id`) USING BTREE,
+  UNIQUE INDEX `uniq_post_page` (`f_post_id`,`f_post_page`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE utf8mb4_unicode_ci ROW_FORMAT=DYNAMIC;

dao/mysql/sql/t_post_comment.sql

@@ -0,0 +1,15 @@
+CREATE TABLE `{table}` (
+  `f_comment_id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'post id',
+  `f_post_id` int(11) NOT NULL COMMENT '留言的文章ID',
+  `f_parent_id` int(11) NOT NULL COMMENT '楼中楼父楼ID',
+  `f_context` text NOT NULL COMMENT '评论内容',
+  `f_user_id` int(11) NOT NULL COMMENT 'user_auth表的f_id，表示作者',
+  `f_status` int(11) NOT NULL COMMENT '评论状态',
+  `f_version` varchar(255) NOT NULL COMMENT '评论版本',
+  `f_create_time` datetime NOT NULL DEFAULT current_timestamp() COMMENT '创建时间',
+  `f_edit_time` datetime NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '修改时间',
+  UNIQUE KEY `f_unique` (`f_comment_id`,`f_post_id`,`f_parent_id`) USING BTREE,
+  KEY `f_comment_id_index` (`f_comment_id`) USING BTREE,
+  KEY `f_post_id_index` (`f_post_id`) USING BTREE,
+  KEY `f_parent_id_index` (`f_parent_id`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE utf8mb4_unicode_ci ROW_FORMAT=DYNAMIC;

dao/mysql/sql/t_post_comment_history.sql

@@ -0,0 +1,9 @@
+CREATE TABLE `{table}` (
+  `f_comment_id` int(11) NOT NULL COMMENT 'post id',
+  `f_context` text NOT NULL COMMENT '评论内容',
+  `f_version` varchar(255) NOT NULL COMMENT '评论版本',
+  `f_create_time` datetime NOT NULL DEFAULT current_timestamp() COMMENT '创建时间',
+  `f_edit_time` datetime NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '修改时间',
+  PRIMARY KEY (`f_comment_id`) USING BTREE,
+  UNIQUE KEY `uniq_version` (`f_comment_id`,`f_version`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE utf8mb4_unicode_ci ROW_FORMAT=DYNAMIC;

dao/mysql/sql/t_post_history.sql

@@ -0,0 +1,9 @@
+CREATE TABLE `{table}` (
+  `f_post_id` int(11) NOT NULL COMMENT 'post id',
+  `f_post_page` int(11) NOT NULL COMMENT '页数',
+  `f_context` text NOT NULL COMMENT '文章内容',
+  `f_version` varchar(255) NOT NULL COMMENT '文章版本',
+  `f_create_time` datetime NOT NULL DEFAULT current_timestamp() COMMENT '创建时间',
+  `f_edit_time` datetime NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '修改时间',
+  UNIQUE KEY `post_index` (`f_post_id`,`f_post_page`,`f_version`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE utf8mb4_unicode_ci ROW_FORMAT=DYNAMIC;

dao/mysql/sql/t_user_privilege.sql

@@ -0,0 +1,9 @@
+CREATE TABLE `{table}` (
+  `f_user_id` int(11) NOT NULL COMMENT 'uid',
+  `f_privilege` int(11) NOT NULL COMMENT '权限掩码',
+  `f_operator` varchar(255) NOT NULL COMMENT '修改人',
+  `f_create_time` datetime NOT NULL DEFAULT current_timestamp() COMMENT '创建时间',
+  `f_edit_time` datetime NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '修改时间',
+  PRIMARY KEY (`f_user_id`) USING BTREE,
+  UNIQUE KEY `uniq_userid` (`f_user_id`) USING BTREE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;