Fix backend modules

Author: Kento75

backend/api_server.js

@@ -0,0 +1,35 @@
+require('rootpath')();
+const express = require("express");
+const app = express();
+const bodyParser = require("body-parser");
+const jwt = require('./app/helper/jwt');
+
+// クロスドメインリクエストの許可
+const cors = require('cors');
+app.use(cors());
+
+// jsonのパーサーを実装
+app.use(bodyParser.json());
+app.use(bodyParser.urlencoded({ extended: true }))
+
+/* DB設定の実装 */
+const database = require('./app/config/dbConfig');
+
+/* テーブル存在チェック & 無い場合は作成 */
+database.init();
+
+/* JWT Auth の実装  */
+app.use(jwt());
+
+/* 引数がない場合は、ポート3000で起動 */
+const port = process.argv[2] || 3000;
+app.listen(port, function () {
+    console.log("Server listening on port : " + port);
+});
+
+app.use(bodyParser.urlencoded({extended: false}));
+app.use(bodyParser.json());
+
+/* ルート設定 */
+const REST_API_ROOT = '/';
+app.use(REST_API_ROOT, require('./app/routes/router'));

backend/app/config/authConfig.json

@@ -0,0 +1,3 @@
+{
+   "secret": "1234567890asdfghjklzxcvbn"
+}

backend/app/config/dbConfig.js

@@ -0,0 +1,29 @@
+let sqlite3 = require('sqlite3').verbose();
+
+/*
+ * データベース設定
+ */
+
+/* DBをロード */
+let db = new sqlite3.Database('./sqlite.db');
+
+/* テーブルが存在しない場合は作成 */
+let init = function () {
+    // user table
+    db.run("CREATE TABLE if not exists user (" +
+        "id TEXT," +
+        " username TEXT," +
+        " password TEXT," +
+        " firstName TEXT," +
+        " lastName TEXT," +
+        " age TEXT," +
+        " imageURL TEXT," +
+        " comment TEXT" +
+        ")");
+};
+
+module.exports = {
+    init: init,
+    db: db
+};
+

backend/app/controller/common/controllerCommon.js

@@ -0,0 +1,65 @@
+var authConfig = require('../../config/authConfig.json');
+var jwt = require('jsonwebtoken');
+
+/**
+ * レスポンスコマンド一覧
+ */
+class controllerCommon {
+
+    authSuccess(res) {
+        return (result) => {
+            // ここにjwtロジックを組み込む
+            // TODO
+            if (result) {
+                const token = jwt.sign({ sub: result.id }, authConfig.secret);
+                var authResult = { ...result[0], token };
+            }
+            res.status(200); // Found
+            res.json(authResult);
+        }
+    }
+
+    findSuccess(res) {
+        return (result) => {
+            res.status(200); // Found
+            res.json(result);
+        }
+    }
+
+    existsSuccess(res) {
+        return (result) => {
+            res.status(200); // Found
+            res.json(result);
+        }
+    }
+
+    editSuccess(res) {
+        return () => {
+            res.status(201); // Created/Updated/Deleted
+            res.json({});
+        }
+    }
+
+    authError(res) {
+        return (error) => {
+            res.status(404); // authUser Not found
+            res.json(error);
+        }
+    }
+
+    serverError(res) {
+        return (error) => {
+            res.status(500);
+            res.json(error);
+        }
+    }
+
+    findError(res) {
+        return (error) => {
+            res.status(404); // Not found
+            res.json(error);
+        }
+    }
+}
+
+module.exports = controllerCommon;

backend/app/controller/userController.js

@@ -0,0 +1,62 @@
+const userDao = require('../dao/userDao');
+
+/* コマンド一覧を実装 */
+const ControllerCommon = require('./common/controllerCommon');
+
+const User = require('../model/user');
+
+class UserController {
+
+    constructor() {
+        this.userDao = new userDao();
+        this.common = new ControllerCommon();
+    }
+
+    /**
+     * 検索
+     * @params req, res
+     * @return entity
+     */
+    findByAuthUser(req, res) {
+        let username = req.body.username;
+        let password = req.body.password;
+          this.userDao.findByAuthUser(username, password)
+              .then(this.common.authSuccess(res))
+              .catch(this.common.authError(res));
+      };
+
+    /**
+     * 検索
+     * @params req, res
+     * @return entity
+     */
+    findById(req, res) {
+      let userId = req.params.userId;
+        this.userDao.findById(userId)
+            .then(this.common.findSuccess(res))
+            .catch(this.common.findError(res));
+    };
+
+    /**
+     * 全件検索
+     * @return all entities
+     */
+    findAll(res) {
+        this.userDao.findAll()
+            .then(this.common.findSuccess(res))
+            .catch(this.common.findError(res));
+    };
+
+    /**
+     * 全件合計
+     * @return count
+     */
+    countAll(res) {
+
+        this.userDao.countAll()
+            .then(this.common.findSuccess(res))
+            .catch(this.common.serverError(res));
+    };
+}
+
+module.exports = UserController;

backend/app/dao/commons/daoCommon.js

@@ -0,0 +1,94 @@
+/** データベースのロードと
+*  データベースコンフィグの適用
+*/
+const database = require('../../config/dbConfig');
+
+/* 非同期処理にBlueBirdを実装 */
+const Promise = require('bluebird');
+
+/* Daoエラーの設定 */
+const DaoError = require('./daoError');
+
+/**
+ * DAOコマンド一覧
+ */
+class Common {
+
+    findAll(sqlRequest) {
+        return new Promise(function (resolve, reject) {
+            database.db.all(sqlRequest, function (err, rows) {
+                if (err) {
+                    reject(
+                        new DaoError(20, "Internal server error")
+                    );
+                } else if (rows === null || rows.length === 0) {
+                    reject(
+                        new DaoError(21, "Entity not found")
+                    );
+                } else {
+                    resolve(rows);
+                }
+            })
+        });
+    }
+
+    findOne(sqlRequest, sqlParams) {
+        return new Promise(function (resolve, reject) {
+            let stmt = database.db.prepare(sqlRequest);
+            stmt.all(sqlParams, function (err, rows) {
+                if (err) {
+                    reject(
+                        new DaoError(11, "Invalid arguments")
+                    );
+                } else if (rows === null || rows.length === 0) {
+                    reject(
+                        new DaoError(21, "Entity not found")
+                    );
+                } else {
+                    resolve(rows);
+                }
+            })
+        });
+    }
+
+    existsOne(sqlRequest, sqlParams) {
+        return new Promise(function (resolve, reject) {
+            let stmt = database.db.prepare(sqlRequest);
+            stmt.each(sqlParams, function (err, row) {
+                if (err) {
+                    reject(
+                        new DaoError(20, "Internal server error")
+                    );
+                } else if (row && row.found === 1) {
+                    resolve(true);
+                } else {
+                    reject(
+                        new DaoError(21, "Entity not found")
+                    );
+                }
+            })
+        });
+    }
+
+    run(sqlRequest, sqlParams) {
+        return new Promise(function (resolve, reject) {
+            let stmt = database.db.prepare(sqlRequest);
+            stmt.run(sqlParams, function (err) {
+                if (this.changes === 1) {
+                    resolve(true);
+                } else if (this.changes === 0) {
+                    reject(
+                        new DaoError(21, "Entity not found")
+                    )
+                } else {
+                    console.log(err);
+                    reject(
+                        new DaoError(11, "Invalid arguments")
+                    )
+                }
+            })
+        });
+    }
+}
+
+module.exports = Common;

backend/app/dao/commons/daoError.js

@@ -0,0 +1,12 @@
+/**
+ * Dao エラー
+ */
+
+class DaoError {
+    constructor(errorCode, message) {
+        this.errorCode = errorCode;
+        this.message = message;
+    }
+}
+
+module.exports = DaoError;

backend/app/dao/userDao.js

@@ -0,0 +1,75 @@
+const User = require('../model/user');
+
+const daoCommon = require('./commons/daoCommon');
+
+class UserDao {
+
+    constructor() {
+        this.common = new daoCommon();
+    }
+
+    /**
+     * 存在チェック
+     * @params username, password
+     * returns true or false
+     */
+    findByAuthUser(username, password) {
+        let sqlRequest = "SELECT id, username, password, firstName, lastName, age, imageURL, comment FROM User WHERE username=$username and password=$password";
+        let sqlParams = {
+            $username: username,
+            $password: password
+        };
+        console.log(sqlParams)
+        return this.common.findOne(sqlRequest, sqlParams).then(rows =>{
+            let user = [];
+            for (const row of rows) {
+                user.push(new User(row.id, row.username, row.password, row.firstName, row.lastName, row.age, row.imageURL, row.comment));
+            }
+            return user;
+        });
+    }
+
+    /**
+     * 検索
+     * @params userId
+     * @return entity
+     */
+    findById(userId) {
+        let sqlRequest = "SELECT id, username, password, firstName, lastName, age, imageURL, comment FROM User WHERE id like '%'||$userId||'%' ";
+        let sqlParams = {$userId: userId};
+        return this.common.findOne(sqlRequest, sqlParams).then(rows =>{
+            let users = [];
+            for (const row of rows) {
+                users.push(new User(row.id, row.username, row.password, row.firstName, row.lastName, row.age, row.imageURL, row.comment));
+            }
+            return users;
+        });
+    };
+
+    /**
+     * 検索(全件)
+     * @return all entities
+     */
+    findAll() {
+        let sqlRequest = "SELECT * FROM User";
+        return this.common.findAll(sqlRequest).then(rows => {
+            let users = [];
+            for (const row of rows) {
+                users.push(new User(row.id, row.username, row.password, row.firstName, row.lastName, row.age, row.imageURL, row.comment));
+            }
+            return users;
+        });
+    };
+
+    /**
+     * 件数(全件)
+     * @return count
+     */
+    countAll() {
+        let sqlRequest = "SELECT COUNT(*) AS count FROM User";
+        return this.common.findOne(sqlRequest);
+    };
+
+}
+
+module.exports = UserDao;