├── .gitignore
├── README.md
├── commonservice
├── googleoauth.service.js
├── jwtverify.js
└── mongoservice.js
├── config.js
├── controller
├── school.controller.js
└── user.controller.js
├── middleware
└── middleware.js
├── models
├── homework.js
├── school.model.js
└── user.model.js
├── package.json
├── routes.js
└── server.js
/.gitignore:
--------------------------------------------------------------------------------
1 | .svn/
2 | .vscode/
3 | log/
4 | node_modules/
5 | smslog/*.csv
6 | jsconfig.json
7 | package-lock.json
8 | bulkemail/
9 | downloads/
10 | tsconfig.json
11 | **/*.ts
12 | **/*.d.ts
13 | **/*.js.map
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Dynamic database connection to mongoose from nodejs
2 |
3 | This example describes a multi-tenant structure with each user having its own database. There might be a better way of doing this,but this was my solution.
4 |
5 | There will be a user creation when the user creation is done in "AuthDB", then i create the New DataBase under UserName.
6 | There will be school model (schema), so user can create or update school info.
7 | I Will get the DB Name from the header(token) and find the database to create or update School info.
8 | I also check that if the user info is already stored in global, there is no need to query the database again.
9 |
10 |
11 | ** Project installation details **
12 | Step 1 : npm install
13 | Step 2 : node server.js
14 |
15 | ** API Details **
16 |
17 | 1) To Create Admin user [Seperate DB]
18 | ```
19 | Method : POST
20 | URL : http://localhost:8085/api/createUser
21 | POST Data: {
22 | "UserName": "Test1",
23 | "Password": "1234"
24 | }
25 |
26 | Response : {
27 | "_id": "5b9f37e1132b1e172886cde5",
28 | "UserName": "Test1",
29 | "Password": "sha256$ad2ee88619dcaa82$1000$751cebd73e593b4adcf4c49ef148433c08afbff86fd16eaef6f6568f3eae3e4e",
30 | "DataBaseName": "Test1",
31 | "Role": "Admin",
32 | "__v": 0
33 | }
34 | ```
35 |
36 | 2) Login Admin User
37 | ```
38 | Method : POST
39 | URL : http://localhost:8085/api/create/school
40 | POST Data : {
41 | "UserName": "Test1",
42 | "Password": "1234"
43 | }
44 |
45 |
46 | Response : {
47 | "user": "Test1",
48 | "roles": "Admin",
49 | "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVc2VyTmFtZSI6IkRCMSIsIkNOYW1lIjoiREIxIiwiUGVybWlzc2lvbiI6WyJ1cGRhdGUiLCJnZXQgYWxsIHNjaG9vbCByZWNvcmQiLCJkZWxldGUiXSwiaWF0IjoxNTM3MTYwNzY2LCJpc3MiOiJLZW8gcGx1cyBMTVMifQ.YH6GNH4plWnPSBj2r7RdWzk_4cJFzkxJVvZZacD6vnk",
50 | "iss": "Keo plus LMS",
51 | "iat": "2018-09-17T05:06:06.186Z"
52 | }
53 | ```
54 |
55 | 3) To Create School - under Admin user DB
56 | ```
57 | Method : POST
58 | URL : http://localhost:8085/api/create/school
59 | Header : Authorization : Bearer token
60 | POST Data : {
61 | "SchoolName": "IG",
62 | "SchoolId": "10251",
63 | "DeanName": "Ravi"
64 | }
65 |
66 | Response : {
67 | "_id": "5b9f3751132b1e172886cde4",
68 | "SchoolName": "IG",
69 | "SchoolId": "10251",
70 | "DeanName": "Ravi",
71 | "__v": 0
72 | }
73 | ```
74 |
75 | 4) Get All schools in collection Admin Db [check routing : Permission]
76 | ```
77 | Method : GET
78 | URL : http://localhost:8085/api/getAllSchool
79 | Header : Authorization : Bearer token
80 |
81 | Response : [
82 | {
83 | "_id": "5b965dc9fc9aac18cce310c6",
84 | "SchoolName": "School1",
85 | "SchoolId": "12121",
86 | "DeanName": "Arul",
87 | "__v": 0
88 | }
89 | ]
90 | ```
91 |
--------------------------------------------------------------------------------
/commonservice/googleoauth.service.js:
--------------------------------------------------------------------------------
1 | var GoogleStrategy = require('passport-google-oauth20').Strategy;
2 | var passport = require('passport');
3 |
4 | //Testing
5 | passport.use(new GoogleStrategy({
6 | clientID: 's',
7 | clientSecret: 's',
8 | callbackURL: "s"
9 | },
10 | function (accessToken, refreshToken, profile, cb) {
11 | console.log(profile);
12 | console.log(accessToken);
13 | console.log(refreshToken);
14 | // cb();
15 | // User.findOrCreate({ googleId: profile.id }, function (err, user) {
16 | // console.log()
17 | // return cb(err, user);
18 | // });
19 | }
20 | ));
21 |
--------------------------------------------------------------------------------
/commonservice/jwtverify.js:
--------------------------------------------------------------------------------
1 | var jwt = require('jsonwebtoken');
2 | var config = require('../config.js');
3 |
4 | function jwtverify(req, next) {
5 | console.log("jwt verify.....")
6 | var header = req.get('Authorization');
7 | if (header) {
8 | DBName = `${config.Prefix}${jwtDecode(header).decodedToken.CName}`;
9 | } else {
10 | console.log("header not found.")
11 | return next();
12 | }
13 | return DBName;
14 | }
15 |
16 | function permission(req, res, next, permissions) {
17 | console.log("Checking permissions.....")
18 | var header = req.get('Authorization');
19 | if (header) {
20 | redisClient.HGETALL(jwtDecode(header).token, function (err, reply) {
21 | if (err) {
22 | return res.status(401).send('You are not an Authorized user.');
23 | }
24 | if (reply !== null && reply !== undefined && reply.Permission !== undefined) {
25 | console.log("redisdata");
26 | let redisdata = reply.Permission.split(',');
27 | console.log(redisdata);
28 | if (redisdata.indexOf(permissions) != -1) {
29 | console.log(redisdata.Permission);
30 | return next();
31 | } else {
32 | return res.status(401).send('You are not an Authorized user.');
33 | }
34 | } else {
35 | console.log("Test err..");
36 | return res.status(401).send('You are not an Authorized user.');
37 | }
38 |
39 | });
40 | /*
41 | if (jwtDecode(header).Permission !== undefined) {
42 | console.log(permissions);
43 | if (jwtDecode(header).Permission.indexOf(permissions) != -1) {
44 | console.log(jwtDecode(header).Permission);
45 | return next();
46 | } else {
47 | return res.status(401).send('You are not an Authorized user.');
48 | }
49 | } else {
50 | return res.status(401).send('You are not an Authorized user.');
51 | }
52 | */
53 | } else {
54 | return res.status(401).send('You are not an Authorized user.');
55 | }
56 | }
57 |
58 | function jwtDecode(header) {
59 | var jwtDecodeValue = {};
60 | var tokenType = header.split(' ')[0];
61 | var token = header.split(' ')[1];
62 |
63 | if (tokenType !== undefined && token !== undefined && tokenType !== '' && token !== '') {
64 | if (tokenType === 'Bearer') {
65 | jwt.verify(token, config.secret, { issuer: config.issuer }, function (err, decodedToken) {
66 | jwtDecodeValue.decodedToken = decodedToken;
67 | jwtDecodeValue.token = token
68 | })
69 | }
70 | }
71 | return jwtDecodeValue;
72 | }
73 |
74 | module.exports = {
75 | jwtverify,
76 | permission
77 | }
78 |
--------------------------------------------------------------------------------
/commonservice/mongoservice.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var mongoose = require('mongoose'),
3 | Admin = mongoose.mongo.Admin;
4 |
5 | var dataBaseSchema = require('../models/school.model');
6 |
7 | /**
8 | * 1. Connect local Mongo server and get all Database
9 | * 2. Match the DB name under username else create new DB
10 | * 3. Create Collection under new DB
11 | * @param {username} UserDbName
12 | */
13 | function createDB(UserDbName, cb) {
14 | var uri = 'mongodb://localhost:27017';
15 | var AdminDb = mongoose.createConnection(uri);
16 | AdminDb.on('open', function () {
17 | var dbExists;
18 | new Admin(AdminDb.db).listDatabases(function (err, result) {
19 | console.log('listDatabases succeeded');
20 | var allDatabases = result.databases;
21 | console.log(allDatabases);
22 | if (allDatabases.length > 0) {
23 | allDatabases.forEach((db) => {
24 | if (db.name == `Keo_${UserDbName}`) {
25 | console.log(`DB ${db.name} is already exits.`);
26 | dbExists = true;
27 | cb(true);
28 | }
29 | })
30 | if (!dbExists) {
31 | var newuri = `mongodb://localhost:27017/Keo_${UserDbName}`;
32 | console.log("Db Creating Process On...." + UserDbName)
33 | var NewUserDb = mongoose.createConnection(newuri);
34 | dataBaseSchema.createSchema(NewUserDb);
35 | AdminDb.close();
36 | cb(false);
37 | }
38 | }
39 | });
40 | });
41 | }
42 |
43 |
44 | module.exports = { createDB }
45 |
--------------------------------------------------------------------------------
/config.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var configObject = new Object();
3 | configObject.issuer = "Keo plus LMS",
4 | configObject.secret = 'Torches for tomorrow'; //Secret key for signing JWT.
5 | configObject.jwtExpiresOn = 86400; //Time in seconds (24 hours)
6 | configObject.jwtExpiredAt = 1; //no.of days
7 | configObject.Prefix = 'Keo_'; //no.of days
8 |
9 |
10 | configObject.redisDB = {
11 | DBHOST: '127.0.0.1',
12 | DBPORT: '6379'
13 | };
14 | module.exports = configObject;
15 |
16 |
--------------------------------------------------------------------------------
/controller/school.controller.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var jwt = require('../commonservice/jwtverify');
3 | /**
4 | * Create School in Particular User Database
5 | */
6 | module.exports.CreateSchool = function (req, res, next) {
7 | var School = DBConnectionsList[jwt.jwtverify(req)].studentModel;
8 | School.create(req.body, function (err, success) {
9 | if (err) {
10 | return res.status(402).send(err);
11 | }
12 | if (success) {
13 | return res.status(200).send(success);
14 | } else {
15 | return res.status(404).send('School not created.');
16 | }
17 | });
18 | };
19 |
20 | module.exports.getAllSchool = function (req, res, next) {
21 | var School = DBConnectionsList[jwt.jwtverify(req)].studentModel;
22 | School.find({}, function (err, user) {
23 | if (err) {
24 | return res.status(402).send(err);
25 | }
26 | if (user) {
27 | return res.status(200).send(user);
28 | }
29 | });
30 | }
31 |
32 | module.exports.getRedisServerData = function (req, res, next) {
33 | let token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVc2VyTmFtZSI6IkFydWwiLCJDTmFtZSI6IkRCMSIsIlBlcm1pc3Npb24iOlsidXBkYXRlIiwiZ2V0IGFsbCBzY2hvb2wgcmVjb3JkIiwiZGVsZXRlIl0sImlhdCI6MTUzNzI1OTQ4MywiaXNzIjoiS2VvIHBsdXMgTE1TIn0.N75JL4YEKEMZrZvSGdnSiAQpm_2G6VPRDyUVlAKTTog";
34 | redisClient.get(token, function (err, reply) {
35 | let data = JSON.parse(reply);
36 | console.log(typeof data);
37 | res.send(data.Permission);
38 | });
39 | }
--------------------------------------------------------------------------------
/controller/user.controller.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var mongoose = require('mongoose');
3 | require('../models/user.model');
4 | var mongo = require('../commonservice/mongoservice');
5 | var user = mongoose.model('UserModel');
6 | var jwt = require('jsonwebtoken');
7 | var config = require('../config.js');
8 | var Q = require('q');
9 | var passwordHasher = require('password-hash');
10 | var passport = require('passport');
11 | /**
12 | * Create New User and store in AuthDB
13 | * success -> create DataBase under UserName
14 | * error -> user not created
15 | */
16 | var passport = require('passport');
17 |
18 | module.exports.createClient = function (req, res, next) {
19 | var application = req.body;
20 |
21 | if (application) {
22 | mongo.createDB(req.body.UserName, function (result) {
23 | if (!result) {
24 | application.DataBaseName = req.body.UserName;
25 | application.Role = "Admin";
26 | application.Password = getHashedPassword(req.body.Password);
27 | user.create(application, function (err, success) {
28 | if (err) {
29 | return res.status(402).send(err);
30 | }
31 | if (success) {
32 | return res.status(200).send(success);
33 | } else {
34 | return res.status(404).send('User not created.');
35 | }
36 | });
37 | } else {
38 | return res.status(200).send("User Already Exists");
39 | }
40 | });
41 | } else {
42 | return res.status(400).send('Data not provide.');
43 | }
44 | };
45 |
46 |
47 | module.exports.createUser = function (req, res, next) {
48 | var application = req.body;
49 | if (application) {
50 | application.Password = getHashedPassword(req.body.Password);
51 | user.create(application, function (err, success) {
52 | if (err) {
53 | return res.status(402).send(err);
54 | }
55 | if (success) {
56 | return res.status(200).send(success);
57 | } else {
58 | return res.status(404).send('User not created.');
59 | }
60 | });
61 | } else {
62 | return res.status(400).send('Data not provide.');
63 | }
64 | };
65 |
66 | module.exports.userLogin = function (req, res, next) {
67 | var username = req.body.UserName;
68 | var password = req.body.Password;
69 | user.findOne({ 'UserName': new RegExp('^' + username + '$', "i") }, function (err, userinfo) {
70 | if (err) {
71 | return res.status(402).send(err);
72 | }
73 | if (userinfo) {
74 | if (passwordHasher.verify(password, userinfo.Password)) {
75 | if (userinfo.Role == 'Admin') {
76 | getJWTResult(username, userinfo.Role, userinfo.DataBaseName)
77 | .then((jwtResult) => {
78 | req.UserName = username;
79 | storeDatainRedisServer(jwtResult, function (result) {
80 | if (result) {
81 | return res.status(200).send(jwtResult);
82 | }
83 | })
84 | });
85 | } else {
86 | user.findOne({
87 | 'UserName': { $in: userinfo.organization }
88 | }, function (err, school) {
89 | if (err) {
90 | return res.status(402).send(err);
91 | }
92 | if (school) {
93 | getJWTResult(username, userinfo.Role, school.DataBaseName, userinfo.organization)
94 | .then((jwtResult) => {
95 | req.UserName = username;
96 | storeDatainRedisServer(jwtResult, function (result) {
97 | if (result) {
98 | return res.status(200).send(jwtResult);
99 | }
100 | })
101 | });
102 | } else {
103 | return res.status(402).send("organization not found");
104 | }
105 | })
106 | }
107 | } else {
108 | return res.status(400).send('Password is Invalid.');
109 | }
110 | } else {
111 | return res.status(404).send('UserName not Vaild.');
112 | }
113 | });
114 | }
115 |
116 | function storeDatainRedisServer(jwtResult, callback) {
117 | console.log("Redis Server...");
118 | var testredisData = {
119 | "accessToken": jwtResult.accessToken,
120 | "Permission": ["Update", "get all school record"].toString()
121 | }
122 | console.log("Redis Server 0...");
123 | jwtResult.organization.forEach(function (Obj) {
124 | testredisData[Obj] = false;
125 | });
126 |
127 | console.log(testredisData);
128 | console.log("Redis Server 1...");
129 | redisClient.HMSET(jwtResult.accessToken, testredisData);
130 | console.log("Redis Server 2...");
131 | callback(true);
132 | }
133 |
134 | //Generate JWT Token
135 | function getJWT(userId, DataBaseName) {
136 | var accessToken = jwt.sign({ 'UserName': userId, 'CName': DataBaseName, 'Permission': ['update', 'get all school record', 'delete'] }, config.secret,
137 | {
138 | algorithm: "HS256",
139 | issuer: config.issuer
140 | });
141 | return accessToken;
142 | }
143 |
144 | //Generate JWT response
145 | function buildJWTResponse(userId, roles, DataBaseName, organization) {
146 | console.log(organization);
147 | var JWTResponseObject = new Object();
148 | var accessToken = getJWT(userId, DataBaseName);
149 | JWTResponseObject.user = userId;
150 | JWTResponseObject.roles = roles;
151 | JWTResponseObject.organization = organization;
152 | JWTResponseObject.accessToken = accessToken;
153 | JWTResponseObject.iss = 'Keo plus LMS';
154 | JWTResponseObject.iat = new Date();
155 | return JWTResponseObject;
156 | }
157 |
158 | function getJWTResponse(userId, roles, DataBaseName, organization, callback) {
159 | //Build AccessTokenModelObject
160 | var JWTResponseObject = buildJWTResponse(userId, roles, DataBaseName, organization);
161 | var accessTokenModelObject = new Object();
162 | accessTokenModelObject.UserName = userId;
163 | accessTokenModelObject.AccessToken = JWTResponseObject.accessToken;
164 | accessTokenModelObject.IssuedAt = JWTResponseObject.iat;
165 | callback(null, JWTResponseObject);
166 | }
167 |
168 | function getJWTResult(username, role, dataBaseName, organization) {
169 | var deferred = Q.defer();
170 | getJWTResponse(username, role, dataBaseName, organization, function (err, JWTResponse) {
171 | if (err) {
172 | deferred.reject(err);
173 | }
174 | if (JWTResponse) {
175 | deferred.resolve(JWTResponse);
176 | } else {
177 | deferred.reject();
178 | }
179 | });
180 | return deferred.promise;
181 | }
182 |
183 | //Password hashing
184 | function getHashedPassword(plainPassword) {
185 | var options = new Object();
186 | options.algorithm = 'sha256';
187 | options.saltLength = 128 / 8;
188 | options.iterations = 1000;
189 | return passwordHasher.generate(plainPassword, options);
190 | }
191 |
--------------------------------------------------------------------------------
/middleware/middleware.js:
--------------------------------------------------------------------------------
1 | var mongoose = require('mongoose');
2 | var dataBaseSchema = require('../models/school.model');
3 | var jwt = require('jsonwebtoken');
4 | var config = require('../config.js');
5 |
6 | //Object holding all your connection strings.
7 | global.DBConnectionsList = {};
8 |
9 | /**
10 | * 1. Get DB Name from the header part.
11 | * 2. Check the DB Connection is avaliable in 'DBConnectionsList' else Create new DBconnection.
12 | * 3. After creating new Connection Load All models under db connection and store it 'DBConnectionsList'.
13 | */
14 | var authorizeDB = function (req, res, next) {
15 | console.log("User Db Connection Process.....")
16 |
17 | //Get DB name from the header(token).
18 | var header = req.get('Authorization');
19 | if (!header) {
20 | return next();
21 | // res.status(400).send('User header not found.');
22 | }
23 |
24 | //Check the DB Connection is avaliable in 'DBConnectionsList'else Create new DBconnection.
25 | if (header) {
26 | console.log("Authorization header verified.");
27 | var tokenType = header.split(' ')[0];
28 | var token = header.split(' ')[1];
29 | if (tokenType !== undefined && token !== undefined && tokenType !== '' && token !== '') {
30 | if (tokenType === 'Bearer') {
31 | jwt.verify(token, config.secret, { issuer: config.issuer }, function (err, decodedToken) {
32 | if (err) {
33 | return res.status(401).send('You are not an Authorized user.');
34 | }
35 | if (decodedToken.CName) {
36 | var dbName = `${config.Prefix}${decodedToken.CName}`;
37 | if (DBConnectionsList[dbName]) {
38 | console.log("DB in Connection List.....");
39 | return next();
40 | } else {
41 | DBConnectionsList[dbName] = mongoose.createConnection('mongodb://localhost:27017/' + dbName);
42 | //Load All models under db connection and store it 'DBConnectionsList'.
43 | DBConnectionsList[dbName]['studentModel'] = dataBaseSchema.createSchema(DBConnectionsList[dbName]);
44 | console.log("New DB added in Connection List.....");
45 | return next();
46 | }
47 | } else {
48 | return res.status(401).send('You are not an Authorized user.');
49 | }
50 | })
51 | } else {
52 | return res.status(401).send('You are not an Authorized user.');
53 | }
54 | } else {
55 | return res.status(401).send('You are not an Authorized user.');
56 | }
57 | } else {
58 | return next();
59 | }
60 | };
61 |
62 | module.exports = { authorizeDB };
63 |
64 |
65 |
--------------------------------------------------------------------------------
/models/homework.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var mongoose = require('mongoose');
3 | var HomeWorkSchema = mongoose.Schema;
4 |
5 |
6 | function createSchema(connection) {
7 | var HomeWorkModel = new HomeWorkSchema({
8 | SchoolName: {
9 | type: String,
10 | required: [true, 'User required.'],
11 | trim: true,
12 | unique: true
13 | },
14 | DeanName: {
15 | type: String,
16 | trim: true
17 | },
18 | Email: {
19 | type: String,
20 | trim: true
21 | },
22 | SchoolId: [{
23 | type: Schema.ObjectId,
24 | ref: 'SchoolModel'
25 | }],
26 | }, { versionkey: false, collection: 'homework' });
27 | return connection.model('HomeWorkModel', HomeWorkModel);
28 | }
29 |
30 | module.exports = {
31 | createSchema: createSchema
32 | }
33 |
--------------------------------------------------------------------------------
/models/school.model.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var mongoose = require('mongoose');
3 | var SchoolSchema = mongoose.Schema;
4 |
5 |
6 | function createSchema(connection) {
7 | var SchoolModel = new SchoolSchema({
8 | SchoolName: {
9 | type: String,
10 | required: [true, 'User required.'],
11 | trim: true,
12 | unique: true
13 | },
14 | SchoolId: {
15 | type: String,
16 | trim: true
17 | },
18 | DeanName: {
19 | type: String,
20 | trim: true
21 | },
22 | Email: {
23 | type: String,
24 | trim: true
25 | }
26 | }, { versionkey: false, collection: 'school' });
27 | return connection.model('SchoolModel', SchoolModel);
28 | }
29 |
30 | module.exports = {
31 | createSchema: createSchema
32 | }
33 |
34 |
--------------------------------------------------------------------------------
/models/user.model.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var mongoose = require('mongoose');
3 | var UserSchema = mongoose.Schema;
4 |
5 |
6 | var UserModel = new UserSchema({
7 |
8 | UserName: {
9 | type: String,
10 | required: [true, 'User required.'],
11 | trim: true,
12 | unique: true
13 | },
14 | Password: {
15 | type: String,
16 | required: [true, 'Password required.'],
17 | trim: true
18 | },
19 | DataBaseName: {
20 | type: String,
21 | trim: true
22 | },
23 | Role: {
24 | type: String,
25 | trim: true
26 | },
27 | organization: [{
28 | type: String,
29 | trim: true
30 | }]
31 | }, { versionkey: false, collection: 'userlogin' });
32 | mongoose.model('UserModel', UserModel);
33 |
34 |
35 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "node_auth",
3 | "version": "1.0.0",
4 | "description": "",
5 | "main": "server.js",
6 | "scripts": {
7 | "test": "echo \"Error: no test specified\" && exit 1"
8 | },
9 | "author": "",
10 | "license": "ISC",
11 | "dependencies": {
12 | "body-parser": "^1.18.3",
13 | "express": "^4.16.3",
14 | "find": "^0.2.9",
15 | "glob": "^7.1.3",
16 | "jsonwebtoken": "^8.3.0",
17 | "mongoose": "^5.2.12",
18 | "passport": "^0.4.0",
19 | "passport-google-oauth20": "^1.0.0",
20 | "password-hash": "^1.2.2",
21 | "q": "^1.5.1",
22 | "redis": "^2.8.0"
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/routes.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Over All router config
3 | * @param {*} router
4 | */
5 | var authServer = require('./commonservice/jwtverify');
6 |
7 | module.exports = function (router) {
8 | //Routing for User Creation
9 | var userinfo = require('./controller/user.controller')
10 | router.post('/createClient', userinfo.createClient);
11 | router.post('/createUser', userinfo.createUser);
12 | router.post('/login', userinfo.userLogin);
13 |
14 | //Routing for School Creation
15 | var school = require('./controller/school.controller')
16 | router.post('/create/school', school.CreateSchool);
17 | router.get('/getAllSchool', permission('get all school record'), school.getAllSchool);
18 |
19 | router.get('/getRedisData', school.getRedisServerData);
20 | }
21 |
22 | var permission = function (permissions) {
23 | return function (req, res, next) {
24 | authServer.permission(req, res, next, permissions);
25 | };
26 | };
27 |
28 |
29 |
--------------------------------------------------------------------------------
/server.js:
--------------------------------------------------------------------------------
1 | var express = require('express')
2 | var app = express()
3 | const mongoose = require('mongoose');
4 | var bodyParser = require('body-parser')
5 | var router = express.Router();
6 | var dynamicDB = require('./middleware/middleware');
7 | var passportconfig = require('./commonservice/googleoauth.service');
8 | var redis = require("redis");
9 | var config = require('./config');
10 |
11 | var redisURI = 'redis://' + config.redisDB.USERNAME + '@' + config.redisDB.DBHOST + ':' + config.redisDB.DBPORT;
12 | var redisClient = redis.createClient(redisURI);
13 | redisClient.on("error", function (err) {
14 | console.log("Error in redis Connection:" + err);
15 | });
16 | redisClient.on('connect', function () {
17 | console.log('Connected to redis...');
18 | });
19 | global.redisClient = redisClient;
20 |
21 |
22 | //Auth Db Connection
23 | var url = "mongodb://localhost:27017/AuthDB";
24 |
25 | mongoose.connect(url, { useNewUrlParser: true });
26 | var authDB = mongoose.connection;
27 | authDB.on('error', function connectionError(err) {
28 | console.log("error connecting authentication database:- " + err);
29 | });
30 | authDB.once('open', function connectionSuccess() {
31 | console.log('Authentication database connected.');
32 | });
33 | authDB.on('disconnected', () => {
34 | console.log(`Authentication database Disconnected.\n`.bold.red);
35 | });
36 | //End Auth Db connection
37 |
38 | //middleware : Find the DB Name from token and connect db.
39 | app.use(dynamicDB.authorizeDB);
40 |
41 | require('./routes')(router);
42 |
43 | app.use(bodyParser.urlencoded({ extended: true }));
44 | app.use(bodyParser.json());
45 | app.use(function (req, res, next) {
46 | res.setHeader('Access-Control-Allow-Origin', '*'); //Enable CORS
47 | res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
48 | res.setHeader('Access-Control-Allow-Methods', 'GET, POST');
49 | next();
50 | });
51 |
52 | app.use('/api', router);
53 |
54 | app.use(errorHandler);
55 |
56 | function errorHandler(err, req, res, next) {
57 | console.log("..Error Handler..")
58 | var ip = req.headers['x-forwarded-for'] ||
59 | req.connection.remoteAddress ||
60 | req.socket.remoteAddress ||
61 | req.connection.socket.remoteAddress;
62 | if (err.name === 'ValidationError') {
63 | return res.status(400).send(err);
64 | }
65 | return res.status(500).send(err);
66 | }
67 |
68 | app.listen(8085, function () {
69 | console.log("Server started : http://localhost:8085");
70 | })
71 |
72 |
--------------------------------------------------------------------------------