Web

Upon saving in VSCode, the code automatically uploads/downloads files between the local computer and the remotePath on KYLaNet's webhost.

• the port number is provided by the webhost
• remote/key path required for ftp to login
• ignore all the folders/files listed

{
    "name": "Diagnostic KYLaNet",
    "host": "ftp.***",
    "protocol": "sftp",
    "port": ***,
    "username": ***,
    "remotePath": ***,
    "uploadOnSave": true, 
    "privateKeyPath": ***,
    "passphrase": ***,
    "ignore": [
        ".vscode",
        ".git",
        ".DS_Store",
        "node_modules"
    ],
    "connectTimeout":***,
    "syncOption": {
        "delete": ***
    }
}

Some of these configurations include:

• create errors handler
• paths
• cookier parser
• express engine using default layouts, helpers, partials and where to find them
• create session keys
• define url routers
• create static sessions

var createError = require("http-errors");
var express = require("express");
var path = require("path");
var cookieParser = require("cookie-parser");
var logger = require("morgan");
const session = require('express-session');
var hbs = require('express-handlebars');

var app = express();

app.use(connectLiveReload());

app.engine('hbs', hbs.engine({
    allowProtoMethodsByDefault: true,
    extname: 'hbs', 
    defaultLayout: 'noside.layout.hbs', 
    helpers: require('***').helpers,
    layoutsDir: path.join(__dirname, '***'),
    partialsDir  : [
        //  path to your partials
        path.join(__dirname, '***'),
    ]
  }));

  app.use(session({
  secret: '***', 
  saveUninitialized: true,
  resave: false,
  cookie: { path: '/',
          httpOnly: true,
          secure: false,
          maxAge: *** }}));

//#region engine setup
app.set('views', [
  path.join(__dirname, '***')]);

app.set("view engine", "hbs");

app.use(logger("dev"));
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(cookieParser());

app.use(express.static(path.join(__dirname, "***")));

//#endregion

//#region routers

//routers
app.use("/",require("***/index.routes"));
app.use("/portfolio",require("***/portfolio.routes"));
app.use("/visualarts",require("***/creator.routes"));
app.use("/projects",require("***/projects.routes"));
//#endregion

//#region errors
// catch 404 and forward to error handler
app.use(function (req, res, next) {
  next(createError(404));
});

// error handler
app.use(function (err, req, res, next) {
  
  res.locals.errCode = err.status?err.status:'500';
  res.locals.errMsg = err.message;
  res.locals.errName = err.name;
  console.log('=== app Error ===');
  console.error(err.stack);
  // render the error page
  res.status(err.status || 500);
  res.render("error");
});

//#endregion

module.exports = app;

Some features:

• regularly add numbering/bullet points
• the [ ] symbols automatically create hyperlinks
• ** show bolded
• dashes or # create headers

The Resume page consists entirely of Markdown language

Header 1 
== 

Header 2
--

Continue typing
- then add a bullet point
- or (brackets) as normal

The hyperlinks are created [in these brackets]

###Markdown also applies to tables

| First | Second    | Third Column   |
| ----------- | ----------- | ----------- |
| This    | is the       | First Row |
| And    |  | So On |

The numbering 
1. is also
2. the same

Controllers handles get/post information between the front-end users and the server.

This is especially useful for:

• pushing website features after authenticating proper sessions/cookies
• pulling inputs from account creations and setting changes into the mySQL database
• validating users using encryptions and web tokens
• connect domain paths to models that decide the list of features or web servers to have

//Handling user login
const user_login_post = async (req, res) => {
    await userService.validateUser(req,res);
    let user = userService.getUserInfo();

    if (user.authenticated) {
        // simulating a database call
        session = req.session;
        session.user = user;
        res.redirect(302, ("/user/profile/" + user.id));
    } 
    else {
        res.render("./user/login", {
            
            title: "Login",
            status: user.status,
            layout: false
        });
    }
}

A model of what routers will send to the front-end

   dataRouteModel: {
        route:'/',
        layout: false,
        title: '',
        session:null,
        content: '',
        modelSidenav: null,
        modelToplist: null,
   }

An example model of objects for the mySQL/mongoDB database

const Schema = new Schema({
  name: {
    type: String,
    required: true,
  },
  value: {
    type: Boolean,
    required: true,
    default: false,
  },

}, { timestamps: true });

These functions initialize either when event handlers occur or when the page loads:

• scrolltotop
• hoverSections
• animateTypewriter

Some layouts used in KYLaNet:

• default: includes all available components
• messageOnly: modular view only
• noSide: no side navigation bar included, it consists of:
  • top icons: home and user icons
  • top navigation bar: webpage categories with their dropdowns
  • button to scroll to the top
  • body section
  • footer
• tbd: a plain page to show the website is in progress
• error: page that displays error

The NoSide layout consists of:

<!DOCTYPE html>
<html>

<head>
  {{>head}}

</head>

<body class="defBody">
  {{>topnav}}
  {{>toplist}}

  {{>btnTop}}
  <section class="secMain">
    {{{body}}}
  </section>

  {{>footer}}
</body>

</html>

Some webservices include emailing the host owner and changing the layout based on who logs in:

var express = require('express');
var router = express.Router();
const emailService = require('../services/email.service');
const validator = require('../middlewares/validators/user.validator');


/* GET home page. */
router.get('/', function(req, res, next) {
  res.render('index', { 
    title:'Home',
  src:'home',
  developed: true,
layout: 'def.layout.hbs' });
});

router.get('/contactus', function(req, res, next) {
  res.render('contactus', {
    title:'Contact Us',
  src:'home',
layout: 'message.layout.hbs'});

});

router.get('/privacypolicy', function(req, res, next) {
  res.render('./about/privacypolicy.about.hbs', {
    title:'Privacy Policy',
  src:'home',
layout: 'message.layout.hbs'});

});

router.post('/contactus', validator.emailUser,function (req,res,next){

   res.render('contactus',{
    title: 'Contact Us',
    
    layout:'message.layout.hbs',
    status: [{msg:'Email sent successfully!'},{msg:'Redirecting to home page in 3 seconds'}]
   });
  emailService.receiveEmail(req.body.name, req.body.email, req.body.subject, req.body.message) 
});
module.exports = router;

Nodemailer creates a transporter to send the mail from the email input to the email listed in the transporter:

const nodemailer = require("nodemailer");

module.exports = {

    receiveEmail: async (name, email, subject, message) => {
      
        console.log("=== email service -- Func receiveEmail === ");
        const transporter = nodemailer.createTransport({
            host:"***.kylanet.com",
            port: ***,
            secure: true,
            auth: {
                user:"***.com",
                pass: "***"
            },
        });
          const mailOption = {
            from: '***',
            to: '***',
            subject: subject,
            text: `You got a message from 
            Email : ${email}
            Name: ${name}
            Message: ${message}`,
          };
          try {
            await transporter.sendMail(mailOption);
            console.log('--receiveEmail-- Message sent successfully!');
            return Promise.resolve("Message Sent Successfully!");
          } catch (err) {
            console.log('--Error receiveEmail--', err);
          }
    } 
}

During routing, the page will render pased text from the Content folder into HTML:

const fs = require("fs");
var marked = require('marked');

  function loadContents(route) {
    console.log("=== Func markdownService--loadContents ===");
    let path = `./contents/${route}.content.md`;
    console.log(path);
    if (fs.existsSync(path)) {
      // return a promise so that the html is there before rendering.
      return new Promise(function (resolve, reject) {
        fs.readFile(path, "utf8", (err, data) => {
          
          let notFoundTemplate = `
     <h2><i class="fa fa-exclamation-triangle text-warning"></i> 204 No Content</h2>
     <p>The server successfully processed the request, but is not returning any content.</p>
     <p>The content may be available again in the future.</p>`;
          if (err) reject(notFoundTemplate);
          //return resolve(converter.makeHtml(data));
         
          return resolve(marked.parse(data));
         // return resolve(data);
        });
      });
    } 
  }

// &#63; to ? helper
function htmlEscapeToText (text)
{
  return text.replace(/\&\#[0-9]*;|&amp;/g, function (escapeCode) {
    if (escapeCode.match(/amp/)) {
      return '&';
    }
    return String.fromCharCode(escapeCode.match(/[0-9]+/));
  });
}

module.exports = {
  LoadContents: loadContents
};