Rewrite phase 1.

Started improved client code structure.

Implemented session based authentication serverside.

Implemented user, match, and sport database models serverside.

Implemented Controllers for variety of C and R operations of CRUD.

sports-matcher/server/schemas/matchModel.js

@@ -0,0 +1,27 @@
+import mongoose from "mongoose";
+import ModelNameRegister from "./modelNameRegister.js";
+
+const Types = mongoose.Schema.Types; // Some types require defining from this object.
+
+const matchSchema = new mongoose.Schema({
+    title: { type: String, required: true, trim: true },
+    when: { type: Date, required: true },
+    publicity: { type: Number, required: true, default: 2 },
+    location: {
+        type: [Number],
+        required: true,
+        validate: {
+            validator: function (v) {
+                return v.length === 2;
+            },
+            message: "Invalid coordinate format (array not length of 2)."
+        }
+    },
+    creator: { type: Types.ObjectId, ref: ModelNameRegister.User },
+    participants: { type: [{ type: Types.ObjectId, ref: ModelNameRegister.User }], required: true, default: [] },
+    difficulty: { type: Number, required: true },
+    sport: { type: Types.ObjectId, ref: ModelNameRegister.Sport },
+    createDate: { type: Date, required: true, default: Date.now }
+});
+
+export default mongoose.model(ModelNameRegister.Match, matchSchema);

sports-matcher/server/schemas/modelNameRegister.js

@@ -0,0 +1,5 @@
+export default {
+    Match: "match",
+    User: "user",
+    Sport: "sport"
+};

sports-matcher/server/schemas/sportModel.js

@@ -0,0 +1,19 @@
+import mongoose from "mongoose";
+import ModelNameRegister from "./modelNameRegister.js";
+
+const sportSchema = new mongoose.Schema({
+    name: { type: String, required: true, unique: true, trim: true },
+    minPlayers: { type: Number, required: true, default: 1 },
+    description: { type: String, required: true, trim: true }
+});
+
+sportSchema.pre("save", function (next) {
+    this.name = this.name.toLowerCase();
+    next();
+});
+
+sportSchema.statics.findByName = function (name) {
+    return this.findOne({ name: name.trim().toLowerCase() });
+};
+
+export default mongoose.model(ModelNameRegister.Sport, sportSchema);

sports-matcher/server/schemas/userModel.js

@@ -0,0 +1,68 @@
+import mongoose from "mongoose";
+import validator from "validator";
+import bcrypt from "bcrypt";
+import modelNameRegister from "./modelNameRegister.js";
+
+const Types = mongoose.Schema.Types;
+
+const userSchema = new mongoose.Schema({
+    email: {
+        type: String,
+        required: true,
+        minlength: 1,
+        trim: true,
+        unique: true,
+        validate: {
+            validator: validator.isEmail,
+            message: "String not email.",
+        }
+    },
+    firstName: { type: String, required: true, trim: true },
+    lastName: { type: String, required: true, trim: true },
+    joinDate: { type: Date, default: Date.now, required: true },
+    phone: { type: Number, required: false, min: 0 },
+    password: {
+        type: String,
+        required: true,
+        minlength: 8
+        // TODO: Custom validator for password requirements?
+    },
+    createdMatches: { type: [{ type: Types.ObjectId, ref: modelNameRegister.Match }], required: true, default: [] },
+    participatingMatches: { type: [{ type: Types.ObjectId, ref: modelNameRegister.Match }], required: true, default: [] },
+    emailPublicity: { type: Number, required: true, default: 0 },
+    bioPublicity: { type: Boolean, required: true, default: false },
+    phonePublicity: { type: Boolean, required: true, default: false },
+    participatingMatchesPublicity: { type: Boolean, required: true, default: false },
+    friends: { type: Types.ObjectId, ref: modelNameRegister.User },
+    accessLevel: { type: Number, required: true, default: 0 },
+});
+
+userSchema.statics.credentialsExist = async function (email, password) {
+    let userModel = this;
+    let user = await userModel.findOne({ email: email });
+    if (!user) {
+        return Promise.reject(new Error("Credentials do not exist."));
+    }
+    if (await bcrypt.compare(password, user.password)) {
+        return user;
+    }
+};
+
+userSchema.pre("save", function (next) {
+    let user = this;
+    if (user.isModified("password")) { // Only perform hashing if the password has changed.
+        bcrypt.genSalt(10, (err, salt) => {
+            bcrypt.hash(user.password, salt, (err, hash) => {
+                if (err) {
+                    throw err; // Probably not, but I'm gonna leave this here for now.
+                }
+                user.password = hash;
+                next();
+            });
+        });
+    } else {
+        next();
+    }
+});
+
+export default mongoose.model(modelNameRegister.User, userSchema);