├── .DS_Store
├── .gitignore
├── Procfile
├── README.md
├── app.js
├── controllers
    ├── allControllers.js
    ├── authController.js
    └── helper.js
├── middleware
    └── authMiddleware.js
├── models
    ├── Balance.js
    ├── User.js
    └── Webhook.js
├── package-lock.json
├── package.json
├── public
    ├── smoothie.png
    └── styles.css
├── routes
    └── authRoutes.js
└── views
    ├── alltransactions.ejs
    ├── balances (copy).ejs
    ├── balances.ejs
    ├── dashboard.ejs
    ├── home.ejs
    ├── index.html
    ├── login.ejs
    ├── monoreauth.ejs
    ├── partials
        ├── footer.ejs
        ├── header.ejs
        ├── mono_dialog.ejs
        ├── mono_reauth_dialog.ejs
        ├── sidebar.ejs
        └── sidebar_end.ejs
    ├── signup.ejs
    └── transactions.ejs


/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/withmono/mono-data-sync-demo/719be4ff125b740790fec6dbab7156a9b03cfc01/.DS_Store


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /node_modules
2 | .env


--------------------------------------------------------------------------------
/Procfile:
--------------------------------------------------------------------------------
1 | web: node app.js


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Mono-Connect API Implementation
 2 | 
 3 | ## Quick Links
 4 | 
 5 | [1. Overview](#1-overview) 
 6 | 
 7 | [2. Implementation](#2-implementation) 
 8 | 
 9 | [3. Installation](#3-installation)  
10 | 
11 | 
12 | ## 1. Overview  
13 | 
14 | Project #sweet-loans [(link)](https://sweet-loans.herokuapp.com/) is a simple web application that allows its users to connect their financial account, see their information, transactions, balances and also fetch real time data that happens on their financial account.  
15 | It is built with NodeJS Express, which basically implements the core features of the Mono-Connect [API](https://docs.mono.co/reference).
16 | 
17 | ### Walkthrough <br />
18 | 1. The web application has a basic authentication system, where a user can [Login](https://sweet-loans.herokuapp.com/login), [Signup](https://sweet-loans.herokuapp.com/signup) and Logout of the system. <br />
19 | 2. Once signed in, a user is faced with a dashboard where he has to link his account through the mono widget. <br />
20 | 3. On successful linkup, the page forces reload and fetches all the user's connected information right on the dashboard.<br />
21 | 4. Also from the side navigation, a user can view his account balance, his recent transaction history, and then all transaction histories with pagination.<br />
22 | 5. Lastly, you can force refresh by Data syncing manually on the Balances page. <br />
23 | 
24 | ## 2. Implementation  
25 | 1. Firstly, the application has Mono's widget [embedded](https://github.com/kingkenway/mono/blob/master/views/partials/mono_dialog.ejs#L1), for users to connect their bank account. Once successful, the application retrieves a <b>code</b>  sent by Mono.  <br />
26 | 
27 | 2. After user has his/her account connected successfully, his <b>Mono ID.</b> is needed which leads to the application making a request with the provided code in 1, to Mono's Authentication Endpoint -> https://api.withmono.com/account/auth through POST Method [here](https://github.com/kingkenway/mono/blob/master/controllers/allControllers.js#L32) <br />
28 | 
29 | 3. Once the user's <b>Mono ID.</b> is fetched and stored in the db, his connected user information is immediately fetched and loaded on the dashboard through Mono's API Identity Endpoint -> https://api.withmono.com/accounts/id/identity through GET Method right [here](https://github.com/kingkenway/mono/blob/master/controllers/allControllers.js#L8) <br />
30 | 
31 | 4. The user can view his account balance through Mono's API Information Endpoint -> https://api.withmono.com/accounts/id through GET Method right [here](https://github.com/kingkenway/mono/blob/master/controllers/allControllers.js#L69) <br />
32 | 
33 | 5. The user views his recent (last 20) transactions, through Mono's API transaction Endpoint -> https://api.withmono.com/accounts/id/transaction through GET Method right [here](https://github.com/kingkenway/mono/blob/master/controllers/allControllers.js#L92) <br />
34 | 
35 | 6. Also, all transaction history with pagination is viewed, through Mono's API transaction Endpoint -> https://api.withmono.com/accounts/id/transaction?page=1 through GET Method right [here](https://github.com/kingkenway/mono/blob/master/controllers/allControllers.js#L121) <br />
36 | 
37 | 7. Lastly, you can force refresh by Data syncing manually, which can be triggered with the button displayed on the Balances page. 
38 | 
39 | You can register [here](https://sweet-loans.herokuapp.com/signup) to give this application a shot.
40 | 
41 | ## 3. Installation
42 | 
43 | The first thing to do is to clone the repository:
44 | 
45 | ```sh
46 | $ git clone https://github.com/kingkenway/mono.git
47 | $ cd mono
48 | ```
49 | 
50 | ## Local Environment Variables  
51 | Ensure you have your .env file created in the root directory, with the following parameters provided:
52 | 
53 | DATABASE_URL='Your Mongo DB URL'  
54 | MONO_SECRET_KEY='Your Mono Secret Key on your dashboard'  
55 | MONO_PUBLIC_KEY='Your Mono Public Key on your dashboard'  
56 | MONO_WEBHOOK_SEC='Your Mono Webhook Secret Key on your dashboard'  
57 | TOKEN='A random key identifier for JWT Verification'
58 | 
59 | ## Project setup
60 | ```
61 | npm install
62 | ```
63 | 
64 | ### Compiles and hot-reloads for development
65 | ```javascript
66 | npm start
67 | ```


--------------------------------------------------------------------------------
/app.js:
--------------------------------------------------------------------------------
 1 | const express = require('express');
 2 | const mongoose = require('mongoose');
 3 | const cookieParser = require('cookie-parser');
 4 | const authRoutes = require('./routes/authRoutes');
 5 | const { requireAuth, checkUser, verifyWebhook, requireMonoReauthToken } = require('./middleware/authMiddleware');
 6 | const controllers = require('./controllers/allControllers');
 7 | const moment = require('moment');
 8 | 
 9 | const port = process.env.PORT || 8000
10 | 
11 | require('dotenv').config();
12 | 
13 | const app = express();
14 | 
15 | app.locals.getPage = function(page) {
16 |   const page_number = page.split("page=")[1];
17 |     return `?page=${page_number}`
18 | }
19 | 
20 | app.locals.setCurrency = function(amount) {
21 |   let res = parseFloat(amount)*0.01  // Convert to naira from kobo
22 |   return res.toLocaleString()
23 | }
24 | 
25 | app.locals.formatTime = function(time) {
26 |   return moment(time).format("DD-MM-YYYY h:mm:ss");
27 | }
28 | 
29 | // middleware
30 | app.use(express.static('public'));
31 | app.use(express.json());
32 | app.use(cookieParser());
33 | 
34 | // view engine
35 | app.set('view engine', 'ejs');
36 | 
37 | // database connection
38 | const dbURI = process.env['DATABASE_URL'];
39 | mongoose.connect(dbURI, { useNewUrlParser: true, useUnifiedTopology: true, useCreateIndex:true })
40 |   .then((result) => {
41 |   	console.log(`Launched @ port ${port}`);
42 |   	app.listen(port);
43 |   })
44 |   .catch((err) => console.log(err));
45 | 
46 | // routes
47 | app.get('*', checkUser);
48 | app.get('/', (req, res) => res.render('home'));
49 | 
50 | app.get('/dashboard', requireAuth, requireMonoReauthToken, controllers.dashboard, (req, res) => res.render('dashboard'));
51 | 
52 | app.post('/dashboard', controllers.dashboardPost);
53 | 
54 | app.get('/manualsync', controllers.manualSync);
55 | 
56 | app.get('/balances', requireAuth, requireMonoReauthToken, controllers.balances, (req, res) => res.render('balances'));
57 | 
58 | app.get('/transactions', requireAuth, requireMonoReauthToken, controllers.transactions, (req, res) => res.render('transactions'));
59 | 
60 | app.get('/alltransactions', requireAuth, requireMonoReauthToken, controllers.alltransactions, (req, res) => res.render('alltransactions'));
61 | 
62 | app.get('/monoReauth', requireAuth, (req, res) => res.render('monoreauth'));
63 | 
64 | app.post('/monoReauth', controllers.monoReauth);
65 | 
66 | app.post('/webhook', verifyWebhook, controllers.webhook);
67 | 
68 | 
69 | // app.get('/force-refresh', requireAuth, (req, res) => res.render('smoothies'));
70 | app.use(authRoutes);


--------------------------------------------------------------------------------
/controllers/allControllers.js:
--------------------------------------------------------------------------------
  1 | const fetch = require('node-fetch');
  2 | const User = require('../models/User');
  3 | const Balance = require('../models/Balance');
  4 | const WebH = require('../models/Webhook');
  5 | const {isDataAvailable} = require('../controllers/helper');
  6 | 
  7 | module.exports.dashboard = async (req,res, next) => {
  8 | 
  9 | 	if(res.locals.data.user.monoId){
 10 | 
 11 | 		const url = `https://api.withmono.com/accounts/${res.locals.data.user.monoId}/identity`
 12 | 
 13 | 		const response = await fetch(url, { 
 14 | 			method: 'GET', 
 15 | 			headers: {
 16 | 				'Content-Type': 'application/json',
 17 | 				'mono-sec-key': process.env['MONO_SECRET_KEY']
 18 | 			}
 19 | 		});
 20 | 
 21 | 		const data = await response.json();
 22 | 		res.locals.dashboard = data;
 23 | 
 24 | 		next();
 25 | 	}else{
 26 | 		next();
 27 | 	}
 28 | 
 29 | }
 30 | 
 31 | module.exports.dashboardPost = async (req,res, next) => {
 32 | 	// Retrieve code and user id from front end
 33 | 	const { code, id } = req.body;
 34 | 
 35 | 	url = "https://api.withmono.com/account/auth";
 36 | 
 37 | 	if(code){
 38 | 		// Retrieve mono id from front end
 39 | 		const response = await fetch(url, { 
 40 | 			method: 'POST',
 41 | 			body: JSON.stringify({ code }),
 42 | 			headers: {
 43 | 				'Content-Type': 'application/json',
 44 | 				'mono-sec-key': process.env['MONO_SECRET_KEY']
 45 | 			}
 46 | 		}).then(res_ => res_.json())
 47 | 		  .then(function (res_) {
 48 | 
 49 | 			const dispatch = {
 50 | 				$set: {
 51 | 					monoId: res_.id,
 52 | 					monoCode: code,
 53 | 					monoStatus: false
 54 | 				}
 55 | 			}
 56 | 			
 57 | 			// Update collection with mono id and code
 58 | 			User.updateOne({_id: id}, dispatch, {new: true}, function(err, res) {});
 59 | 			// Create instance in our balance collection
 60 | 			Balance({ monoId: res_.id }).save();
 61 | 			
 62 | 			res.status(200).json('done')
 63 | 		  })  
 64 | 		  .catch(err => res.status(501).send("Error fetching id"));
 65 | 
 66 | 		  
 67 | 	}else{
 68 | 		res.status(500).json({ error: "Error somewhere" })
 69 | 	}
 70 | 
 71 | 
 72 | 	
 73 | 	// next();
 74 | }
 75 | 
 76 | 
 77 | module.exports.balances = async (req,res, next) => {
 78 | 	if(res.locals.data.user.monoId){
 79 | 		const url = `https://api.withmono.com/accounts/${res.locals.data.user.monoId}`
 80 | 
 81 | 		const response = await fetch(url, { 
 82 | 			method: 'GET', 
 83 | 			headers: {
 84 | 				'Content-Type': 'application/json',
 85 | 				'mono-sec-key': process.env['MONO_SECRET_KEY']
 86 | 			}
 87 | 		});
 88 | 
 89 | 		const data = await response.json();
 90 | 		res.locals.balances = data;
 91 | 		next();
 92 | 	}
 93 | 	else{
 94 | 		res.locals.balances = ""
 95 | 		next();
 96 | 	}
 97 | }
 98 | 
 99 | module.exports.transactions = async (req,res, next) => {
100 | 	if(res.locals.data.user.monoId){
101 | 
102 | 		if (await isDataAvailable(res.locals.data.user.monoId)) {
103 | 
104 | 			const url = req.query.page || `https://api.withmono.com/accounts/${res.locals.data.user.monoId}/transactions`
105 | 
106 | 			const response = await fetch(url, { 
107 | 				method: 'GET', 
108 | 				headers: {
109 | 					'Content-Type': 'application/json',
110 | 					'mono-sec-key': process.env['MONO_SECRET_KEY']
111 | 				}
112 | 			});
113 | 
114 | 			const data = await response.json();
115 | 			res.locals.transactions = data;
116 | 			next();
117 | 		
118 | 		}
119 | 
120 | 		res.locals.transactions = "PROCESSING";
121 | 		next()
122 | 
123 | 	}
124 | 	else{
125 | 		res.locals.transactions = null;
126 | 		next();
127 | 	}
128 | 
129 | }
130 | 
131 | module.exports.alltransactions = async (req,res, next) => {
132 | 	
133 | 	if(res.locals.data.user.monoId){
134 | 		
135 | 		// Check if data is still processing
136 | 		if (await isDataAvailable(res.locals.data.user.monoId)) {
137 | 
138 | 			let url = `https://api.withmono.com/accounts/${res.locals.data.user.monoId}/transactions`	
139 | 			let page = req.query.page || 1
140 | 			let finalUrl = url + `?page=${page}`
141 | 
142 | 			const response = await fetch(finalUrl, { 
143 | 				method: 'GET', 
144 | 				headers: {
145 | 					'Content-Type': 'application/json',
146 | 					'mono-sec-key': process.env['MONO_SECRET_KEY']
147 | 				}
148 | 			});
149 | 
150 | 			const data = await response.json();
151 | 			res.locals.transactions = data;
152 | 			next();			
153 | 		}
154 | 
155 | 		res.locals.transactions = "PROCESSING";
156 | 		next()
157 | 
158 | 	}
159 | 	else{
160 | 		res.locals.transactions = null;
161 | 		next();
162 | 	}
163 | 
164 | }
165 | 
166 | module.exports.reauthorise = async function(id){
167 | 		let url = `https://api.withmono.com/accounts/${id}/reauthorise`	
168 | 
169 | 		const response = await fetch(url, { 
170 | 			method: 'POST', 
171 | 			headers: {
172 | 				'Content-Type': 'application/json',
173 | 				'mono-sec-key': process.env['MONO_SECRET_KEY']
174 | 			}
175 | 		});
176 | 
177 | 		const data = await response.json();
178 | 
179 | 		return data.token;
180 | }
181 | 
182 | // NOTE
183 | // This feature is only available to select partners. Reach out to us on slack about your product feature and why this should be enabled for your business.
184 | 
185 | // By default, all connected accounts are automatically refreshed once every 24 hours.
186 | // You can contact us at hi@mono.co if you want to change the update frequency to:
187 | 
188 | // 6h, all connected accounts will be refreshed every 6h (4 times a day)
189 | // 12h, all connected accounts will be refreshed every 12h (2 times a day)
190 | 
191 | module.exports.webhook = async (req,res, next) => {
192 | 
193 | 	const webhook = req.body;
194 | 
195 | 	if (webhook.event == "mono.events.account_updated") {
196 | 		await WebH.create({test: "updated"});
197 | 
198 | 		if (webhook.data.meta.data_status == "AVAILABLE") { // AVAILABLE, PROCESSING, FAILED
199 | 			
200 | 			const data = webhook.data.account;
201 | 
202 | 			// You can update your records on success
203 | 
204 | 			const query = {
205 | 				monoId: data._id
206 | 			};
207 | 
208 | 			const result = {
209 | 				$set: {
210 | 					monoId: data._id,
211 | 					institution: data.institution.name, // name:bankCode:type
212 | 					name: data.name,
213 | 					accountNumber: data.accountNumber,
214 | 					type: data.type,
215 | 					currency: data.currency,
216 | 					balance: data.balance,
217 | 					bvn: data.bvn
218 | 				}
219 | 			}
220 | 
221 | 			await Balance.updateOne(query, result, {new: true}, function(err, res) {});
222 | 
223 | 			await WebH.create({test: "updated___available_id: "+data._id});
224 | 
225 | 			// webhook.data.account
226 | 		}
227 | 		else if (webhook.data.meta.data_status == "PROCESSING") {
228 | 			await WebH.create({test: "updated___processing"});
229 | 			// Lol! Just chill and wait
230 | 		}
231 | 	}
232 | 
233 | 	else if (webhook.event == "mono.events.reauthorisation_required") {
234 | 		// webhook.data.account._id
235 | 
236 | 		// You can retrieve your token here for re-authentication
237 | 		// reauthorise(webhook.data.account._id)
238 | 		const query = {
239 | 			monoId: data._id
240 | 		};
241 | 
242 | 		const result = {
243 | 			$set: {
244 | 				monoStatus: true,
245 | 			}
246 | 		}
247 | 
248 | 		await User.updateOne(query, result, {new: true}, function(err, res) {});
249 | 
250 | 		await WebH.create({test: "reauthorisation_required"});
251 | 
252 | 	}
253 | 
254 | 	else if (webhook.event == "mono.events.account_reauthorized") {
255 | 		// webhook.data.account._id
256 | 
257 | 		// Account Id. will be sent on successful reauthorisation. Nothing much to do here.
258 | 		await WebH.create({test: "account_reauthorized"});
259 | 
260 | 	}
261 | 
262 |     return res.sendStatus(200);
263 | 	
264 | }
265 | 
266 | module.exports.manualSync = async (req,res, next) => {
267 | 
268 | 	if(res.locals.data.user.monoId){
269 | 		const url = `https://api.withmono.com/accounts/${res.locals.data.user.monoId}/sync`
270 | 
271 | 		// console.log(123412345);
272 | 
273 | 		const response = await fetch(url, { 
274 | 			method: 'GET', 
275 | 			headers: {
276 | 				'Content-Type': 'application/json',
277 | 				'mono-sec-key': process.env['MONO_SECRET_KEY']
278 | 			}
279 | 		});
280 | 
281 | 		const data = await response.json();
282 | 
283 | 		console.log(data);
284 | 		// res.locals.dashboard = data;
285 | 
286 | 		next();
287 | 	}else{
288 | 		next();
289 | 	}
290 | 
291 | }
292 | 
293 | 
294 | module.exports.monoReauth = async (req,res, next) => {
295 | 
296 | 	const query = {
297 | 		monoId: req.body.id
298 | 	};
299 | 
300 | 	const result = {
301 | 		$set: {
302 | 			monoStatus: true,
303 | 		}
304 | 	}
305 | 
306 | 	await User.updateOne(query, result, {new: true}, function(err, res) {});
307 | 	
308 | 	res.status(201).json({status: "redirect"});
309 | 	
310 | }


--------------------------------------------------------------------------------
/controllers/authController.js:
--------------------------------------------------------------------------------
 1 | const User = require('../models/User');
 2 | const Balance = require('../models/Balance');
 3 | const jwt = require('jsonwebtoken');
 4 | 
 5 | // JWT and Cookie expiry
 6 | const maxAge = 3*24*60*60;
 7 | 
 8 | // handle errors
 9 | const handleErrors = (err) => {
10 | 	let errors = { email: '', password: '' };
11 | 
12 | 	// handle login errors
13 | 	if (err.message === 'incorrect email') {
14 | 		errors.email ="This email is not registered"
15 | 	}
16 | 
17 | 	if (err.message === 'incorrect password') {
18 | 		errors.password ="Wrong password"
19 | 	}
20 | 
21 | 	// duplicate error code
22 | 	if (err.code === 11000) {
23 | 		errors.email = "Email is already taken.";
24 | 		return errors;
25 | 	}
26 | 
27 | 	// validation errors
28 | 	if (err.message.includes('user validation failed')) {
29 | 		Object.values(err.errors).forEach(({properties}) => {
30 | 			errors[properties.path] = properties.message;
31 | 		})
32 | 	}
33 | 	return errors;	
34 | }
35 | 
36 | const createToken = (id) =>{
37 | 	return jwt.sign({ id }, process.env['TOKEN'], {
38 | 		expiresIn: maxAge
39 | 	});
40 | }
41 | 
42 | module.exports.signup_get = (req,res) => {
43 | 	res.render('signup');
44 | }
45 | 
46 | module.exports.login_get = (req,res) => {
47 | 	res.render('login');
48 | }
49 | 
50 | module.exports.signup_post = async (req,res) => {
51 | 	const { email, password } = req.body;
52 | 
53 | 	try{
54 | 		const user = await User.create({email, password});
55 | 		const token = createToken(user._id);
56 | 		res.cookie('jwt', token, { httpOnly: true, maxAge: maxAge * 1000 });
57 | 		// res.status(201).json(user);
58 | 		res.status(201).json({user: user._id});
59 | 	}
60 | 	catch(err){
61 | 		const errors = handleErrors(err);
62 | 		res.status(400).json({ errors });
63 | 	}
64 | }
65 | 
66 | module.exports.login_post = async (req,res) => {
67 | 	const { email, password } = req.body;
68 | 	
69 | 	try{
70 | 		const user = await User.login(email,password);
71 | 		const token = createToken(user._id);
72 | 		res.cookie('jwt', token, { httpOnly: true, maxAge: maxAge * 1000 });
73 | 		res.status(200).json({ user: user._id })
74 | 	}
75 | 	catch (err){
76 | 		const errors = handleErrors(err);
77 | 		res.status(400).json({ errors });
78 | 	}
79 | }
80 | 
81 | module.exports.logout_get = (req, res) => {
82 | 	res.cookie('jwt', '', { maxAge: 1 });
83 | 	res.redirect('/');
84 | }


--------------------------------------------------------------------------------
/controllers/helper.js:
--------------------------------------------------------------------------------
 1 | const fetch = require('node-fetch');
 2 | 
 3 | const isDataAvailable = async (id) => {
 4 | 	const response = await fetch(`https://api.withmono.com/accounts/${id}`, { 
 5 | 		method: 'GET', 
 6 | 		headers: {
 7 | 			'Content-Type': 'application/json',
 8 | 			'mono-sec-key': process.env['MONO_SECRET_KEY']
 9 | 		}
10 | 	});
11 | 	const data = await response.json();
12 | 	if (data.meta && data.meta.data_status == "AVAILABLE") {
13 | 		return true
14 | 	}return false
15 | }
16 | 
17 | module.exports = { isDataAvailable };


--------------------------------------------------------------------------------
/middleware/authMiddleware.js:
--------------------------------------------------------------------------------
 1 | const jwt = require('jsonwebtoken');
 2 | const User = require('../models/User');
 3 | const Balance = require('../models/Balance');
 4 | const {reauthorise} = require('../controllers/allControllers');
 5 | 
 6 | const secret = process.env.MONO_WEBHOOK_SEC;
 7 | 
 8 | const requireAuth = ( req, res, next) => {
 9 | 	const token = req.cookies.jwt;
10 | 
11 | 	// check if jwt exists & is verified
12 | 	if (token) {
13 | 		jwt.verify(token, process.env['TOKEN'], (err, decodedToken) => {
14 | 			if (err) {
15 | 				console.log(err.message);
16 | 				res.redirect('/login');
17 | 			}else{
18 | 				// console.log(decodedToken);
19 | 				next();
20 | 			}
21 | 		});
22 | 	}else{
23 | 		res.redirect('/login');
24 | 	}
25 | }
26 | 
27 | const checkUser = (req, res, next) => {
28 | 	const token = req.cookies.jwt;
29 | 
30 | 	if (token) {
31 | 		jwt.verify(token, process.env['TOKEN'], async (err, decodedToken) => {
32 | 			if (err) {
33 | 				console.log(err.message);
34 | 				res.locals.data = null;
35 | 				res.locals.reauth = null;
36 | 				next();
37 | 			}else{
38 | 				let monoBalance = ""
39 | 				let user = await User.findById(decodedToken.id)
40 | 				
41 | 				if (user && user['monoId']){
42 | 					monoBalance = await Balance.findOne({ monoId:user.monoId })
43 | 				}
44 | 
45 | 				res.locals.reauth = null;				
46 | 				res.locals.data = {
47 | 					user,
48 | 					monoBalance,
49 | 					publicKey: process.env['MONO_PUBLIC_KEY'],
50 | 					secretKey: process.env['MONO_SECRET_KEY']
51 | 				}
52 | 				
53 | 				next();
54 | 			}
55 | 		});
56 | 	}else{
57 | 		res.locals.data = null;
58 | 		res.locals.reauth = null;
59 | 		next();
60 | 	}
61 | }
62 | 
63 | const verifyWebhook = (req, res, next) => {
64 |     if (req.headers['mono-webhook-secret'] !== secret) {
65 |         return res.status(401).json({
66 |             message: "Unauthorized request."
67 |         });
68 |     }
69 | 
70 |     next();
71 | }
72 | 
73 | const requireMonoReauthToken = async ( req, res, next) => {
74 | 	if (res.locals.data.user.monoStatus) {
75 | 		const reauthoriseToken = await reauthorise(res.locals.data.user.monoId)
76 | 
77 | 		const query = {
78 | 			monoId: res.locals.data.user.monoId
79 | 		};
80 | 	
81 | 		const result = {
82 | 			$set: {
83 | 				monoReauthToken: reauthoriseToken,
84 | 			}
85 | 		}
86 | 	
87 | 		await User.updateOne(query, result, {new: true}, function(err, res) {});
88 | 
89 | 		// res.locals.reauth = reauthoriseToken
90 | 		res.redirect('/monoReauth');
91 | 	}else{
92 | 		next();
93 | 	}
94 | }
95 | 
96 | module.exports = { requireAuth, checkUser, verifyWebhook, requireMonoReauthToken };


--------------------------------------------------------------------------------
/models/Balance.js:
--------------------------------------------------------------------------------
 1 | const mongoose = require('mongoose');
 2 | 
 3 | // Create Schema
 4 | const balanceSchema = new mongoose.Schema({
 5 | 	monoId: {
 6 | 		type: String,
 7 |         default: ''
 8 | 	},
 9 | 	institution: {
10 | 		type: String,
11 |         default: ''
12 | 	},
13 |     name: {
14 | 		type: String,
15 |         default: ''
16 | 	},
17 | 	accountNumber: {
18 | 		type: String,
19 |         default: ''
20 | 	},
21 |     type: {
22 | 		type: String,
23 |         default: ''
24 | 	},
25 | 	currency: {
26 | 		type: String,
27 |         default: ''
28 | 	},
29 |     balance: {
30 | 		type: String,
31 |         default: ''
32 | 	},
33 | 	bvn: {
34 | 		type: String,
35 |         default: ''
36 | 	},
37 | },
38 | { timestamps: true }
39 | );
40 | 
41 | const Balance = mongoose.model('balance', balanceSchema);
42 | 
43 | module.exports = Balance;


--------------------------------------------------------------------------------
/models/User.js:
--------------------------------------------------------------------------------
 1 | const mongoose = require('mongoose');
 2 | const bcrypt = require('bcrypt');
 3 | const { isEmail } = require('validator');
 4 | 
 5 | 
 6 | // Create Schema
 7 | const userSchema = new mongoose.Schema({
 8 | 	email: {
 9 | 		type: String,
10 | 		required: [true, 'Please enter an email'],
11 | 		unique: true,
12 | 		lowercase: true,
13 | 		// validate: [(val) => {}, 'Please enter a valid email']
14 | 		validate: [isEmail, 'Please enter a valid email']
15 | 	},
16 | 	password: {
17 | 		type: String,
18 | 		required: [true, 'Please enter a password'],
19 | 		minlength: [6, 'Minimum password length is 6 characters']
20 | 	},
21 | 	monoId: {
22 | 		type: String,
23 | 		default: ''
24 | 	},
25 | 	monoCode: {
26 | 		type: String,
27 | 		default: ''
28 | 	},
29 | 	monoStatus: {
30 | 		type: Boolean,
31 | 		default: false
32 | 	},
33 | 	monoReauthToken: {
34 | 		type: String,
35 | 		default: ''
36 | 	},
37 | });
38 | 
39 | 
40 | // fire a function after doc saved to db
41 | // userSchema.post('save', function(doc, next) {
42 | // 	console.log('new user was C & S', doc);
43 | // 	next();
44 | // });
45 | 
46 | // fire a function after doc saved to db
47 | userSchema.pre('save', async function(next) {
48 | 	const salt = await bcrypt.genSalt();
49 | 	this.password = await bcrypt.hash(this.password, salt);
50 | 	// console.log('user about to be created', this);
51 | 	next();
52 | });
53 | 
54 | // Static method to login user
55 | userSchema.statics.login = async function(email, password) {
56 | 	const user = await this.findOne({ email });
57 | 	if (user) {
58 | 		const auth = await bcrypt.compare(password, user.password);
59 | 		if (auth) {
60 | 			return user;
61 | 		}
62 | 		throw Error('incorrect password');
63 | 	}
64 | 	throw Error('incorrect email');
65 | }
66 | 
67 | 
68 | const User = mongoose.model('user', userSchema);
69 | 
70 | module.exports = User;


--------------------------------------------------------------------------------
/models/Webhook.js:
--------------------------------------------------------------------------------
 1 | const mongoose = require('mongoose');
 2 | 
 3 | // Create Schema
 4 | const webhookSchema = new mongoose.Schema({
 5 | 	test: {
 6 | 		type: String,
 7 |         default: ''
 8 | 	},
 9 | 	createdAt: {
10 |         type: Date,
11 |         default: Date.now
12 |     }
13 | });
14 | 
15 | const Webhook = mongoose.model('webhook', webhookSchema);
16 | 
17 | module.exports = Webhook;


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "mono",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "app.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1",
 8 |     "start": "nodemon app.js"
 9 |   },
10 |   "author": "",
11 |   "license": "ISC",
12 |   "dependencies": {
13 |     "bcrypt": "^5.0.0",
14 |     "body-parser": "^1.19.0",
15 |     "cookie-parser": "^1.4.5",
16 |     "csurf": "^1.11.0",
17 |     "dotenv": "^8.2.0",
18 |     "ejs": "^3.1.5",
19 |     "express": "^4.17.1",
20 |     "jsonwebtoken": "^8.5.1",
21 |     "moment": "^2.29.1",
22 |     "mongoose": "^5.10.15",
23 |     "node-fetch": "^2.6.1",
24 |     "nodemon": "^2.0.6",
25 |     "validator": "^13.1.17"
26 |   },
27 |   "engines": {
28 |     "node": "12.16.3"
29 |   }
30 | }
31 | 


--------------------------------------------------------------------------------
/public/smoothie.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/withmono/mono-data-sync-demo/719be4ff125b740790fec6dbab7156a9b03cfc01/public/smoothie.png


--------------------------------------------------------------------------------
/public/styles.css:
--------------------------------------------------------------------------------
  1 | /* google fonts */
  2 | @import url('https://fonts.googleapis.com/css2?family=Quicksand:wght@300;400;500;600;700&display=swap');
  3 | 
  4 | body{
  5 |   margin: 20px 40px;
  6 |   font-size: 1.2rem;
  7 |   letter-spacing: 1px;
  8 |   background: #fafafa;
  9 | }
 10 | h1, h2, h3, h4, ul, li, a, p, input, label, button, div, footer{
 11 |   margin: 0;
 12 |   padding: 0;
 13 |   font-family: 'Quicksand', sans-serif;
 14 |   color: #444;
 15 | }
 16 | ul{
 17 |   list-style-type: none;
 18 | }
 19 | a{
 20 |   text-decoration: none;
 21 | }
 22 | nav{
 23 |   display: flex;
 24 |   justify-content: space-between;
 25 |   align-items: flex-end;
 26 |   margin-bottom: 40px;
 27 | }
 28 | nav ul{
 29 |   display: flex;
 30 |   align-items: center;
 31 | }
 32 | nav li{
 33 |   margin-left: 20px;
 34 | }
 35 | nav li a{
 36 |   text-transform: uppercase;
 37 |   font-weight: 700;
 38 |   font-size: 0.8em;
 39 |   display: block;
 40 |   padding: 10px 16px;
 41 |   letter-spacing: 2px;
 42 | }
 43 | .btn{
 44 |   border-radius: 36px;
 45 |   background: #FEE996;
 46 | }
 47 | form h2{
 48 |   font-size: 2.4em;
 49 |   font-weight: 900;
 50 |   margin-bottom: 40px;
 51 | }
 52 | form{
 53 |   width: 360px;
 54 |   margin: 0 auto;
 55 |   padding: 30px;
 56 |   box-shadow: 1px 2px 3px rgba(0,0,0,0.1);
 57 |   border-radius: 10px;
 58 |   background: white;
 59 | }
 60 | input{
 61 |   padding: 10px 12px;
 62 |   border-radius: 4px;
 63 |   border: 1px solid #ddd;
 64 |   font-size: 1em;
 65 |   width: 100%;
 66 | }
 67 | label{
 68 |   display: block;
 69 |   margin: 20px 0 10px;
 70 | }
 71 | button{
 72 |   margin-top: 30px;
 73 |   border-radius: 36px;
 74 |   background: #FEE996;
 75 |   border:0;
 76 |   text-transform: uppercase;
 77 |   font-weight: 700;
 78 |   font-size: 0.8em;
 79 |   display: block;
 80 |   padding: 10px 16px;
 81 |   letter-spacing: 2px;
 82 | }
 83 | .error{
 84 |   color: #ff0099;
 85 |   margin: 10px 2px;
 86 |   font-size: 0.8em;
 87 |   font-weight: bold;
 88 | }
 89 | header{
 90 |   display: flex;
 91 |   align-items: center;
 92 | }
 93 | header img{
 94 |   width: 250px;
 95 |   margin-right: 40px;
 96 | }
 97 | header h2{
 98 |   font-size: 3em;
 99 |   margin-bottom: 10px;
100 | }
101 | header h3{
102 |   font-size: 1.6em;
103 |   margin-bottom: 10px;
104 |   margin-left: 2px;
105 |   color: #999;
106 | }
107 | header .btn{
108 |   margin-top: 20px;
109 |   padding: 12px 18px;
110 |   text-transform: uppercase;
111 |   font-weight: bold;
112 |   display: inline-block;
113 |   font-size: 0.8em;
114 | }
115 | .recipes{
116 |   display: grid;
117 |   grid-template-columns: 1fr 1fr 1fr;
118 |   column-gap: 30px;
119 |   row-gap: 80px;
120 |   margin: 80PX AUTO;
121 |   max-width: 1200px;
122 | }
123 | .recipe{
124 |   display: inline-block;
125 |   border-radius: 20px;
126 |   background: white;
127 |   position: relative;
128 |   text-align: center;
129 |   padding: 0 20px 30px 20px
130 | }
131 | .recipe img{
132 |   width: 100px;
133 |   margin: -30px auto 20px;
134 | }
135 | footer{
136 |   text-align: center;
137 |   margin-top: 120px;
138 |   color: #aaa;
139 | }
140 | 
141 | .inp > span {
142 |   font-weight: 100;
143 | }
144 | 
145 | .inp{
146 |   font-weight: 800;
147 |   margin: 20px 0 0 0;
148 | }
149 | 
150 | .sp{
151 |   max-width:100%;
152 |   white-space:nowrap;
153 | }


--------------------------------------------------------------------------------
/routes/authRoutes.js:
--------------------------------------------------------------------------------
 1 | const {Router} = require('express');
 2 | const authController = require('../controllers/authController');
 3 | const router = Router();
 4 | 
 5 | router.get('/signup', authController.signup_get);
 6 | router.post('/signup', authController.signup_post);
 7 | router.get('/login', authController.login_get);
 8 | router.post('/login', authController.login_post);
 9 | router.get('/logout', authController.logout_get);
10 | 
11 | module.exports = router;


--------------------------------------------------------------------------------
/views/alltransactions.ejs:
--------------------------------------------------------------------------------
  1 | <%- include('partials/header'); -%>
  2 | <%- include('partials/sidebar'); -%>
  3 | 
  4 | <div class="w3-container w3-padding">
  5 |   Your Transactions
  6 |   <hr />
  7 | 
  8 |   <% if ( transactions && transactions == "PROCESSING" ) { %>
  9 |     
 10 |     <div class="w3-center">
 11 |         Transaction data is still processing.
 12 |     </div>
 13 | 
 14 |   <% } else if ( data['user']['monoId'] ) { %>
 15 | 
 16 |     <h2>
 17 |         All Transactions
 18 |         <hr>
 19 |     </h2>
 20 | 
 21 |     <div class="w3-container">
 22 |         <div class="w3-left">
 23 |             <div class="w3-bar">
 24 |                 <% if (transactions.paging.previous) { %>
 25 |                     <a href="<%= getPage(transactions.paging.previous) %>" class="w3-button">&laquo;</a>
 26 |                 <% } %>
 27 | 
 28 |                 <a class="">Page <%= transactions.paging.page %></a>
 29 | 
 30 |                 <% if (transactions.paging.next) { %>
 31 |                     <a href="<%= getPage(transactions.paging.next) %>" class="w3-button">&raquo;</a>
 32 |                 <% } %>
 33 |                 
 34 |             </div>
 35 |         </div>
 36 | 
 37 |         <div class="w3-right">
 38 |             Page <%= transactions.paging.page %> of <%= Math.floor(transactions.paging.total/20) %>
 39 |         </div>
 40 |         
 41 |         <table class="w3-table w3-striped w3-bordered">
 42 |             <tr>
 43 |                 <th>S/N</th>
 44 |                 <th>Type</th>
 45 |                 <th>Date</th>
 46 |                 <th>Amount</th>
 47 |                 <th>Balance</th>
 48 |                 <th>Narration</th>
 49 |             </tr>
 50 | 
 51 |             <% for(var i=0; i < transactions.data.length; i++) { %>
 52 |                 <tr>
 53 |                   <td>
 54 |                     <%= (i + 1) + ( transactions.paging.page * 20) -20  %>                
 55 |                   </td>
 56 |                   <td><%= transactions.data[i].type %></td>
 57 |                   <td class="sp"><%= formatTime(transactions.data[i].date) %></td>
 58 |                   <td class="sp">NGN <%= setCurrency(transactions.data[i].amount) %></td>
 59 |                   <td class="sp">NGN <%= setCurrency(transactions.data[i].balance) %></td>
 60 |                   <td><%= transactions.data[i].narration %></td>
 61 |                 </tr>
 62 |              <% } %>
 63 |             
 64 |         </table>
 65 | 
 66 | 
 67 |         <div class="w3-center w3-margin-top">
 68 |             <div class="w3-bar">
 69 |                 <% if (transactions.paging.previous) { %>
 70 |                     <a href="<%= getPage(transactions.paging.previous) %>" class="w3-button">&laquo;</a>
 71 |                 <% } %>
 72 | 
 73 |                 <a class="w3-button">Page <%= transactions.paging.page %></a>
 74 | 
 75 |                 <% if (transactions.paging.next) { %>
 76 |                     <a href="<%= getPage(transactions.paging.next) %>" class="w3-button">&raquo;</a>
 77 |                 <% } %>
 78 |                 
 79 |             </div>
 80 |         </div>
 81 |         
 82 |     </div>
 83 | 
 84 | 
 85 |   <% } else { %>
 86 |     <div class="w3-center">
 87 |         Your account is not linked yet
 88 |     </div>
 89 |   <% } %>
 90 | 
 91 | 
 92 | </div>
 93 | 
 94 | <%- include('partials/sidebar_end'); -%>
 95 | 
 96 | <script type="application/javascript">
 97 |     // function page(page){
 98 |     //     const page_number = page.split("page=");
 99 | 
100 |     //     return `?page=${page_number}`
101 |     // }
102 | </script>
103 | 
104 | <%- include('partials/footer'); -%>


--------------------------------------------------------------------------------
/views/balances (copy).ejs:
--------------------------------------------------------------------------------
 1 | <%- include('partials/header'); -%>
 2 | <%- include('partials/sidebar'); -%>
 3 | 
 4 | <div class="w3-container w3-padding">
 5 |   Account Balances
 6 |   <hr />
 7 | 
 8 |   <% if (mono['data']) { %>
 9 | 
10 |     <h2>
11 |         Your Account Balances
12 |         <hr>
13 |     </h2>
14 | 
15 |     <p class="inp">
16 |         NAME: <span class="name"></span>
17 |     </p>
18 |     
19 |     <p class="inp">
20 |         BVN: <span class="bvn"></span>
21 |     </p>
22 |     
23 |     <p class="inp">
24 |         ACCOUNT NUMBER: <span class="account"></span>
25 |     </p>
26 |     
27 |     <p class="inp">
28 |         CURRENCY: <span class="currency"></span>
29 |     </p>
30 |     
31 |     <p class="inp">
32 |         BALANCE: <span class="balance"></span>
33 |     </p>
34 |     
35 |     <p class="inp">
36 |         TYPE: <span class="type"></span>
37 |     </p>
38 |     
39 | 
40 | 
41 |   <% } else { %>
42 |     <div class="w3-center">
43 |         Your account is not linked yet
44 |     </div>
45 |   <% } %>
46 | 
47 | 
48 | </div>
49 | 
50 | <%- include('partials/sidebar_end'); -%>
51 | 
52 | <% if (mono['data']) { %>
53 | <script>
54 |     const mono = JSON.parse('<%- JSON.stringify(mono) %>');
55 | 
56 |     const name = document.querySelector('.name');
57 |     const bvn = document.querySelector('.bvn');
58 |     const account = document.querySelector('.account');
59 |     const currency = document.querySelector('.currency');
60 |     const balance = document.querySelector('.balance');
61 |     const type = document.querySelector('.type');
62 | 
63 |     (async function() {
64 |         // const url = `https://api.withmono.com/accounts/${mono.monoId}5f171a530295e231abca1153`
65 |         const url = `https://api.withmono.com/accounts/5f171a530295e231abca1153`
66 | 
67 |         const res = await fetch(url, { 
68 |             method: 'GET', 
69 |             headers: {
70 |                 'Content-Type': 'application/json',
71 |                 'mono-sec-key': mono.publicKey
72 |             }
73 |         });
74 | 
75 |         const data = await res.json();
76 | 
77 |         console.log(data);
78 | 
79 |         name.textContent = data.account.name
80 |         bvn.textContent = data.account.bvn
81 |         account.textContent = data.account.accountNumber
82 |         currency.textContent = data.account.currency
83 |         balance.textContent = data.account.balance
84 |         type.textContent = data.account.type
85 | 
86 |     })();
87 | 
88 |     </script>
89 | <% } %>
90 | 
91 | <%- include('partials/footer'); -%>


--------------------------------------------------------------------------------
/views/balances.ejs:
--------------------------------------------------------------------------------
  1 | <%- include('partials/header'); -%>
  2 | <%- include('partials/sidebar'); -%>
  3 | 
  4 | <div class="w3-container w3-padding">
  5 |   Account Balances 
  6 | 
  7 |   <% if ( data['user']['monoId'] ) { %>
  8 |     <span onclick="sync()" class="w3-button w3-border w3-round w3-right">Refresh</span>
  9 |   <% } %>
 10 |   <hr />
 11 |   
 12 |   <h2>
 13 |       Your Account Balance
 14 |       <hr>
 15 |   </h2>
 16 | 
 17 |   <% if ( data['user']['monoBalance'] && data['user']['monoId'] ) { %>
 18 | 
 19 |     <p class="inp">
 20 |         NAME:
 21 |         <span><%= data['monoBalance']['name'] %></span>
 22 |     </p>
 23 |     
 24 |     <p class="inp">
 25 |         BVN:
 26 |         <span><%= data['monoBalance']['bvn'] %></span>
 27 |     </p>
 28 |     
 29 |     <p class="inp">
 30 |         ACCOUNT NUMBER:
 31 |         <span><%= data['monoBalance']['accountNumber'] %></span>
 32 |     </p>
 33 |     
 34 |     <p class="inp">
 35 |         CURRENCY:
 36 |         <span><%= data['monoBalance']['currency'] %></span>
 37 |     </p>
 38 |     
 39 |     <p class="inp">
 40 |         BALANCE:
 41 |         <span><%= setCurrency(data['monoBalance']['balance']) %></span>
 42 |     </p>
 43 |     
 44 |     <p class="inp">
 45 |         TYPE:
 46 |         <span><%= data['monoBalance']['type'] %></span>
 47 |     </p>
 48 | 
 49 | 
 50 | 
 51 |   <% } else if (balances) { %>
 52 | 
 53 |     <p class="inp">
 54 |         NAME:
 55 |         <span><%= balances['account']['name'] %></span>
 56 |     </p>
 57 |     
 58 |     <p class="inp">
 59 |         BVN:
 60 |         <span><%= balances['account']['bvn'] %></span>
 61 |     </p>
 62 |     
 63 |     <p class="inp">
 64 |         ACCOUNT NUMBER:
 65 |         <span><%= balances['account']['accountNumber'] %></span>
 66 |     </p>
 67 |     
 68 |     <p class="inp">
 69 |         CURRENCY:
 70 |         <span><%= balances['account']['currency'] %></span>
 71 |     </p>
 72 |     
 73 |     <p class="inp">
 74 |         BALANCE:
 75 |         <span><%= setCurrency(balances['account']['balance']) %></span>
 76 |     </p>
 77 |     
 78 |     <p class="inp">
 79 |         TYPE:
 80 |         <span><%= balances['account']['type'] %></span>
 81 |     </p>
 82 |     
 83 | 
 84 |   <% } else { %>
 85 |     <div class="w3-center">
 86 |         Your account is not linked yet
 87 |     </div>
 88 |   <% } %>
 89 | 
 90 | 
 91 | </div>
 92 | 
 93 | <script type="application/javascript">
 94 |     const data = JSON.parse('<%- JSON.stringify(data) %>');
 95 | 
 96 |     let sync = async () => {
 97 |         const url = `https://api.withmono.com/accounts/${data.user.monoId}/sync`
 98 | 
 99 | 		const response = await fetch(url, { 
100 | 			method: 'POST', 
101 | 			headers: {
102 | 				'Content-Type': 'application/json',
103 | 				'mono-sec-key': data.secretKey
104 | 			}
105 | 		});
106 | 
107 | 		const result = await response.json();
108 |         
109 |         console.log(result);
110 | 		// alert(result.code)
111 | 
112 |         if (result.code == "SYNC_SUCCESSFUL"){
113 |             location.assign('/balances');
114 |         }
115 |         
116 |         else if(result.code == "REAUTHORISATION_REQUIRED"){
117 | 
118 |             const response2 = await fetch('/monoReauth', { 
119 |                 method: 'POST',
120 |                 body: JSON.stringify({ id: data.user.monoId }),
121 |                 headers: {'Content-Type': 'application/json'}
122 |             });
123 | 
124 |             const result2 = await response2.json();
125 | 
126 |             if (result2.status == "redirect") {
127 |                 // location.assign('/monoReauth');
128 |                 location.assign('/balances');
129 |             }
130 | 
131 |         }
132 | 
133 |     }
134 | 
135 |     // sync(data.user.monoId)
136 | 
137 | </script>
138 | 
139 | <%- include('partials/sidebar_end'); -%>
140 | 
141 | <%- include('partials/footer'); -%>


--------------------------------------------------------------------------------
/views/dashboard.ejs:
--------------------------------------------------------------------------------
  1 | <%- include('partials/header'); -%>
  2 | <%- include('partials/sidebar'); -%>
  3 | 
  4 | 
  5 | <div class="w3-container w3-padding">
  6 |   Your Dashboard
  7 |   <hr />
  8 | 
  9 |   <% if (data['user']['monoId'] ) { %>
 10 | 
 11 |     <h2>
 12 |       Your User Information
 13 |       <span class="w3-padding w3-green w3-round w3-small">
 14 |         ACCOUNT CONNECTED
 15 |       </span>
 16 |       <hr>
 17 |     </h2>
 18 | 
 19 |     <p class="inp w3-third w3-margin-bottom">
 20 |       TITLE:
 21 |       <span><%= dashboard['title'] %></span>
 22 |     </p>
 23 | 
 24 |     <p class="inp w3-third w3-margin-bottom">
 25 |       FIRST NAME:
 26 |       <span><%= dashboard['firstName'] %></span>
 27 |     </p>
 28 | 
 29 |     <p class="inp w3-third w3-margin-bottom">
 30 |       MIDDLE NAME:
 31 |       <span><%= dashboard['middleName'] %></span>
 32 |     </p>
 33 | 
 34 |     <p class="inp w3-third w3-margin-bottom">
 35 |       LAST NAME:
 36 |       <span><%= dashboard['lastName'] %></span>
 37 |     </p>
 38 | 
 39 |     <p class="inp w3-third w3-margin-bottom">
 40 |       PHONE NUMBER 1:
 41 |       <span><%= dashboard['phoneNumber1'] %></span>
 42 |     </p>
 43 | 
 44 |     <p class="inp w3-third w3-margin-bottom">
 45 |       PHONE NUMBER 2:
 46 |       <span><%= dashboard['phoneNumber2'] %></span>
 47 |     </p>
 48 | 
 49 |     <p class="inp w3-third w3-margin-bottom">
 50 |       EMAIL:
 51 |       <span><%= dashboard['email'] %></span>
 52 |     </p>
 53 | 
 54 |     <p class="inp w3-third w3-margin-bottom">
 55 |       GENDER:
 56 |       <span><%= dashboard['gender'] %></span>
 57 |     </p>
 58 | 
 59 |     <p class="inp w3-third w3-margin-bottom">
 60 |       LGA OF ORIGIN:
 61 |       <span><%= dashboard['lgaOfOrigin'] %></span>
 62 |     </p>
 63 | 
 64 |     <p class="inp w3-third w3-margin-bottom">
 65 |       LGA OF RESIDENCE:
 66 |       <span><%= dashboard['lgaOfResidence'] %></span>
 67 |     </p>
 68 | 
 69 |     <p class="inp w3-third w3-margin-bottom">
 70 |       MARITAL STATUS:
 71 |       <span><%= dashboard['maritalStatus'] %></span>
 72 |     </p>
 73 | 
 74 |     <p class="inp w3-third w3-margin-bottom">
 75 |       NIN:
 76 |       <span><%= dashboard['nin'] %></span>
 77 |     </p>
 78 | 
 79 |     <p class="inp w3-third w3-margin-bottom">
 80 |       NATIONALITY:
 81 |       <span><%= dashboard['nationality'] %></span>
 82 |     </p>
 83 | 
 84 |     <p class="inp w3-third w3-margin-bottom">
 85 |       RESIDENTIAL ADDRESS:
 86 |       <span><%= dashboard['residentialAddress'] %></span>
 87 |     </p>
 88 | 
 89 |     <p class="inp w3-third w3-margin-bottom">
 90 |       STATE OF ORIGIN:
 91 |       <span><%= dashboard['stateOfOrigin'] %></span>
 92 |     </p>
 93 | 
 94 |     <p class="inp w3-third w3-margin-bottom">
 95 |       STATE OF RESIDENCE:
 96 |       <span><%= dashboard['stateOfResidence'] %></span>
 97 |     </p>
 98 | 
 99 |     <p class="inp w3-third w3-margin-bottom">
100 |       WATCH LISTED:
101 |       <span><%= dashboard['watchListed'] %></span>
102 |     </p>
103 | 
104 |     <p class="inp w3-third w3-margin-bottom">
105 |       BVN:
106 |       <span><%= dashboard['bvn'] %></span>
107 |     </p>
108 | 
109 | 
110 | 
111 | 
112 |   <% } else { %>
113 |     <div>
114 |       <button id="launch-btn">Link your financial account</button>
115 |     </div>
116 |   <% } %>
117 | 
118 | 
119 | </div>
120 | 
121 | 
122 | <%- include('partials/sidebar_end'); -%>
123 | 
124 | <%- include('partials/mono_dialog'); -%>
125 | 
126 | <script type="application/javascript">
127 |   async function get() {
128 | 
129 |   
130 |   }
131 | 
132 |   get()
133 | </script>
134 | 
135 | <%- include('partials/footer'); -%>


--------------------------------------------------------------------------------
/views/home.ejs:
--------------------------------------------------------------------------------
 1 | <%- include('partials/header'); -%>
 2 | 
 3 | 
 4 | <br><br><br>
 5 | 
 6 | <header>
 7 |   <div class="smoothie">
 8 |     <img src="/smoothie.png" alt="">
 9 |   </div>
10 |   <div class="headings">
11 |     <h2>Sweet Loans.</h2>
12 |     <h3>Get access to sweet loans, quickly in no time</h3>
13 |     <a href="/dashboard" class="btn">Get In!</a>
14 |   </div>
15 | </header>
16 | 
17 | 
18 | <%- include('partials/footer'); -%>


--------------------------------------------------------------------------------
/views/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <title>Mono Connect test</title>
 5 |     <style>
 6 |         .p-5 {
 7 |             padding: 5em;
 8 |         }
 9 |     </style>
10 |     <script type="application/javascript" src="https://connect.withmono.com/connect.js"></script>
11 | </head>
12 | <body>
13 | <div className="p-5">
14 |     <p>Welcome to Mono Connect.</p>
15 |     <button id="launch-btn">Link a financial account</button>
16 | </div>
17 | <script type="application/javascript">
18 |   const copyToClipboard = text => {
19 |     const elm = document.createElement('textarea');
20 |     elm.value = text;
21 |     document.body.appendChild(elm);
22 |     elm.select();
23 |     document.execCommand('copy');
24 |     document.body.removeChild(elm);
25 |   };
26 | 
27 |   const reauthToken = "nyd96OgGzRtRBNx2S1OiLxBbkBo5";
28 | 
29 | 
30 | 
31 |   var connect;
32 |   var config = {
33 |     key: "live_pk_Qv6rON9yvEEDloiujrcM",
34 |     onSuccess: function (response) {
35 |       copyToClipboard(response.code);
36 |       console.log(JSON.stringify(response));
37 |       alert(JSON.stringify(response));
38 |       /**
39 |        response : { "code": "code_xyz" }
40 |        you can send this code back to your server to get this
41 |        authenticated account and start making requests.
42 |        */
43 |     },
44 |     onClose: function () {
45 |       console.log('user closed the widget.')
46 |     }
47 |   };
48 |   connect = new Connect(config);
49 |   connect.setup();
50 |   // connect.reauthorise(reauthToken);
51 |   // code_ccE0Ck7o1zeXHTlJGVMb
52 | 
53 |   var launch = document.getElementById('launch-btn');
54 |   launch.onclick = function (e) {
55 |     connect.open();
56 |   };
57 | </script>
58 | </body>
59 | </html>


--------------------------------------------------------------------------------
/views/login.ejs:
--------------------------------------------------------------------------------
 1 | <%- include('partials/header'); -%>
 2 | 
 3 | <form action="/signup">
 4 |   <h2>Login</h2>
 5 |   <label for="email">Email</label>
 6 |   <input type="text" name="email" required />
 7 |   <div class="email error"></div>
 8 | 
 9 |   <label for="password">Password</label>
10 |   <input type="password" name="password" required />
11 |   <div class="password error"></div>
12 | 
13 |   <button>login</button>
14 | </form>
15 | 
16 | <%- include('partials/footer'); -%>
17 | 
18 | <script>
19 |   const form = document.querySelector('form');
20 |   const emailError = document.querySelector('.email.error');
21 |   const passwordError = document.querySelector('.password.error');
22 | 
23 | 
24 |   form.addEventListener('submit', async(e) => {
25 |     e.preventDefault();
26 | 
27 |     // reset errors
28 |     emailError.textContent = '';
29 |     passwordError.textContent = '';
30 | 
31 |     // get values
32 |     const email = form.email.value;
33 |     const password = form.password.value;
34 | 
35 |     try {
36 |       const res = await fetch('/login', { 
37 |         method: 'POST', 
38 |         body: JSON.stringify({ email, password }),
39 |         headers: {'Content-Type': 'application/json'}
40 |       });
41 | 
42 |       const data = await res.json();
43 |       console.log(data);
44 | 
45 |       if (data.errors) {
46 |         emailError.textContent = data.errors.email;
47 |         passwordError.textContent = data.errors.password;
48 |       }
49 | 
50 |       if (data.user) {
51 |         location.assign('/dashboard');
52 |       }
53 | 
54 |     }
55 |     catch (err) {
56 |       console.log(err);
57 |     }
58 |   });
59 | </script>


--------------------------------------------------------------------------------
/views/monoreauth.ejs:
--------------------------------------------------------------------------------
 1 | <%- include('partials/header'); -%>
 2 | <%- include('partials/sidebar'); -%>
 3 | 
 4 | 
 5 | <div class="w3-container w3-padding">
 6 |   Your Dashboard
 7 |   <hr />
 8 | 
 9 |   <% if (data['user']['monoStatus'] ) { %>
10 |     <div>
11 |       <button id="launch-btn">Reauthorise your financial account</button>
12 |     </div>
13 |   <% } else { %>
14 |     <div>
15 |         Nothing to do here. No pending re-authorisation!
16 |     </div>
17 |   <% } %>
18 | 
19 | 
20 | </div>
21 | 
22 | 
23 | <%- include('partials/sidebar_end'); -%>
24 | 
25 | <%- include('partials/mono_reauth_dialog'); -%>
26 | 
27 | <script type="application/javascript">
28 |   async function get() {
29 | 
30 |   
31 |   }
32 | 
33 |   get()
34 | </script>
35 | 
36 | <%- include('partials/footer'); -%>


--------------------------------------------------------------------------------
/views/partials/footer.ejs:
--------------------------------------------------------------------------------
1 | <!-- <footer>Copyright 2020 Your Boy!</footer> -->
2 | 
3 | </body>
4 | </html>


--------------------------------------------------------------------------------
/views/partials/header.ejs:
--------------------------------------------------------------------------------
 1 | <html lang="en">
 2 | <head>
 3 |   <meta charset="UTF-8">
 4 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 5 |   <title>S.w.e.e.t Loans</title>
 6 |   <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css"> 
 7 |   <link rel="stylesheet" href="/styles.css">
 8 |   <script type="application/javascript" src="https://connect.withmono.com/connect.js"></script>
 9 | </head>
10 | <body>
11 |   <nav>
12 |     <h1><a href="/">S.w.e.e.t Loans</a></h1>
13 |     <ul>
14 |       <% if (data && data.user) { %>
15 |         <li>Welcome, <%= data.user.email %></li>
16 |         <li><a href="/logout">Log out</a></li>
17 |       <% } else { %>
18 |         <li><a href="/login">Log in</a></li>
19 |         <li><a href="/signup" class="btn">Sign up</a></li>
20 |       <% } %>
21 |     </ul>
22 |   </nav>


--------------------------------------------------------------------------------
/views/partials/mono_dialog.ejs:
--------------------------------------------------------------------------------
 1 | <script type="application/javascript">
 2 |     const data = JSON.parse('<%- JSON.stringify(data) %>');
 3 | 
 4 |     const copyToClipboard = text => {
 5 |         const elm = document.createElement('textarea');
 6 |         elm.value = text;
 7 |         document.body.appendChild(elm);
 8 |         elm.select();
 9 |         document.execCommand('copy');
10 |         document.body.removeChild(elm);
11 |     };
12 |     var connect;
13 |     var config = {
14 |         key: data.publicKey,
15 |         onSuccess: function (response) {
16 |             // copyToClipboard(response.code);
17 | 
18 |             // const res = await fetch('/dashboard', { 
19 |             //     method: 'POST', 
20 |             //     body: JSON.stringify({ code: response.code, id: data.user._id }),
21 |             //     headers: {'Content-Type': 'application/json'}
22 |             // })
23 |             // .then(res_ => res_.json())
24 |             // .then((res_) => {
25 |             //     //   const data = await res.json();
26 |             //     console.log(res_);
27 |             //     // if (data.user) {
28 |             //     location.assign('/dashboard');
29 |             //     // }
30 |             // });
31 | 
32 |             (async () => {
33 | 
34 |                 try {
35 |                     const res = await fetch('/dashboard', { 
36 |                         method: 'POST', 
37 |                         body: JSON.stringify({ code: response.code, id: data.user._id }),
38 |                         headers: {'Content-Type': 'application/json'}
39 |                     });
40 | 
41 |                     const val = await res.json();
42 |                     console.log(val);
43 |                 
44 |                     if (val) {
45 |                         location.assign('/dashboard');
46 |                     }
47 | 
48 |                 }
49 |                 catch (err) {
50 |                     // console.log(err);
51 |                 }
52 |             
53 | 			})();
54 | 
55 |         },
56 |         onClose: function () {
57 |         console.log('user closed the widget.')
58 |         }
59 |     };
60 |     connect = new Connect(config);
61 |     connect.setup();
62 |     var launch = document.getElementById('launch-btn');
63 |     launch.onclick = function (e) {
64 |         connect.open();
65 |     };
66 | 
67 | </script>


--------------------------------------------------------------------------------
/views/partials/mono_reauth_dialog.ejs:
--------------------------------------------------------------------------------
 1 | <script type="application/javascript">
 2 |     const data = JSON.parse('<%- JSON.stringify(data) %>');
 3 | 
 4 |     const reauthToken = data.user.monoReauthToken;
 5 | 
 6 |     const copyToClipboard = text => {
 7 |         const elm = document.createElement('textarea');
 8 |         elm.value = text;
 9 |         document.body.appendChild(elm);
10 |         elm.select();
11 |         document.execCommand('copy');
12 |         document.body.removeChild(elm);
13 |     };
14 |     var connect;
15 |     var config = {
16 |         key: data.publicKey,
17 |         onSuccess: function (response) {
18 |             (async () => {
19 | 
20 |                 console.log('we in');
21 | 
22 |                 try {
23 |                     const res = await fetch('/dashboard', { 
24 |                         method: 'POST', 
25 |                         body: JSON.stringify({ code: response.code, id: data.user._id }),
26 |                         headers: {'Content-Type': 'application/json'}
27 |                     });
28 | 
29 |                     const val = await res.json();
30 |                     alert(val)
31 |                     console.log(val);
32 |                 
33 |                     if (val) {
34 |                         location.assign('/dashboard');
35 |                     }
36 | 
37 |                 }
38 |                 catch (err) {
39 |                     console.log(err);
40 |                     alert(err);
41 |                 }
42 |             
43 | 			})();
44 | 
45 |         },
46 |         onClose: function () {
47 |             console.log('user closed the widget.')
48 |         }
49 |     };
50 |     connect = new Connect(config);
51 |     connect.reauthorise(reauthToken);
52 | 
53 |     var launch = document.getElementById('launch-btn');
54 |     launch.onclick = function (e) {
55 |         connect.open();
56 |     };
57 | 
58 | </script>


--------------------------------------------------------------------------------
/views/partials/sidebar.ejs:
--------------------------------------------------------------------------------
 1 | <div class="w3-sidebar w3-bar-block w3-round w3-margin-bottom" style="width:20%;height: 80vh;border: 2px solid #ccc;">
 2 |     <a href="/dashboard" class="w3-bar-item w3-margin-top">Dashboard</a> 
 3 |     <a href="/balances" class="w3-bar-item w3-margin-top">Balances</a>
 4 |     <a href="/transactions" class="w3-bar-item w3-margin-top">Latest Transactions</a> 
 5 |     <a href="/alltransactions" class="w3-bar-item w3-margin-top">All Transactions</a> 
 6 |     <a class="w3-bar-item w3-margin-top">Request Loan
 7 |         <span class="w3-red w3-round-large w3-padding-small w3-small">Soon</span>    
 8 |     </a> 
 9 | </div>
10 | 
11 | <div style="margin-left:20%">
12 |     <div class="w3-padding">
13 | 


--------------------------------------------------------------------------------
/views/partials/sidebar_end.ejs:
--------------------------------------------------------------------------------
1 |     </div>
2 | </div>


--------------------------------------------------------------------------------
/views/signup.ejs:
--------------------------------------------------------------------------------
 1 | <%- include('partials/header'); -%>
 2 | <form>
 3 | 	<h2>Sign up</h2>
 4 | 
 5 | 	<label for="email">Email</label>
 6 | 	<input type="text" name="email" required />
 7 | 	<div class="email error"></div>
 8 | 	
 9 | 	<label for="password">Password</label>
10 | 	<input type="password" name="password" required />
11 | 	<div class="password error"></div>
12 | 	
13 | 	<button>Sign up</button>
14 | </form>
15 | 
16 | <script>
17 |   const form = document.querySelector('form');
18 |   const emailError = document.querySelector('.email.error');
19 |   const passwordError = document.querySelector('.password.error');
20 | 
21 |   form.addEventListener('submit', async (e) => {
22 |     e.preventDefault();
23 | 
24 |     // reset errors
25 |     emailError.textContent = '';
26 |     passwordError.textContent = '';
27 | 
28 |     // get values
29 |     const email = form.email.value;
30 |     const password = form.password.value;
31 | 
32 |     try {
33 |       const res = await fetch('/signup', { 
34 |         method: 'POST', 
35 |         body: JSON.stringify({ email, password }),
36 |         headers: {'Content-Type': 'application/json'}
37 |       });
38 | 
39 |       const data = await res.json();
40 |       console.log(data);
41 | 
42 |       if (data.errors) {
43 |         emailError.textContent = data.errors.email;
44 |         passwordError.textContent = data.errors.password;
45 |       }
46 | 
47 |       if (data.user) {
48 |         location.assign('/dashboard');
49 |       }
50 | 
51 |     }
52 |     catch (err) {
53 |       console.log(err);
54 |     }
55 | 
56 |   });
57 | </script>
58 | <%- include('partials/footer'); -%>


--------------------------------------------------------------------------------
/views/transactions.ejs:
--------------------------------------------------------------------------------
 1 | <%- include('partials/header'); -%>
 2 | <%- include('partials/sidebar'); -%>
 3 | 
 4 | <div class="w3-container w3-padding">
 5 |   Your Transactions
 6 |   <hr />
 7 | 
 8 |   <% if ( transactions && transactions == "PROCESSING" ) { %>
 9 |     
10 |     <div class="w3-center">
11 |         Transaction data is still processing.
12 |     </div>
13 | 
14 |   <% } else if ( data['user']['monoId'] ) { %>
15 |     <h2>
16 |         Last 20 Transactions
17 |         <hr>
18 |     </h2>
19 | 
20 |     <div class="w3-container">
21 |         <!-- <h2>Striped Bordered Table</h2> -->
22 | 
23 |         <!-- <div class="w3-right">
24 |             Page <%= transactions.paging.page %> of <%= transactions.paging.total %>
25 |         </div>
26 |          -->
27 |         <table class="w3-table w3-striped w3-bordered">
28 |             <tr>
29 |                 <th>S/N</th>
30 |                 <th>Type</th>
31 |                 <th>Date</th>
32 |                 <th>Amount</th>
33 |                 <th>Balance</th>
34 |                 <th>Narration</th>
35 |             </tr>
36 | 
37 |             <% for(var i=0; i < transactions.data.length; i++) { %>
38 |                 <tr>
39 |                   <td><%= i+1 %></td>
40 |                   <td><%= transactions.data[i].type %></td>
41 |                   <td class="sp"><%= formatTime(transactions.data[i].date) %></td>
42 |                   <td class="sp">NGN <%= setCurrency(transactions.data[i].amount) %></td>
43 |                   <td class="sp">NGN <%= setCurrency(transactions.data[i].balance) %></td>
44 |                   <td><%= transactions.data[i].narration %></td>
45 |                 </tr>
46 |              <% } %>
47 |             
48 |         </table>
49 | 
50 | 
51 |         <!-- <div class="w3-center w3-margin-top">
52 |             <div class="w3-bar">
53 |                 <a href="<% if (transactions.paging.previous) { getPage(transactions.paging.previous) } else{''} %>" class="w3-button">&laquo;</a>
54 |                 <a class="w3-button"><%= transactions.paging.page %></a>
55 |                 <a href="<% if (transactions.paging.next) { getPage(transactions.paging.next) } else{'2'} %>" class="w3-button">&raquo;</a>
56 |             </div>
57 |         </div> -->
58 |     </div>
59 | 
60 | 
61 |   <% } else { %>
62 |     <div class="w3-center">
63 |         Your account is not linked yet
64 |     </div>
65 |   <% } %>
66 | 
67 | 
68 | </div>
69 | 
70 | <%- include('partials/sidebar_end'); -%>
71 | 
72 | <script type="application/javascript">
73 |     // function page(page){
74 |     //     const page_number = page.split("page=");
75 | 
76 |     //     return `?page=${page_number}`
77 |     // }
78 | </script>
79 | 
80 | <%- include('partials/footer'); -%>


--------------------------------------------------------------------------------