ernest/Templater.js

Web framework for HTTP and HTTPS, using ExpressJS, Session, Mongo, Socket IO, Redis

var fs 		= require('fs');
var path 	= require('path');

class Templater
{
	constructor(viewsFolder,templatesFolder,extension,app)
	{
		this.app 				= app;
		this.viewsFolder 		= viewsFolder;
		this.templatesFolder 	= templatesFolder;
		this.templates 			= {};
		this.views 				= {};
		this.extension 			= extension.toLowerCase();
		this.viewFiles 			= [];
		this.properties 		= [];
		this.symbol 			= "###";
	};

	setExtension(extension)
	{
		this.extension = extension.toLowerCase();
		return this;
	};

	setSymbol(symbol)
	{	
		this.symbol = symbol;
		return this;
	};

	Start(callback)
	{
		this.Reload((e,r)=>
		{
			callback(e,r);
		});
	};

	Reload(callback)
	{
		let _this = this;
		_this.LoadTemplateFiles(function(e,r)
		{
			if(e)
			{
				callback(e,r);
			}
			else
			{
				_this.LoadViewFiles(function(e2,r2)
				{
					callback(e2,r2);
				});	
			};			
		});
	}

	Apply(urlContains,production,callback)
	{
		let _this 		= this;
		_this.app.get('/*',function(req,res,next)
		{
			let originalUrl = req.originalUrl.replace(urlContains,'').replace('/','').replace('.' + _this.extension,''); 
			(urlContains && !req.originalUrl.includes(urlContains)) ? next() : (()=>
			{
				if(originalUrl in _this.views)
				{
					let userData = {};let vars = {};
					if(req.session.user !== undefined)
					{
						userData = req.session.data;
						delete userData._id;
						delete userData.password;
						vars = req.session.vars;
					};
					let prevfinal = (req.session.user !== undefined) ? _this.views[originalUrl].replace("_session",JSON.stringify({userData,vars})):_this.views[originalUrl];  
					let final = prevfinal;
					if( (originalUrl + "_html") in userData)
					{
						final = _this.ByLevel(userData[originalUrl + "_html"],prevfinal);	
					};					
					return res.send( production ? final.replace(new RegExp('\n', 'g'),' ').replace(new RegExp('\t', 'g'),'') : final);				 
				}
				else
				{
					next();
				}
			})();
		});
		callback(null,true);
	};

	ByLevel(level,text)
	{
		let patternbegin 	= "_onUserLevel";
		let base 			= text;
		let pattern 		= RegExp(patternbegin + "\\[.*?\\]:((.|\n|\t)*?)::",'g');
		let coincidences 	= base.match(pattern);
		var pattern2 		= RegExp(patternbegin + "\\[.*?\\]:",'g');
		if(coincidences != null)
		{
			for(let i = 0; i< coincidences.length; i++ )
			{
				let cur 	= coincidences[i].match(pattern2);
				let onLevel = Number(cur[0].replace(patternbegin + "[","").replace("]:",""));

				if(level >= onLevel)
				{
					base = base.replace(coincidences[i],coincidences[i].replace(pattern2,"").replace("::",""))
				}
				else
				{
					base = base.replace(coincidences[i],"");
				}
			};
			return base;
		}
		else
		{
			return text;
		}
		
	};

	ContainsTemplatePattern(text,callback)
	{
		let _this = this;
		let pattern = RegExp(this.symbol + '(.*?)'+ this.symbol,'g');
		var result = text.match(pattern);
		if(!result)
		{
			callback(text);
		}
		else
		{
			let intersection = _this.properties.filter(property => result.includes(_this.symbol + property + _this.symbol));
			let len = intersection.length;
			if(len > 0)
			{	
				let till = len - 1;
				intersection.map((inter, index)=>
				{
					text = text.replace(new RegExp(this.symbol + inter + this.symbol, 'g'),this.templates[inter]);
					if(index == till)
					{
						_this.ContainsTemplatePattern(text,repl => callback(repl));
					}
				});
			}
			else
			{
				callback(text);
			}
		};
	};

	AddToTemplateArray(file,callback)
	{
		var _this 		= this; 
		var filePath 	= _this.templatesFolder + file;
		var prop 		= file.replace('.'+_this.extension,'');
		fs.readFile(filePath, function (err, content) 
		{
			if(err)
			{
				callback(err,null)
			}
			else
			{
				if(prop != '_locals')
				{
					_this.templates[prop] = content.toString();
				};
				callback(null,true);
			};
		});
	};

	AddtoViewArray(file,callback)
	{
		var _this = this;
		var filePath 	= _this.viewsFolder + file;
		var prop 		= file.replace('.'+_this.extension,'');
		fs.readFile(filePath, function (err, content) 
		{
			if(err)
			{
				callback(err,null);
			}
			else
			{	
				_this.ContainsTemplatePattern(content.toString(),updated =>
				{
					_this.views[prop] = updated;
					callback(null,true);
				});		
			};
		});
	}

	LoadTemplateFiles(callback)
	{
		var _this = this;
		var error = null;
		fs.readdir(_this.templatesFolder, (err, files) => 
		{
			if(err)
			{	
				callback(err,null);
			}
			else
			{	
				_this.templates = {};
				files.async((item,next)=>
				{
					if(path.extname(item).toLowerCase() == ('.' + _this.extension)) 
					{
						_this.AddToTemplateArray(item,function(e,r)
						{
							next(e,r);  
						});
					}
					else
					{
						next(null,null);
					};
				},(e,r)=>
				{
					_this.properties = Object.keys(_this.templates);
					callback(e,r);
				});
			}
		}); 
	};

	LoadViewFiles(callback)
	{
		var _this = this;
		var error = null;
		var result = true;
		fs.readdir(_this.viewsFolder, (err, files) => 
		{
			if(err)
			{
				callback(err,null);
			}
			else
			{
				_this.views = {};
				files.async((item,next)=>
				{
					if(path.extname(item).toLowerCase() == ('.' + _this.extension))
					{
						_this.AddtoViewArray(item,function(e,r)
						{
							next(e,r);
						});
					}
					else
					{
						next(null,null);
					};		
				},(e,r)=>
				{
					callback(e,r);
				});
			};
		});
	};
};

module.exports = Templater;
/*
	Requires Array.protoype.async extends with Async module
*/