Merge 'database'

# Conflicts:
#	app/routes/signup.js

+node_modules
\ No newline at end of file

@@ -15,6 +15,12 @@ var csvRouter = require('./routes/csv')
 var app = express();
 var app = express();
 var router = express.Router();
 var router = express.Router();
 
 
+var cookieParser = require('cookie-parser')
+var ExpressSession = require('express-session')
+
+var database = require('./database/database');
+var config = require('./config');
+
 
 
 // get port
 // get port
 var port = process.env.PORT || 3000;
 var port = process.env.PORT || 3000;
@@ -46,6 +52,13 @@ app.use('/signup',signupRouter); // sign up page route
 app.use('/', indexRouter);  // main page route
 app.use('/', indexRouter);  // main page route
 
 
 
 
+//Session 처리
+app.use(cookieParser());
+app.use(ExpressSession({
+    secret:'key',
+    resave: true,
+    saveUninitialized:true
+}));
 
 
 //모든 router 처리가 끝난 후 404 오류 페이지 처리
 //모든 router 처리가 끝난 후 404 오류 페이지 처리
 var errorHandler = expressErrorHandler({
 var errorHandler = expressErrorHandler({
@@ -57,9 +70,25 @@ app.use(expressErrorHandler.httpError(404));
 app.use(errorHandler);
 app.use(errorHandler);
 
 
 
 
+// 프로세스 종료 시에 데이터베이스 연결 해제
+process.on('SIGTERM', function () {
+    console.log("프로세스가 종료됩니다.");
+    app.close();
+});
+
+app.on('close', function () {
+	console.log("Express 서버 객체가 종료됩니다.");
+	if (database.db) {
+		database.db.close();
+	}
+});
+
 
 
 // for server listening 
 // for server listening 
 var server = http.createServer(app)
 var server = http.createServer(app)
 server.listen(port,function(){
 server.listen(port,function(){
     console.log('익스프레스 서버를 시작했습니다.');
     console.log('익스프레스 서버를 시작했습니다.');
+
+    database.init(app, config);
 })
 })
+

+module.exports = {
+	server_port: 3000,
+	db_url: 'mongodb://oss:12341234@cluster0.us5lm.mongodb.net/?retryWrites=true&w=majority',
+	db_schemas: [
+	    {file:'./user_schema', collection:'users3', schemaName:'UserSchema', modelName:'UserModel'}
+	]
+}
\ No newline at end of file

+var mongoose = require('mongoose');
+var db_url = 'mongodb+srv://oss:12341234@cluster0.us5lm.mongodb.net/?retryWrites=true&w=majority';
+// database 객체에 db, schema, model 모두 추가
+var database = {};
+
+// 초기화를 위해 호출하는 함수
+database.init = function(app, config) {
+	console.log('init() 호출됨.');
+	
+	connect(app, config);
+}
+
+//데이터베이스에 연결하고 응답 객체의 속성으로 db 객체 추가
+function connect(app, config) {
+	console.log('connect() 호출됨.');
+	
+	// 데이터베이스 연결 : config의 설정 사용
+    mongoose.Promise = global.Promise;  // mongoose의 Promise 객체는 global의 Promise 객체 사용하도록 함
+	mongoose.connect(db_url);
+
+	database.db = mongoose.connection;
+	
+	database.db.on('error', console.error.bind(console, 'mongoose connection error.'));	
+	database.db.on('open', function () {
+		console.log('데이터베이스에 연결되었습니다. : ' + db_url);
+		
+		// config에 등록된 스키마 및 모델 객체 생성
+		createSchema(app, config);
+		
+	});
+	database.db.on('disconnected', connect);
+
+}
+
+// config에 정의된 스키마 및 모델 객체 생성
+function createSchema(app, config) {
+	var schemaLen = config.db_schemas.length;
+	console.log('설정에 정의된 스키마의 수 : %d', schemaLen);
+	
+	for (var i = 0; i < schemaLen; i++) {
+		var curItem = config.db_schemas[i];
+		
+		// 모듈 파일에서 모듈 불러온 후 createSchema() 함수 호출하기
+		var curSchema = require(curItem.file).createSchema(mongoose);
+		console.log('%s 모듈을 불러들인 후 스키마 정의함.', curItem.file);
+		
+		// User 모델 정의
+		var curModel = mongoose.model(curItem.collection, curSchema);
+		console.log('%s 컬렉션을 위해 모델 정의함.', curItem.collection);
+		
+		// database 객체에 속성으로 추가
+		database[curItem.schemaName] = curSchema;
+		database[curItem.modelName] = curModel;
+		console.log('스키마 이름 [%s], 모델 이름 [%s] 이 database 객체의 속성으로 추가됨.', curItem.schemaName, curItem.modelName);
+	}
+	
+	app.set('database', database);
+	console.log('database 객체가 app 객체의 속성으로 추가됨.');
+}
+ 
+
+// database 객체를 module.exports에 할당
+module.exports = database;
\ No newline at end of file

+var crypto = require('crypto');
+
+var Schema = {};
+
+Schema.createSchema = function(mongoose) {
+	
+	// 스키마 정의
+	var UserSchema = mongoose.Schema({
+	    id: {type: String, required: true, unique: true, 'default':''},
+	    hashed_password: {type: String, required: true, 'default':''},
+	    salt: {type:String, required:true},
+	    name: {type: String, index: 'hashed', 'default':''},
+	    age: {type: Number, 'default': -1},
+	    created_at: {type: Date, index: {unique: false}, 'default': Date.now},
+	    updated_at: {type: Date, index: {unique: false}, 'default': Date.now}
+	});
+	
+	// password를 virtual 메소드로 정의 : MongoDB에 저장되지 않는 편리한 속성임. 특정 속성을 지정하고 set, get 메소드를 정의함
+	UserSchema
+	  .virtual('password')
+	  .set(function(password) {
+	    this._password = password;
+	    this.salt = this.makeSalt();
+	    this.hashed_password = this.encryptPassword(password);
+	    console.log('virtual password 호출됨 : ' + this.hashed_password);
+	  })
+	  .get(function() { return this._password });
+	
+	// 스키마에 모델 인스턴스에서 사용할 수 있는 메소드 추가
+	// 비밀번호 암호화 메소드
+	UserSchema.method('encryptPassword', function(plainText, inSalt) {
+		if (inSalt) {
+			return crypto.createHmac('sha1', inSalt).update(plainText).digest('hex');
+		} else {
+			return crypto.createHmac('sha1', this.salt).update(plainText).digest('hex');
+		}
+	});
+	
+	// salt 값 만들기 메소드
+	UserSchema.method('makeSalt', function() {
+		return Math.round((new Date().valueOf() * Math.random())) + '';
+	});
+	
+	// 인증 메소드 - 입력된 비밀번호와 비교 (true/false 리턴)
+	UserSchema.method('authenticate', function(plainText, inSalt, hashed_password) {
+		if (inSalt) {
+			console.log('authenticate 호출됨 : %s -> %s : %s', plainText, this.encryptPassword(plainText, inSalt), hashed_password);
+			return this.encryptPassword(plainText, inSalt) === hashed_password;
+		} else {
+			console.log('authenticate 호출됨 : %s -> %s : %s', plainText, this.encryptPassword(plainText), this.hashed_password);
+			return this.encryptPassword(plainText) === this.hashed_password;
+		}
+	});
+	
+	// 값이 유효한지 확인하는 함수 정의
+	var validatePresenceOf = function(value) {
+		return value && value.length;
+	};
+		
+	// 저장 시의 트리거 함수 정의 (password 필드가 유효하지 않으면 에러 발생)
+	UserSchema.pre('save', function(next) {
+		if (!this.isNew) return next();
+	
+		if (!validatePresenceOf(this.password)) {
+			next(new Error('유효하지 않은 password 필드입니다.'));
+		} else {
+			next();
+		}
+	})
+	
+	// 필수 속성에 대한 유효성 확인 (길이값 체크)
+	UserSchema.path('id').validate(function (id) {
+		return id.length;
+	}, 'id 칼럼의 값이 없습니다.');
+	
+	UserSchema.path('name').validate(function (name) {
+		return name.length;
+	}, 'name 칼럼의 값이 없습니다.');
+	
+	UserSchema.path('hashed_password').validate(function (hashed_password) {
+		return hashed_password.length;
+	}, 'hashed_password 칼럼의 값이 없습니다.');
+	
+	   
+	// 스키마에 static 메소드 추가
+	UserSchema.static('findById', function(id, callback) {
+		return this.find({id:id}, callback);
+	});
+	
+	UserSchema.static('findAll', function(callback) {
+		return this.find({}, callback);
+	});
+	
+	console.log('UserSchema 정의함.');
+
+	return UserSchema;
+};
+
+// module.exports에 UserSchema 객체 직접 할당
+module.exports = Schema;
+

+var Conn = require('../database/database')
 var express = require('express')
 var express = require('express')
-var router = express.Router()
+var router = express.Router();
 
 
 //라우팅 함수 등록
 //라우팅 함수 등록
 
 
 router.get('/',function(req,res){
 router.get('/',function(req,res){
+   
     res.render('login.html')
     res.render('login.html')
 });
 });
 
 
 router.post('/process', function(req, res) {
 router.post('/process', function(req, res) {
-    console.log('/process/login 처리함');
+    console.log('/login/process 처리함');
 
 
     var paramId = req.body.id || req.query.id;
     var paramId = req.body.id || req.query.id;
     var paramPassword = req.body.password || req.query.password;
     var paramPassword = req.body.password || req.query.password;
     //GET, POST 모두 고려해서 둘 다 검사
     //GET, POST 모두 고려해서 둘 다 검사
 
 
-    res.writeHead('200', { 'Content-Type': 'text/html;charset=utf8' });
-    res.write('<h1>Result form Express Server</h1>');
-    res.write('<div><p>Param id : ' + paramId + '</p></div>');
-    res.write('<div><p>Param password : ' + paramPassword + '</p></div>');
-    res.write("<br><br><a href ='/login.html'>로그인 페이지로 돌아가기</a>");
+    // 데이터베이스 객체 참조
+	var database = req.app.get('database');
+	
+    // 데이터베이스 객체가 초기화된 경우, authUser 함수 호출하여 사용자 인증
+	if (database.db) {
+		authUser(database, paramId, paramPassword, function(err, docs) {
+			// 에러 발생 시, 클라이언트로 에러 전송
+			if (err) {
+                console.error('사용자 로그인 중 에러 발생 : ' + err.stack);
+                
+                res.writeHead('200', {'Content-Type':'text/html;charset=utf8'});
+				res.write('<h2>사용자 로그인 중 에러 발생</h2>');
+                res.write('<p>' + err.stack + '</p>');
+				res.end();
+                
+                return;
+            }
+			
+            // 조회된 레코드가 있으면 성공 응답 전송
+			if (docs) {
+				console.dir(docs);
+
+                // 조회 결과에서 사용자 이름 확인
+				var username = docs[0].name;
+				
+				res.writeHead('200', {'Content-Type':'text/html;charset=utf8'});
+				res.write('<h1>로그인 성공</h1>');
+				res.write('<div><p>사용자 아이디 : ' + paramId + '</p></div>');
+				res.write('<div><p>사용자 이름 : ' + username + '</p></div>');
+				res.write("<br><br><a href='/login'>다시 로그인하기</a>");
+				res.end();
+			
+			} else {  // 조회된 레코드가 없는 경우 실패 응답 전송
+				res.writeHead('200', {'Content-Type':'text/html;charset=utf8'});
+				res.write('<h1>로그인  실패</h1>');
+				res.write('<div><p>아이디와 패스워드를 다시 확인하십시오.</p></div>');
+				res.write("<br><br><a href='/login'>다시 로그인하기</a>");
 				res.end();
 				res.end();
+			}
+		});
+	} else {  // 데이터베이스 객체가 초기화되지 않은 경우 실패 응답 전송
+		res.writeHead('200', {'Content-Type':'text/html;charset=utf8'});
+		res.write('<h2>데이터베이스 연결 실패</h2>');
+		res.write('<div><p>데이터베이스에 연결하지 못했습니다.</p></div>');
+		res.end();
+	}
+
 });
 });
 
 
+//사용자를 인증하는 함수 : 아이디로 먼저 찾고 비밀번호를 그 다음에 비교하도록 함
+var authUser = function(database, id, password, callback) {
+	console.log('authUser 호출됨.');
+	
+	// 1. 아이디를 이용해 검색
+	database.UserModel.findById(id, function(err, results) {
+		if (err) {
+			callback(err, null);
+			return;
+		}
+		
+		console.log('아이디 [%s]로 사용자 검색결과', id);
+		console.dir(results);
+		
+		if (results.length > 0) {
+			console.log('아이디와 일치하는 사용자 찾음.');
+			
+			// 2. 패스워드 확인 : 모델 인스턴스를 객체를 만들고 authenticate() 메소드 호출
+			var user = new database.UserModel({id:id});
+			var authenticated = user.authenticate(password, results[0]._doc.salt, results[0]._doc.hashed_password);
+			if (authenticated) {
+				console.log('비밀번호 일치함');
+				callback(null, results);
+			} else {
+				console.log('비밀번호 일치하지 않음');
+				callback(null, null);
+			}
+			
+		} else {
+	    	console.log("아이디와 일치하는 사용자를 찾지 못함.");
+	    	callback(null, null);
+	    }
+		
+	});
+	
+}
+
 module.exports = router
 module.exports = router
\ No newline at end of file

@@ -53,9 +53,9 @@
                 <div class="row justify-content-center">
                 <div class="row justify-content-center">
                     <div class="col-lg-8 col-xxl-6">
                     <div class="col-lg-8 col-xxl-6">
                         <div class="text-center my-5">
                         <div class="text-center my-5">
-                            <h1>로그인</h1>
+                            <h1>회원가입</h1>
                             <br>
                             <br>
-                            <form method="post" action="/login/process">
+                            <form method="post" action="/signup/process">
                                 <table>
                                 <table>
                                     <tr>
                                     <tr>
                                         <td><label>이름</label></td>
                                         <td><label>이름</label></td>

-../ejs/bin/cli.js
\ No newline at end of file
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../ejs/bin/cli.js" "$@"
+else 
+  exec node  "$basedir/../ejs/bin/cli.js" "$@"
+fi

-../jake/bin/cli.js
\ No newline at end of file
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../jake/bin/cli.js" "$@"
+else 
+  exec node  "$basedir/../jake/bin/cli.js" "$@"
+fi

-../mime/cli.js
\ No newline at end of file
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../mime/cli.js" "$@"
+else 
+  exec node  "$basedir/../mime/cli.js" "$@"
+fi

@@ -11,10 +11,15 @@
   "dependencies": {
   "dependencies": {
     "body-parser": "^1.20.0",
     "body-parser": "^1.20.0",
     "bootstrap": "^5.1.3",
     "bootstrap": "^5.1.3",
+    "cookie-parser": "^1.4.6",
+    "crypto": "^1.0.1",
     "ejs": "^3.1.7",
     "ejs": "^3.1.7",
     "express": "^4.18.1",
     "express": "^4.18.1",
     "express-error-handler": "^1.1.0",
     "express-error-handler": "^1.1.0",
+    "express-session": "^1.17.3",
     "http": "^0.0.1-security",
     "http": "^0.0.1-security",
+    "mongoose": "^6.3.4",
+    "mysql": "^2.18.1",
     "path": "^0.12.7",
     "path": "^0.12.7",
     "serve-static": "^1.15.0"
     "serve-static": "^1.15.0"
   }
   }