강의용

config.json

{
    "development": {
        "dialect": "mssql",
        "host":"{host}.database.windows.net",
        "port":1433,
        "username": "{your_username}",
        "password": "{your_password}",
        "dialectOptions":{
            "encrypt": true,
            "database":"{database}"
        }
    },
    "production": {
        "dialect": "mssql",
        "host":"{host}.database.windows.net",
        "port":1433,
        "username": "{your_username}",
        "password": "{your_password}",
        "dialectOptions":{
            "encrypt": true,
            "database":"{database}"
        }
    }
}

file.js

///<reference path="../typings/node/node.d.ts"/>
///<reference path="../typings/express/express.d.ts"/>

'use strict';


var express = require('express');
var router = express.Router();
var multer = require('multer');
var fs = require('fs');
var crypto = require('crypto');
var storageCtrl = require('../utils/storageCtrl');




function CreateMd5(str) {
    var md5 = crypto.createHash("md5");
    return md5.update(new Buffer(str, 'utf8')).digest('base64');
}


var upload = multer({ dest: './UploadFiles/' });
router.post('/upload/:fileName', upload.single('myFile'), function(req, res) {

    let filePath = req.file.path;
    let fileName = req.params.fileName;
    let fileSplit =  req.params.fileName.split('.');
    let fileType = fileSplit[1];
    let size = req.file.size;


    let loadedFileData;
    let ReadFile = new Promise(function (resolve, reject) {
        fs.readFile(filePath, 'utf8', function (err, data) {
            loadedFileData = data;
            resolve(data);
        });
    });


    let createdMd5;
    let containerName = 'sample';
    
    ReadFile
    .then(function (fileDatas) {
        //md5 제작
        return new Promise(function (resolve, reject) {
            createdMd5 = CreateMd5(fileDatas);
            resolve();
        });
    })
    .then(function() {
        //storage 초기화
        return storageCtrl.InitBlobService();
    })
    .then(function() {
        //컨테이너 생성
        let options = {publicAccessLevel : 'container'}; //cdn으로 사용하기 위해서 publicAccessLevel 옵션을 추가함.
        return storageCtrl.CreateContainer(containerName, options)
    })
    .then(function () {
        let stream = fs.createReadStream(filePath
            , { flags: 'r',
                ding: null,
                fd: null,
                mode: 0o666,
                autoClose: true,
                bufferSize: 64 * 1024
            });
        let options = {};
        
        if(fileType !== 'json') {
            options['storeBlobContentMD5'] = false;
        }
        else {
            options['contentMD5'] = createdMd5;
        }
        
        //azure에파일 업로드.
        return storageCtrl.uploadBlobs(stream, containerName, fileName, options, size);
    })
    .then(function(createResponse) {
        //성공 결과  생성
        return new Promise(function (resolve, reject) {
            resolve({result:0, response:createResponse});
        });
    })
    .catch(function (err) {
        //error 결과 생성
        return new Promise(function (resolve, reject) {
            console.log(err);
            resolve({result:99, error:`${err}`});
        });
    })
    .then(function (sendResult) {
        //템프파일 삭제.
        fs.unlink(filePath, function (err) {
            //결과 전송.
            res.send(sendResult);
        });
    });
});

module.exports = router;

model_score.js

"use strict";

module.exports = function(sequelize, DataTypes) {
  var Score = sequelize.define("Score", {
    id: {type:DataTypes.INTEGER, primaryKey:true}, //사용자 구분
    score: {type:DataTypes.INTEGER, defaultValue:0} //점수기록
  },
  {timestamps:false} //타입스탬프 컬럼이 생성되지 않도록 처리.
  );

  return Score;
};

rank_score.js

router.get('/ranker', function (req, res) {
	let finalData = [];
	function GetUserName(id, rankData) {
		return models.User.findOne({where:{id:id}})
		.then(function(userInfo){
			return new Promise(function (resolve, reject) {
				rankData['username'] = userInfo['username'];
				finalData.push(rankData);
				resolve();
			});
		});
	}
	
	//상위 10명 랭크 정보 반환
	redisCtrl.GetRankers(0, 9)
	.then(function(result) {
		let promise = [];
		for(let row of result) {
			promise.push(GetUserName(row.id, row));
		}
		return Promise.all(promise);
	})
	.then(function() {
		finalData.sort((a, b)=>a.Rank - b.Rank);
		res.send({result:0, Rank:finalData});
	})
});

redisCtrl.js

'use strict';

var redis = require("redis");
var bluebird = require("bluebird");
bluebird.promisifyAll(redis.RedisClient.prototype);


//{name} : redis 호스트명, {primary key} : 기본 액세스 키 string  
var client = redis.createClient(6379,'lv0test.redis.cache.windows.net', {auth_pass: 'p/T39hx/8eygNhApU3UPzvtBRXbdEWMwPvr++OWUozM=' });

var mainThis = this;
var redisKey = "Lv0Score"; //원하는 명칭으로 변경가능

/** 점수를 업데이트한다.
 * @param {number | string}     id
 * @param {number | string}     Score
 * @returns {Promise}
 */
exports.UpdateScore = function (id, Score) {
    let userKeyStr = `${id}`;
    let convertScore = Score * 1;
    return new Promise(function (resolve, reject) {
        //점수 기록.
        client.zaddAsync(redisKey, convertScore, userKeyStr)
        .then(function(replies) {
            resolve(convertScore);
        });
    });
};

/**
 * 점수조회
 * @param {number | string}     id
 * @returns {Promise}
 */
exports.GetScore = function (id) {
    return new Promise(function (resolve, reject) {
        client.zscoreAsync(redisKey, `${id}`).then(function(reply) {
            console.log(`GetScore : ${reply}`);
            if(reply === null) {
                reject();
                return;
            }
            resolve( reply * 1 );
        });
    });
};

/**
 * 랭킹 로딩
 * @param {number | string}     id
 * @returns {Promise}
 */
exports.GetRank = function (id) {
    let saveUserScore = 0;
    return new Promise(function (resolve, reject) {
        mainThis.GetScore(id)
            .catch(function(){ return mainThis.UpdateScore(id, 0); })
            .then(function (userScore) {
                saveUserScore = userScore;
                return mainThis.GetRankWithScore(userScore);
            })
            .then(function(getRank){
                resolve(getRank, saveUserScore);
            });

    });
};

/**
 * 점수를통해 랭킹 획득
 * @param {string | number}     userScore
 * @returns {Promise}
 */
exports.GetRankWithScore = function(userScore) {
    return new Promise(function (resolve, reject) {
        let targetScore = (userScore * 1) + 1;
        client.zcountAsync(redisKey, targetScore, '+inf').then(function(reply) {
            resolve((reply * 1) + 1);
        });
    });
};

/**
 * 일정 구간랭커 로딩.
 * @param {string|number}       min     가장 작은 순위
 * @param {string|number}       max     최대 순위
 * @returns {Promise}
 * @example
 *  1~10위 로딩 시
 *  GetRankers(0, 9).then( //function );
 */
exports.GetRankers = function(min, max) {
    let sendResult = [];
    function GetRankAndMakeResult(id, score) {
        return new Promise(function(resolve, reject) {
            mainThis.GetRankWithScore(score)
            .then(function(rank) {
                sendResult.push({ id:id*1, score:score*1, Rank:rank});
                resolve();
            });
        });
    }
    
    return client.zrevrangeAsync(redisKey, min, max, 'withscores')
    .then(function(rangeIdAndScores) {
        //rangeIdAndScores는 홀수가 id이고 짝수가 score이다.
        let promiseList = []
        for(let i=0;i<rangeIdAndScores.length;i=i+2) {
            promiseList.push(GetRankAndMakeResult(rangeIdAndScores[i], rangeIdAndScores[i+1]));
        }
        
        return Promise.all(promiseList);
    })
    .then(function(){
        return new Promise(function(resolve, reject) {
            //오름차순 정렬.
            sendResult.sort( (a, b)=> a.Rank - b.Rank);
            resolve(sendResult);
        });
    })
};

route_score.js

///<reference path="../typings/node/node.d.ts"/>
///<reference path="../typings/express/express.d.ts"/>

'use strict';

var express = require('express');
var router = express.Router();

var models = require('../models');

router.post('/add/:id/:score', function(req, res){
	let totalScore = 0;
	
	//Score 테이블에 사용자 데이터가 존재하는지 확인
	models.Score.findOne({where:{id:req.params.id}})
	.then(function(findScoreRow) {
		return new Promise(function(resolve, reject) {
			if(findScoreRow !== null) {
				resolve(findScoreRow);
			}
			else {
				reject();
			}
		});
	})
	.catch(function(err) {
		//존재하지 않을 때 생성
		return models.Score.create({id:req.params.id});
	})
	.then(function(scoreRow) {
		//점수 증가
		totalScore = scoreRow.score+(req.params.score*1);
		return models.Score.update({score:totalScore}, {where:{id:scoreRow.id}});
	})
	.then(function(){
		//결과 전송
		res.send({result:0, score:totalScore});
	});
});

module.exports = router;

storageCtrl.js

'use strict';

var azure = require('azure-storage');

var STORAGE_KEY = '{access key}'; //액세스 키
var STORAGE_ACCOUNT_NAME = '{account name}'; //저장소 계정이름


var blobService;
var isInit = false;

/**
 * 초기화 여부 체크에 사용.
 * @type {boolean}
 */
exports.isInit = isInit;

/**
 * 초기화 진행
 */
exports.InitBlobService = function () {
    return new Promise(function (resolve, reject) {
        if(isInit === true) {
            resolve();
            return;
        }
        
        console.log('init blob service');
        blobService = azure.createBlobService(STORAGE_ACCOUNT_NAME, STORAGE_KEY);
        isInit = true;
        resolve();
    });
};

/**
 * 컨테이너 제작
 * @param {string}		container	컨테이너명
 * @param {object}		options		옵션 //{publicAccessLevel : 'container'}
 * @returns {Promise}
 */
exports.CreateContainer = function (container, options) {
    return new Promise(function (resolve, reject) {
        // Create the container.
        blobService.createContainerIfNotExists(container, options, function (error) {
            if (error) {
                console.log('createContainerIfNotExists err : ', error);
                reject(error);
            } else {
                console.log('Created the container ' + container);
                resolve();
            }
        });
    });
};


/**
 * 파일을 저장한다.
 * @param               fileStream            파일내용.
 * @param {string}      containerName   저장할 컨테이너명.
 * @param {string}      blobName        저장할 파일명.
 * @param {object}      options             옵션 //{contentMD5:md5, storeBlobContentMD5:true} 
 * @param {number}      size            파일 사이즈
 */
exports.uploadBlobs = function (fileStream, containerName, blobName, options, size) {
    return new Promise(function (resolve, reject) {
		blobService.createBlockBlobFromStream(containerName, blobName, fileStream, size, options, function(err, createBlob, createResponse) {
			if (err) {
				console.log('createBlockBlobFromStream err : ', err);
				reject(err);
			} else {
				console.log(' Blob ' + blobName + ' upload finished.');
				resolve(createResponse);
			}
		});
	});
};

user.js

"use strict";

module.exports = function(sequelize, DataTypes) {
  var User = sequelize.define("User", {
    username: {type:DataTypes.STRING}, //사용자 이름
    gold: {type:DataTypes.INTEGER, defaultValue:1000}, //골드
    gem: {type:DataTypes.INTEGER, defaultValue:10} //보석
  },
  {timestamps:false} //타입스탬프 컬럼이 생성되지 않도록 처리.
  );

  return User;
};

users.js

///<reference path="../typings/node/node.d.ts"/>
///<reference path="../typings/express/express.d.ts"/>

'use strict';

var express = require('express');
var router = express.Router();

var models = require('../models');

router.get('/info/:id', function(req, res, next) {
    //사용자 검색.
    models.User.findOne({where:{id:req.params.id}})
    .then(function(result) {
        if(result !== null) {
            res.send({result:0, body:result});
        }
        else {
            res.send({result:98, body:'do not exist'});
        }
    });
});

router.post('/add/:username', function(req, res) {
    function MakeResult(stateCode, resultValue) {
        return {result:stateCode, body:resultValue};
    }
    //동일한 username이 사용중인지 체크
    models.User.findOne({where:{username:req.params.username}})
    .then(function(findResult) {
        return new Promise(function(resolve, reject) {
            //사용중이면 에러 처리
            if(findResult !== null) {
                reject('exist');
                return;
            }
            resolve();
        });
    }).then(function(){
        //새로운 user 생성
        return models.User.create({username:req.params.username}).then(function(result){
            return new Promise(function(resolve, reject) {
                resolve(MakeResult(0, result));
            });
        });
    }).catch(function(err) {
        //에러 발생 처리 부분
        return new Promise(function (resolve, reject) {
            console.log(`error : ${err}`);
            resolve(MakeResult(99, err));
        });
    }).then(function(returnValue) {
        //최종 결과 전송
        res.send(returnValue);
    });
});

module.exports = router;