Added TS Compiler Output Bundle (#11)

backend/dist/index.js

@@ -0,0 +1,89 @@
+import express from "express";
+import dotenv from "dotenv";
+import os from "os";
+import bodyParser from "body-parser";
+import mongoose from "mongoose";
+import cors from "cors";
+import cloudinary from "cloudinary";
+// Middleware
+import tracker from "./middleware/tracker.js";
+import setHeaders from "./utils/setHeaders.js";
+// Auth
+import register from "./routes/auth/register.js";
+import login from "./routes/auth/login.js";
+import logout from "./routes/auth/logout.js";
+// CRUD
+import get_user from "./routes/crud/read/get_user.js";
+import get_machines from "./routes/crud/read/get_machines.js";
+import get_workouts from "./routes/crud/read/get_workouts.js";
+import update_user from "./routes/crud/update/update_user.js";
+import update_cardio from "./routes/crud/update/update_cardio.js";
+import add_machine from "./routes/crud/update/add_machine.js";
+import create_workout from "./routes/crud/create/create_workout.js";
+import create_machine from "./routes/crud/create/create_machine.js";
+import update_status from "./routes/crud/update/update_status.js";
+import end_workout from "./routes/crud/delete/end_workout.js";
+import rate_workout from "./routes/crud/update/rate_workout.js";
+import create_exercise from "./routes/crud/create/create_exercise.js";
+import update_set from "./routes/crud/update/update_set.js";
+dotenv.config();
+const PORT = process.env.PORT;
+// Image Storage
+cloudinary.config({
+ cloud_name: process.env.CLOUD_NAME,
+ api_key: process.env.CLOUDINARY_API_KEY,
+ api_secret: process.env.CLOUDINARY_API_SECRET
+});
+const app = express();
+app.use(bodyParser.urlencoded({ extended: true }));
+// Parse incoming requests data as JSON.
+app.use(bodyParser.json());
+// Allow cross-origin requests.
+app.use(cors());
+// Track the requests to the backend.
+app.use(tracker);
+// Set the headers for the requests.
+app.use(setHeaders);
+// Register a user endpoint.
+app.use("/api/users/register", register);
+// Login a user endpoint.
+app.use("/api/users/login", login);
+// Logout a user endpoint.
+app.use("/api/users/logout", logout);
+// Create a new workout for a user.
+app.use("/api/workouts/create", create_workout);
+// Add a machine to the dixon collectiion
+app.use("/api/machine/create", create_machine);
+// Add an exercise to a workout.
+app.use("/api/workout/exercises/add", create_exercise);
+// Add a new machine to a workout.
+app.use("/api/workout/machines/add", add_machine);
+// Update a machine's status in a workout.
+app.use("/api/machine/update_status", update_status);
+// Update cardio machine 'x' with a distance and time spent.
+app.use("/api/workout/machines/cardio/add", update_cardio);
+// Update the user's profile
+app.use("/api/users/update", update_user);
+// Add a sets to a strength machine.
+app.use("/api/workout/machines/sets/add", update_set);
+// Get user endpoint.
+app.use("/api/users/get", get_user);
+// Get all the machines in the dixon collection
+app.use("/api/machines/get", get_machines);
+// Get the user's workout and saved workouts.
+app.use("/api/workouts/get", get_workouts);
+// End the user's workout.
+app.use("/api/workout/end", end_workout);
+// Rate the user's workout.
+app.use("/api/workout/rate", rate_workout);
+app.get("/api", (req, res) => {
+ res.send({ username: os.userInfo().username });
+});
+app.listen(PORT, () => {
+ console.log(`⚡️ [server]: Server is running at http://localhost:${PORT}`);
+});
+const uri = process.env.URI;
+mongoose
+ .connect(uri)
+ .then(() => console.log("⚡️ [server]: MongoDB connection established..."))
+ .catch((error) => console.error("⚡️ [server]: MongoDB connection failed:", error.message));

backend/dist/middleware/tracker.js

@@ -0,0 +1,22 @@
+import { Router } from "express";
+const router = Router();
+const connectionTracker = {};
+router.all("*", function (req, res, next) {
+ const counter = connectionTracker[req.originalUrl];
+ if (counter || counter === 0) {
+ connectionTracker[req.originalUrl] = counter + 1;
+ }
+ else {
+ connectionTracker[req.originalUrl] = 1;
+ }
+ console.log("========REQUEST RECEIVED========");
+ console.log(`REQUEST ROUTE: ${JSON.stringify(req.originalUrl, null, " ")}`);
+ console.log(`REQUEST METHOD: ${JSON.stringify(req.method, null, " ")}`);
+ console.log(`REQUEST BODY: ${JSON.stringify(req.body, null, " ")}`);
+ console.log(`REQUEST QUERY: ${JSON.stringify(req.query, null, " ")}`);
+ console.log(`STATUS CODE: ${JSON.stringify(res.statusCode, null, " ")}`);
+ console.log(`REQUEST HEADERS: ${JSON.stringify(req.headers, null, " ")}`);
+ console.log(`SESSION VISITS: ${JSON.stringify(connectionTracker, null, " ")}`);
+ next();
+});
+export default router;

backend/dist/models/dixon.js

@@ -0,0 +1,34 @@
+import mongoose from "mongoose";
+const dixonSchema = new mongoose.Schema({
+ machine_name: {
+ type: String,
+ required: true,
+ unique: true
+ },
+ machine_id: {
+ // uuid
+ type: String,
+ required: true,
+ unique: true
+ },
+ machine_image: {
+ // cloudinary
+ type: String,
+ required: true,
+ unique: true
+ },
+ machine_type: {
+ type: String,
+ enum: ["Cardio", "Strength", "Other", "None"],
+ default: "None",
+ required: true
+ },
+ machine_status: {
+ // 1,true = available, 0,false = in use
+ type: Boolean,
+ required: true,
+ default: true
+ }
+});
+const Dixon = mongoose.model("Dixon", dixonSchema);
+export default Dixon;

backend/dist/models/user.js

@@ -0,0 +1,108 @@
+import mongoose from "mongoose";
+import dotenv from "dotenv";
+import { Workout } from "./workout.js";
+dotenv.config();
+var EBloodType;
+(function (EBloodType) {
+ EBloodType["A"] = "A";
+ EBloodType["B"] = "B";
+ EBloodType["AB"] = "AB";
+ EBloodType["O"] = "O";
+ EBloodType["None"] = "";
+})(EBloodType || (EBloodType = {}));
+const userSchema = new mongoose.Schema({
+ username: {
+ type: String,
+ required: true,
+ minlength: 3,
+ maxlength: 200,
+ unique: false
+ },
+ pin: {
+ type: String,
+ required: true,
+ minlength: 4,
+ maxlength: 99999,
+ unique: false
+ },
+ initLogin: {
+ type: Boolean,
+ default: true
+ },
+ weight: {
+ type: Number,
+ default: 0,
+ validate: {
+ validator: Number.isInteger,
+ message: "{VALUE} is not an integer value"
+ },
+ required: [true, "Weight is required"],
+ unique: false
+ },
+ height: {
+ type: Number,
+ default: 0,
+ validate: {
+ validator: Number.isInteger,
+ message: "{VALUE} is not an integer value"
+ },
+ required: [true, "Height is required"],
+ unique: false
+ },
+ BMI: {
+ type: Number,
+ default: 0,
+ required: [true, "BMI is required"],
+ unique: false
+ },
+ bloodType: {
+ type: String,
+ enum: ["O+", "O-", "A+", "A-", "B+", "B-", "AB+", "AB-", ""],
+ required: false,
+ unique: false,
+ uppercase: true
+ },
+ // May be used for future features
+ // loginDateTime: {
+ // type: Date,
+ // required: false,
+ // minlength: 3,
+ // maxlength: 200,
+ // unique: false
+ // },
+ // logoutDateTime: {
+ // type: Date,
+ // required: false,
+ // minlength: 3,
+ // maxlength: 200,
+ // unique: false
+ // },
+ savedWorkouts: [Workout.schema],
+ workouts: [Workout.schema],
+ firstName: {
+ type: String,
+ required: false
+ },
+ lastName: {
+ type: String,
+ required: false
+ },
+ age: {
+ type: Number,
+ default: 0,
+ min: 0,
+ max: 150,
+ validate: {
+ validator: Number.isInteger,
+ message: "{VALUE} is not an integer value"
+ },
+ required: false,
+ unique: false
+ },
+ timestamps: {
+ type: Boolean,
+ default: true
+ }
+});
+const User = mongoose.model("User", userSchema);
+export default User;

backend/dist/models/workout.js

@@ -0,0 +1,131 @@
+import mongoose from "mongoose";
+import dotenv from "dotenv";
+dotenv.config();
+var EWorkoutType;
+(function (EWorkoutType) {
+ EWorkoutType["Cardio"] = "Cardio";
+ EWorkoutType["Strength"] = "Strength";
+ EWorkoutType["Other"] = "Other";
+ EWorkoutType["None"] = "None";
+})(EWorkoutType || (EWorkoutType = {}));
+var EWorkoutIntensity;
+(function (EWorkoutIntensity) {
+ EWorkoutIntensity["Low"] = "Low";
+ EWorkoutIntensity["Medium"] = "Medium";
+ EWorkoutIntensity["High"] = "High";
+ EWorkoutIntensity["None"] = "None";
+})(EWorkoutIntensity || (EWorkoutIntensity = {}));
+const exerciseSchema = new mongoose.Schema({
+ exercise_name: {
+ type: String,
+ required: true,
+ }
+});
+const machineSchema = new mongoose.Schema({
+ username: {
+ type: String,
+ required: true,
+ unqiue: true
+ },
+ machine_name: {
+ type: String,
+ required: true
+ },
+ machine_type: {
+ type: String,
+ enum: ["Cardio", "Strength", "Other", "None"],
+ default: "None",
+ required: true
+ },
+ machine_status: {
+ // 1,true = available, 0,false = in use
+ type: Boolean,
+ required: true
+ },
+ distance: {
+ // in miles
+ type: Number,
+ required: false
+ },
+ timeSpent: {
+ // in minutes
+ type: Number,
+ required: false
+ },
+ sets: [
+ {
+ reps: {
+ type: Number,
+ required: false,
+ default: 0
+ },
+ weight: {
+ type: Number,
+ required: false,
+ default: 0
+ }
+ }
+ ],
+ machine_id: {
+ type: String,
+ required: true,
+ unique: true
+ }
+});
+const workoutSchema = new mongoose.Schema({
+ username: {
+ type: String,
+ required: true,
+ unqiue: false
+ },
+ workOutType: {
+ enum: [EWorkoutType.Cardio, EWorkoutType.Strength, EWorkoutType.Other, EWorkoutType.None],
+ type: String,
+ required: false,
+ unique: false,
+ default: EWorkoutType.None
+ },
+ workOutIntensity: {
+ enum: [EWorkoutIntensity.Low, EWorkoutIntensity.Medium, EWorkoutIntensity.High, EWorkoutIntensity.None],
+ type: String,
+ required: false,
+ unique: false,
+ default: EWorkoutIntensity.None
+ },
+ machines: [machineSchema],
+ workoutStartTimestamp: {
+ type: Date,
+ required: false,
+ unique: false
+ },
+ workoutEndTimestamp: {
+ type: Date,
+ required: false,
+ unique: false
+ },
+ effortLevel: {
+ type: Number,
+ required: false,
+ min: 0,
+ max: 10,
+ unique: false
+ },
+ tirednessLevel: {
+ type: Number,
+ required: false,
+ min: 0,
+ max: 10,
+ unique: false
+ },
+ workoutDuration: {
+ // in minutes
+ type: Number,
+ required: false,
+ unique: false
+ },
+ workoutExercises: [exerciseSchema]
+});
+const Workout = mongoose.model("Workout", workoutSchema);
+const Machine = mongoose.model("Machine", machineSchema);
+const Exercise = mongoose.model("Exercise", exerciseSchema);
+export { Workout, Machine, Exercise, EWorkoutType, EWorkoutIntensity };