Initial commit

TODO: change api.conf URL references to use environment variables and add these variables to the docker-compose configuration for host domain

api/db/config.js

@@ -0,0 +1,19 @@
+// dotenv
+//   .config()
+
+module.exports = {
+  HOST: process.env.DB_HOST,
+  PORT: process.env.DB_PORT,
+  // USER: process.env.DB_USER,
+  USER: 'root',
+  // PASSWORD: process.env.DB_PASSWORD,
+  PASSWORD: process.env.DB_ROOT_PASSWORD,
+  DATABASE: process.env.DB_DATABASE,
+  dialect: "mysql",
+  pool: {
+    max: 5,
+    min: 0,
+    acquire: 30000,
+    idle: 10000
+  }
+};

api/db/controllers/Award.controller.js

@@ -0,0 +1,70 @@
+const db = require("..");
+const Award = db.Award;
+const Op = db.Sequelize.Op;
+
+// Create and Save a new Award
+exports.create = (req, res) => {
+  // Validate
+  if (!req.body) {
+    res.status(400).send({
+      message: "Body content can not be empty!"
+    });
+    return;
+  }
+
+  const awards = []
+
+  if (Array.isArray(req.body)) {
+    awards.push(...req.body)
+  } else {
+    awards.push(req.body)
+  }
+
+  // Save
+  const promises = awards.map(award => {
+    return Award.create(award)
+  });
+
+  // Create
+  const successes = []
+  const failures = []
+  Promise.allSettled(promises)
+    .then(data => {
+      if (data.every(result => result.status === 'fulfilled')) {
+        res.status(201).send({
+          message: "All awards were created successfully.",
+          successes: data.map(result => result.value),
+          failures: [],
+        })
+        return;
+      }
+
+      data.forEach(result => {
+        if (result.status === 'fulfilled') {
+          successes.push(result.value)
+        } else {
+          failures.push(result.reason.errors)
+        }
+      })
+      if (successes.length === 0) {
+        res.status(500).send({
+          message:
+            "Failed to create any Awards.",
+          failures: failures,
+          successes: successes,
+        });
+        return;
+      }
+      res.status(207).send({
+        message: "Some Awards were created successfully.",
+        successes: successes,
+        failures: failures,
+      })
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while creating the Award.",
+      });
+    });
+};

api/db/controllers/Course.controller.js

@@ -0,0 +1,176 @@
+const db = require("../");
+const Course = db.Course;
+const Op = db.Sequelize.Op;
+
+// Create and Save a new Course
+exports.create = (req, res) => {
+  // Validate
+  if (!req.body) {
+    res.status(400).send({
+      message: "Body content can not be empty!"
+    });
+    return;
+  }
+
+  // Create
+  const courses = []
+
+  if (Array.isArray(req.body)) {
+    courses.push(...req.body)
+  } else {
+    courses.push(req.body)
+  }
+
+  // Save
+  const promises = []
+  courses.forEach(course => {
+    promises.push(Course.create(course))
+  });
+
+  const successes = []
+  const failures = []
+  Promise.allSettled(promises)
+    .then(data => {
+      if (data.every(result => result.status === 'fulfilled')) {
+        res.status(201).send({
+          message: "All courses were created successfully.",
+          successes: data.map(result => result.value),
+          failures: [],
+        })
+        return;
+      }
+
+      data.forEach(result => {
+        if (result.status === 'fulfilled') {
+          successes.push(result.value)
+        } else {
+          failures.push(result.reason)
+        }
+      })
+      res.status(207).send({
+        message: "Some courses were created successfully.",
+        successes: successes,
+        failures: failures,
+      })
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while creating the Course.",
+
+      });
+    });
+};
+
+// Retrieve all Courses from the database.
+exports.findAll = (req, res) => {
+  const name = req.query.name;
+  var condition = name ? { name: { [Op.like]: `%${name}%` } } : null;
+
+  Course.findAll({ where: condition, include: ['trainingsHeld'] })
+    .then(data => {
+      res.send(data);
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving courses."
+      });
+    });
+};
+
+// Find a single Course with an id
+exports.findOne = (req, res) => {
+  const id = req.params.id;
+
+  Course.findByPk(id)
+    .then(data => {
+      res.send(data);
+    })
+    .catch(err => {
+      res.status(500).send({
+        message: "Error retrieving Course with id=" + id
+      });
+    });
+};
+
+// Update a Course by the id in the request
+exports.update = (req, res) => {
+  const id = req.params.id;
+
+  Course.update(req.body, {
+    where: { id: id }
+  })
+    .then(num => {
+      if (num == 1) {
+        res.send({
+          message: "Course was updated successfully."
+        });
+      } else {
+        res.send({
+          message: `Cannot update Course with id=${id}. Maybe Course was not found or req.body is empty!`
+        });
+      }
+    })
+    .catch(err => {
+      res.status(500).send({
+        message: "Error updating Course with id=" + id
+      });
+    });
+};
+
+// Delete a Course with the specified id in the request
+exports.delete = (req, res) => {
+  const id = req.params.id;
+
+  Course.destroy({
+    where: { id: id }
+  })
+    .then(num => {
+      if (num == 1) {
+        res.send({
+          message: "Course was deleted successfully!"
+        });
+      } else {
+        res.send({
+          message: `Cannot delete Course with id=${id}. Maybe Course was not found!`
+        });
+      }
+    })
+    .catch(err => {
+      res.status(500).send({
+        message: "Could not delete Course with id=" + id
+      });
+    });
+};
+
+// Delete all Courses from the database.
+exports.deleteAll = (req, res) => {
+  Course.destroy({
+    where: {},
+    truncate: false
+  })
+    .then(nums => {
+      res.send({ message: `${nums} Courses were deleted successfully!` });
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while removing all courses."
+      });
+    });
+};
+
+// Find all published Courses
+exports.findAllPublished = (req, res) => {
+  Course.findAll({ where: { published: true } })
+    .then(data => {
+      res.send(data);
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving courses."
+      });
+    });
+};

api/db/controllers/Member.controller.js

@@ -0,0 +1,100 @@
+const db = require("..");
+const Member = db.Member;
+const Op = db.Sequelize.Op;
+
+// Create and Save a new Member
+exports.create = (req, res) => {
+  // Validate
+  if (!req.body) {
+    res.status(400).send({
+      message: "Body content can not be empty!"
+    });
+    return;
+  }
+
+  // Create
+  const members = []
+
+  if (Array.isArray(req.body)) {
+    members.push(...req.body)
+  } else {
+    members.push(req.body)
+  }
+
+  // Save
+  const promises = members.map(member => {
+    return Member.create(member)
+      .then(memberObj => {
+        if (req.body.rankId) {
+          db.Rank.findByPk(req.body.rankId)
+            .then(rank => {
+              memberObj.setRank(rank)
+            })
+        }
+        if (req.body.statusId) {
+          db.MemberStatus.findByPk(req.body.statusId)
+            .then(status => {
+              memberObj.setStatus(status)
+            })
+        }
+        return memberObj
+      })
+  });
+
+  // Create
+  const successes = []
+  const failures = []
+  Promise.allSettled(promises)
+    .then(data => {
+      if (data.every(result => result.status === 'fulfilled')) {
+        res.status(201).send({
+          message: "All members were created successfully.",
+          successes: data.map(result => result.value),
+          failures: [],
+        })
+        return;
+      }
+
+      data.forEach(result => {
+        if (result.status === 'fulfilled') {
+          successes.push(result.value)
+        } else {
+          failures.push(result.reason.errors)
+        }
+      })
+      if (successes.length === 0) {
+        res.status(500).send({
+          message:
+            "Failed to create any Members.",
+          failures: failures,
+          successes: successes,
+        });
+        return;
+      }
+      res.status(207).send({
+        message: "Some Members were created successfully.",
+        successes: successes,
+        failures: failures,
+      })
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while creating the Member.",
+      });
+    });
+};
+
+// Retrieve all Members from the database.
+exports.findAll = (req, res) => {
+  Member.findAll()
+    .then(data => {
+      res.send(data);
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving members."
+      });
+    });
+};

api/db/controllers/Rank.controller.js

@@ -0,0 +1,70 @@
+const db = require("..");
+const Rank = db.Rank;
+const Op = db.Sequelize.Op;
+
+// Create and Save a new Rank
+exports.create = (req, res) => {
+  // Validate
+  if (!req.body) {
+    res.status(400).send({
+      message: "Body content can not be empty!"
+    });
+    return;
+  }
+
+  const ranks = []
+
+  if (Array.isArray(req.body)) {
+    ranks.push(...req.body)
+  } else {
+    ranks.push(req.body)
+  }
+
+  // Save
+  const promises = ranks.map(rank => {
+    return Rank.create(rank)
+  });
+
+  // Create
+  const successes = []
+  const failures = []
+  Promise.allSettled(promises)
+    .then(data => {
+      if (data.every(result => result.status === 'fulfilled')) {
+        res.status(201).send({
+          message: "All ranks were created successfully.",
+          successes: data.map(result => result.value),
+          failures: [],
+        })
+        return;
+      }
+
+      data.forEach(result => {
+        if (result.status === 'fulfilled') {
+          successes.push(result.value)
+        } else {
+          failures.push(result.reason.errors)
+        }
+      })
+      if (successes.length === 0) {
+        res.status(500).send({
+          message:
+            "Failed to create any Ranks.",
+          failures: failures,
+          successes: successes,
+        });
+        return;
+      }
+      res.status(207).send({
+        message: "Some Ranks were created successfully.",
+        successes: successes,
+        failures: failures,
+      })
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while creating the Rank.",
+      });
+    });
+};

api/db/index.js

@@ -0,0 +1,260 @@
+// require dbconfig
+const dbConfig = require("./config.js");
+
+
+// create connection to database
+const Sequelize = require("sequelize");
+const sequelize = new Sequelize(
+  dbConfig.DATABASE,
+  dbConfig.USER,
+  dbConfig.PASSWORD,
+  {
+    host: dbConfig.HOST,
+    port: dbConfig.PORT,
+    dialect: dbConfig.dialect,
+
+    pool: {
+      max: dbConfig.pool.max,
+      min: dbConfig.pool.min,
+      acquire: dbConfig.pool.acquire,
+      idle: dbConfig.pool.idle
+    }
+  }
+);
+
+try {
+  sequelize.authenticate();
+} catch (error) {
+  console.error('Unable to connect to the database:', error);
+  return
+}
+
+
+
+const db = {};
+
+db.Sequelize = Sequelize;
+db.instance = sequelize;
+
+db.Member = db.instance.define("Member", require("./models/Member.model.js"), { paranoid: true })
+db.Award = db.instance.define("Award", require("./models/Award.model.js"), { paranoid: true })
+db.Course = db.instance.define("Course", require("./models/Course.model.js"), { paranoid: true })
+db.Rank = db.instance.define("Rank", require("./models/Rank.model.js"), { paranoid: true })
+
+db.AwardAction = db.instance.define("AwardAction", require("./junctionModels/AwardAction.js"), { paranoid: true })
+db.CourseEventTrainingReport = db.instance.define("CourseEventTrainingReport", require("./junctionModels/CourseEventTrainingReport.model.js"), { paranoid: true })
+db.CourseEvent = db.instance.define("CourseEvent", require("./models/CourseEvent.js"), { paranoid: true })
+
+// Members have ranks
+db.Rank.hasMany(db.Member, {
+  as: "members",
+  foreignKey: "rankId"
+})
+db.Member.belongsTo(db.Rank, {
+  as: "rank",
+  foreignKey: "rankId"
+})
+
+// Members have statuses
+db.MemberStatus = db.instance.define("MemberStatus", require("./models/MemberStatus.model.js"), { paranoid: true })
+db.MemberStatus.hasMany(db.Member, {
+  as: "members",
+  foreignKey: "statusId"
+})
+db.Member.belongsTo(db.MemberStatus, {
+  as: "status",
+  foreignKey: "statusId"
+})
+
+
+// * AWARDS
+// Awards have a creator
+db.Award.belongsTo(db.Member, {
+  as: "createdBy",
+  foreignKey: "createdById"
+})
+db.Member.hasMany(db.Award, {
+  as: "awardsCreated",
+  foreignKey: "createdById"
+})
+// Awards have a last modified by
+db.Award.belongsTo(db.Member, {
+  as: "lastModifiedBy",
+  foreignKey: "lastModifiedById"
+})
+db.Member.hasMany(db.Award, {
+  as: "awardsLastModified",
+  foreignKey: "lastModifiedById"
+})
+// Members are granted awards
+db.Award.belongsToMany(db.Member, {
+  through: db.AwardAction,
+  as: "awardHolders",
+  foreignKey: "recipientId",
+});
+db.Member.belongsToMany(db.Award, {
+  through: db.AwardAction,
+  as: "awardsEarned",
+  foreignKey: "awardId"
+});
+// * AWARDS GRANTED/REVOKED
+// Instances of award grants have a creator
+db.AwardAction.belongsTo(db.Member, {
+  as: "createdBy",
+  foreignKey: "createdById"
+})
+db.Member.hasMany(db.AwardAction, {
+  as: "awardGrantsCreated",
+  foreignKey: "createdById"
+})
+// Instances of award grants have a last modified by
+db.AwardAction.belongsTo(db.Member, {
+  as: "lastModifiedBy",
+  foreignKey: "lastModifiedById"
+})
+db.Member.hasMany(db.AwardAction, {
+  as: "awardGrantsLastModified",
+  foreignKey: "lastModifiedById"
+})
+// Instances of award grants have the acting member
+db.AwardAction.belongsTo(db.Member, {
+  as: "actor",
+  foreignKey: "actorId"
+})
+db.Member.hasMany(db.AwardAction, {
+  as: "awardGrantsGiven",
+  foreignKey: "actorId"
+})
+// Instances of award grants have the recipient
+db.AwardAction.belongsTo(db.Member, {
+  as: "recipient",
+  foreignKey: "recipientId"
+})
+db.Member.hasMany(db.AwardAction, {
+  as: "awardGrantsReceived",
+  foreignKey: "recipientId"
+})
+// Instances of award grants have the award
+db.AwardAction.belongsTo(db.Award, {
+  as: "award",
+  foreignKey: "awardId"
+})
+db.Award.hasMany(db.AwardAction, {
+  as: "awardGrants",
+  foreignKey: "awardId"
+})
+
+
+
+// * COURSE EVENTS
+// Events have a creator
+db.CourseEvent.belongsTo(db.Member, {
+  as: "createdBy",
+  foreignKey: "createdById"
+})
+db.Member.hasMany(db.CourseEvent, {
+  as: "courseEventsCreated",
+  foreignKey: "createdById"
+})
+// Events have a last modified by
+db.CourseEvent.belongsTo(db.Member, {
+  as: "lastModifiedBy",
+  foreignKey: "lastModifiedById"
+})
+db.Member.hasMany(db.CourseEvent, {
+  as: "courseEventsLastModified",
+  foreignKey: "lastModifiedById"
+})
+// Events have a course that's taught
+db.CourseEvent.belongsTo(db.Course, {
+  as: "courseTaught",
+  foreignKey: "courseTaughtId"
+})
+db.Course.hasMany(db.CourseEvent, {
+  as: "trainingsHeld",
+  foreignKey: "courseTaughtId"
+})
+// Events have one or more trainer
+db.CourseEvent.belongsToMany(db.Member, {
+  through: "CourseEventsTrainers",
+  as: "trainers",
+  foreignKey: "trainerId"
+})
+db.Member.belongsToMany(db.CourseEvent, {
+  through: "CourseEventsTrainers",
+  as: "courseEventsTaught",
+  foreignKey: "courseEventId"
+})
+// Events have one or more observer
+db.CourseEvent.belongsToMany(db.Member, {
+  through: "CourseEventsObservers",
+  as: "observers",
+  foreignKey: "courseEventId"
+})
+db.Member.belongsToMany(db.CourseEvent, {
+  through: "CourseEventsObservers",
+  as: "courseEventsObserved",
+  foreignKey: "observerId"
+})
+// Events have one or more attendees, each of which passed or did not
+db.CourseEvent.belongsToMany(db.Member, {
+  through: db.CourseEventTrainingReport,
+  as: "attendees",
+  foreignKey: "attendeeId"
+});
+db.Member.belongsToMany(db.CourseEvent, {
+  through: db.CourseEventTrainingReport,
+  as: "courseEventsAttended",
+  foreignKey: "courseEventId"
+});
+
+
+// * COURSES
+// Courses have a creator
+db.Course.belongsTo(db.Member, {
+  as: "createdBy",
+  foreignKey: "createdById"
+})
+db.Member.hasMany(db.Course, {
+  as: "coursesCreated",
+  foreignKey: "createdById"
+})
+// Courses have a last modified by
+db.Course.belongsTo(db.Member, {
+  as: "lastModifiedBy",
+  foreignKey: "lastModifiedById"
+})
+db.Member.hasMany(db.Course, {
+  as: "coursesLastModified",
+  foreignKey: "lastModifiedById"
+})
+// Courses have SMEs
+db.Course.belongsToMany(db.Member, {
+  through: "CoursesSME",
+  as: "sme",
+  foreignKey: "smeId"
+})
+db.Member.belongsToMany(db.Course, {
+  through: "CoursesSME",
+  as: "coursesSMEFor",
+  foreignKey: "courseId"
+})
+
+
+
+// Courses belong to award paths
+db.Award.belongsToMany(db.Course, {
+  through: "CoursesAwards",
+  as: "coursesRequired",
+  foreignKey: "courseId"
+});
+// Awards have pre-requisite courses
+db.Course.belongsToMany(db.Award, {
+  through: "CoursesAwards",
+  as: "possibleAwards",
+  foreignKey: "awardId"
+});
+
+
+
+module.exports = db;

api/db/junctionModels/AwardAction.js

@@ -0,0 +1,34 @@
+const Sequelize = require('sequelize');
+
+module.exports = {
+  actionDate: {
+    type: Sequelize.DataTypes.DATEONLY,
+    allowNull: false,
+    defaultValue: Sequelize.DataTypes.NOW
+  },
+  isGrantEvent: {
+    type: Sequelize.DataTypes.BOOLEAN,
+    allowNull: true,
+    defaultValue: true
+  },
+  actorId: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  recipientId: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  awardId: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  createdById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  lastModifiedById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+}

api/db/junctionModels/courseEventTrainingReport.model.js

@@ -0,0 +1,21 @@
+const Sequelize = require('sequelize');
+
+module.exports = {
+  attendeeId: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  courseEventId: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  passed: {
+    type: Sequelize.DataTypes.BOOLEAN,
+    allowNull: false,
+    defaultValue: false
+  },
+  notes: {
+    type: Sequelize.DataTypes.STRING(500),
+    allowNull: true,
+  }
+}

api/db/models/Award.model.js

@@ -0,0 +1,37 @@
+const Sequelize = require('sequelize');
+
+module.exports = {
+  name: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: false,
+  },
+  shortName: {
+    type: Sequelize.DataTypes.STRING(70),
+    allowNull: false
+  },
+  description: {
+    type: Sequelize.DataTypes.STRING(1000),
+    allowNull: true
+  },
+  category: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: false
+  },
+  imageUrl: {
+    type: Sequelize.DataTypes.STRING,
+    allowNull: true,
+    isUrl: true
+  },
+  footprint: {
+    type: Sequelize.DataTypes.STRING(45),
+    allowNull: false
+  },
+  createdById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  lastModifiedById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+};

api/db/models/Course.model.js

@@ -0,0 +1,32 @@
+const Sequelize = require("sequelize");
+
+module.exports = {
+  name: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: false
+  },
+  shortName: {
+    type: Sequelize.DataTypes.STRING(70),
+    allowNull: false
+  },
+  category: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: false
+  },
+  description: {
+    type: Sequelize.DataTypes.STRING(1000),
+    allowNull: true
+  },
+  imageUrl: {
+    type: Sequelize.DataTypes.STRING,
+    allowNull: true
+  },
+  createdById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  lastModifiedById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+};

api/db/models/CourseEvent.js

@@ -0,0 +1,25 @@
+const Sequelize = require('sequelize');
+
+module.exports = {
+  notes: {
+    type: Sequelize.DataTypes.STRING(1000),
+    allowNull: true,
+  },
+  runDate: {
+    type: Sequelize.DataTypes.DATEONLY,
+    allowNull: false,
+    defaultValue: Sequelize.DataTypes.NOW
+  },
+  courseTaughtId: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  createdById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  lastModifiedById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+}

api/db/models/Member.model.js

@@ -0,0 +1,53 @@
+const Sequelize = require('sequelize');
+
+module.exports = {
+  name: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: false,
+    unique: true
+  },
+  email: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: true,
+    // validate: {
+    //   isEmail: true
+    // }
+  },
+  password: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: true
+  },
+  website: {
+    type: Sequelize.DataTypes.STRING(240),
+    allowNull: true,
+    // validate: {
+    //   isUrl: true
+    // }
+  },
+  steamId64: {
+    type: Sequelize.DataTypes.STRING(17),
+    allowNull: true,
+    unique: true
+  },
+  steamProfileName: {
+    type: Sequelize.DataTypes.STRING(32),
+    allowNull: true
+  },
+  discordId: {
+    type: Sequelize.DataTypes.STRING(18),
+    unique: true,
+    allowNull: true
+  },
+  discordUsername: {
+    type: Sequelize.DataTypes.STRING(32),
+    allowNull: true
+  },
+  createdById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  lastModifiedById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+};

api/db/models/MemberStatus.model.js

@@ -0,0 +1,16 @@
+const Sequelize = require('sequelize');
+
+module.exports = {
+  name: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: false,
+  },
+  createdById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  lastModifiedById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+};

api/db/models/Rank.model.js

@@ -0,0 +1,35 @@
+const Sequelize = require('sequelize');
+
+module.exports = {
+  name: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: false,
+    unique: true
+  },
+  shortName: {
+    type: Sequelize.DataTypes.STRING(70),
+    allowNull: false
+  },
+  category: {
+    type: Sequelize.DataTypes.STRING(100),
+    allowNull: false
+  },
+  sortId: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+    defaultValue: 0
+  },
+  imageUrl: {
+    type: Sequelize.DataTypes.STRING(240),
+    allowNull: true,
+    isUrl: true
+  },
+  createdById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+  lastModifiedById: {
+    type: Sequelize.DataTypes.INTEGER,
+    allowNull: false,
+  },
+};

api/db/routes/Award.route.js

@@ -0,0 +1,98 @@
+
+const award = require("../controllers/Award.controller.js");
+
+const db = require("..");
+
+var router = require("express").Router();
+
+// Create a new Award
+router.post("/", award.create);
+
+// GET AWARD
+router.get("/", async (req, res) => {
+  const id = req.query.id;
+  if (!id) {
+    return db.Award.findAll()
+      .then(results => res.send(results))
+  }
+
+  return db.Award.findByPk(id)
+    .then(async (award) => {
+      if (award === null) {
+        res.status(404).send({
+          message: `Award with id=${id} was not found!`
+        });
+        return
+      }
+      res.send(award)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving awards."
+      })
+    })
+});
+
+// GET AWARD DETAILS
+router.get("/details", async (req, res) => {
+  const id = req.query.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Award id cannot be empty!"
+    });
+    return
+  }
+  return db.Award.findByPk(id, {
+    include: [
+      'awardHolders',
+      'coursesRequired'
+    ]
+  })
+    .then(async (award) => {
+      if (award === null) {
+        res.status(404).send({
+          message: `Award with id=${id} was not found!`
+        });
+        return
+      }
+      res.send(award)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving awards."
+      })
+    })
+});
+
+
+// GET CATEGORIES
+router.get("/categories", async (req, res) => {
+  return db.Award.findAll({
+    attributes: ['category'],
+    group: ['category']
+  })
+    .then(async (awardCategories) => {
+      if (awardCategories === null) {
+        res.status(404).send({
+          message: `Award categories were not found!`
+        });
+        return
+      }
+      res.send(awardCategories.map(awardCategory => awardCategory.category))
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving award categories."
+      })
+    })
+});
+
+
+
+module.exports = {
+  apiPath: "/api/awards",
+  apiRouter: router
+};

api/db/routes/Course.route.js

@@ -0,0 +1,96 @@
+const courses = require("../controllers/Course.controller.js");
+
+const db = require("..");
+
+var router = require("express").Router();
+
+// Create a new Course
+router.post("/", courses.create);
+
+// GET AWARD
+router.get("/", async (req, res) => {
+  const id = req.query.id;
+  if (!id) {
+    return db.Course.findAll()
+      .then(results => res.send(results))
+  }
+
+  return db.Course.findByPk(id)
+    .then(async (course) => {
+      if (course === null) {
+        res.status(404).send({
+          message: `Course with id=${id} was not found!`
+        });
+        return
+      }
+      res.send(course)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving courses."
+      })
+    })
+});
+
+// GET AWARD DETAILS
+router.get("/details", async (req, res) => {
+  const id = req.query.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Course id cannot be empty!"
+    });
+    return
+  }
+  return db.Course.findByPk(id, {
+    include: [
+      'trainingsHeld',
+      'possibleAwards',
+      'sme'
+    ]
+  })
+    .then(async (course) => {
+      if (course === null) {
+        res.status(404).send({
+          message: `Course with id=${id} was not found!`
+        });
+        return
+      }
+      res.send(course)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving courses."
+      })
+    })
+});
+
+
+// GET CATEGORIES
+router.get("/categories", async (req, res) => {
+  return db.Course.findAll({
+    attributes: ['category'],
+    group: ['category']
+  })
+    .then(async (courseCategories) => {
+      if (courseCategories === null) {
+        res.status(404).send({
+          message: `Course categories were not found!`
+        });
+        return
+      }
+      res.send(courseCategories.map(courseCategory => courseCategory.category))
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving course categories."
+      })
+    })
+});
+
+module.exports = {
+  apiPath: "/api/courses",
+  apiRouter: router
+};

api/db/routes/Member.route.js

@@ -0,0 +1,231 @@
+
+const member = require("../controllers/Member.controller.js");
+
+const db = require("..");
+
+var router = require("express").Router();
+
+// Create a new Member
+router.post("/", member.create);
+// Retrieve all Members
+router.get("/", member.findAll);
+
+// GET MEMBER
+router.get("/:id", async (req, res) => {
+  const id = req.params.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Member id cannot be empty!"
+    });
+    return
+  }
+  return db.Member.findByPk(id)
+    .then(async (member) => {
+      if (member === null) {
+        res.status(404).send({
+          message: `Member with id=${id} was not found!`
+        });
+        return
+      }
+      res.send(member)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving members."
+      })
+    })
+});
+
+// GET MEMBER DETAILS
+router.get("/:id/details", async (req, res) => {
+  const id = req.params.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Member id cannot be empty!"
+    });
+    return
+  }
+  return db.Member.findByPk(id, {
+    include: [
+      'rank',
+      'status',
+      'awards',
+      'coursesSMEFor',
+      'coursesTaught',
+      'coursesAttended'
+    ]
+  })
+    .then(async (member) => {
+      if (member === null) {
+        res.status(404).send({
+          message: `Member with id=${id} was not found!`
+        });
+        return
+      }
+      res.send(member)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving members."
+      })
+    })
+});
+
+
+// COURSES TAUGHT
+router.get("/:id/courses/taught", async (req, res) => {
+  const id = req.params.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Member id cannot be empty!"
+    });
+    return
+  }
+  return db.Member.findByPk(id)
+    .then(async (member) => {
+      if (member === null) {
+        res.status(404).send({
+          message: `Member with id=${id} was not found!`
+        });
+        return
+      }
+      const courses = await member.getCoursesSMEFor()
+      res.send(courses)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving members."
+      })
+    })
+});
+
+// COURSES ATTENDED
+router.get("/:id/courses/attended", async (req, res) => {
+  const id = req.params.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Member id cannot be empty!"
+    });
+    return
+  }
+  return db.Member.findByPk(id)
+    .then(async (member) => {
+      if (member === null) {
+        res.status(404).send({
+          message: `Member with id=${id} was not found!`
+        });
+        return
+      }
+      const courses = await member.getCoursesAttended()
+      res.send(courses)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving members."
+      })
+    })
+});
+
+// COURSES SME FOR
+router.get("/:id/courses/sme", async (req, res) => {
+  const id = req.params.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Member id cannot be empty!"
+    });
+    return
+  }
+  return db.Member.findByPk(id)
+    .then(async (member) => {
+      if (member === null) {
+        res.status(404).send({
+          message: `Member with id=${id} was not found!`
+        });
+        return
+      }
+      const courses = await member.getCoursesSMEFor()
+      res.send(courses)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving members."
+      })
+    })
+});
+
+
+// UPDATE MEMBER
+router.put("/:id", async (req, res) => {
+  const id = req.params.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Member id cannot be empty!"
+    });
+    return
+  }
+  return db.Member.findByPk(id)
+    .then(async (member) => {
+      if (member === null) {
+        res.status(404).send({
+          message: `Member with id=${id} was not found!`
+        });
+        return
+      }
+      member.set(req.body)
+      await member.save()
+      res.send(member)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving members.",
+        error: err
+      })
+    })
+});
+
+
+// Delete a Member with id
+router.delete("/:id", async (req, res) => {
+  const id = req.params.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Member id cannot be empty!"
+    });
+    return
+  }
+  return db.Member.findByPk(id)
+    .then(async (member) => {
+      if (member === null) {
+        res.status(404).send({
+          message: `Member with id=${id} was not found!`
+        });
+        return
+      }
+      await member.destroy()
+      res.send({
+        deleted: member,
+        message: `Member with id=${id} was deleted!`
+      })
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving members.",
+        error: err
+      })
+    })
+});
+
+// Delete all Members
+// router.delete("/", member.deleteAll);
+
+module.exports = {
+  apiPath: "/api/members",
+  apiRouter: router
+};

api/db/routes/Rank.route.js

@@ -0,0 +1,95 @@
+const rank = require("../controllers/Rank.controller.js");
+
+const db = require("..");
+
+var router = require("express").Router();
+
+// Create a new Rank
+router.post("/", rank.create);
+
+// GET RANK
+router.get("/", async (req, res) => {
+  const id = req.query.id;
+  if (!id) {
+    return db.Rank.findAll()
+      .then(results => res.send(results))
+  }
+
+  return db.Rank.findByPk(id)
+    .then(async (rank) => {
+      if (rank === null) {
+        res.status(404).send({
+          message: `Rank with id=${id} was not found!`
+        });
+        return
+      }
+      res.send(rank)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving ranks."
+      })
+    })
+});
+
+// GET RANK DETAILS
+router.get("/details", async (req, res) => {
+  const id = req.query.id;
+  if (!id) {
+    res.status(400).send({
+      message: "Rank id cannot be empty!"
+    });
+    return
+  }
+  return db.Rank.findByPk(id, {
+    include: [
+      'members',
+    ]
+  })
+    .then(async (rank) => {
+      if (rank === null) {
+        res.status(404).send({
+          message: `Rank with id=${id} was not found!`
+        });
+        return
+      }
+      res.send(rank)
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving ranks."
+      })
+    })
+});
+
+
+// GET CATEGORIES
+router.get("/categories", async (req, res) => {
+  return db.Rank.findAll({
+    attributes: ['category'],
+    group: ['category']
+  })
+    .then(async (rankCategories) => {
+      if (rankCategories === null) {
+        res.status(404).send({
+          message: `Rank categories were not found!`
+        });
+        return
+      }
+      res.send(rankCategories.map(rankCategory => rankCategory.category))
+    })
+    .catch(err => {
+      res.status(500).send({
+        message:
+          err.message || "Some error occurred while retrieving rank categories."
+      })
+    })
+});
+
+
+module.exports = {
+  apiPath: "/api/ranks",
+  apiRouter: router
+};