Score page

.github/workflows/main.yml

@@ -0,0 +1,36 @@
+# The name of the workflow
+name: Frontend Testing 
+
+# This workflow will run on any push to the repository
+on: push
+
+jobs:
+  test:
+    name: Frontend Tests
+    # Similar to docker, we set up a virtual machine to run our tests
+    runs-on: ubuntu-latest
+
+    steps:
+      # Each step has a name, some code, and some options
+      - name: Check out the code
+        uses: actions/checkout@v3 # This is a reference to some code to run
+
+      # This step installs the Node version
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 20.x
+
+      # Move to frontend directory and install dependencies
+      - name: Move to frontend and install dependencies
+        run: |
+          cd frontend
+          npm install
+
+      # Test React app
+      - name: Move to frontend and Test
+        run: |
+            cd frontend
+            npm run test
+
+

api/app.js

@@ -5,6 +5,7 @@ const cors = require("cors");
 const usersRouter = require("./routes/users");
 const postsRouter = require("./routes/posts");
 const authenticationRouter = require("./routes/authentication");
+const musicRouter = require("./routes/music")
 const tokenChecker = require("./middleware/tokenChecker");
 
 const app = express();
@@ -21,6 +22,7 @@ app.use(bodyParser.json());
 app.use("/users", usersRouter);
 app.use("/posts", tokenChecker, postsRouter);
 app.use("/tokens", authenticationRouter);
+app.use("/music", musicRouter)
 
 // 404 Handler
 app.use((_req, res) => {

api/controllers/music.js

@@ -0,0 +1,93 @@
+const getGenres = async (req, res) => {
+    const requestOptions = {
+        method: "GET"
+    }
+
+    const response = await fetch("https://api.deezer.com/genre", requestOptions);
+
+    if (response.status !== 200) {
+        throw new Error(`Unable to fetch genres. Status: ${response.status}. Headers: ${await response.text()}`);
+    }
+
+    const data = await response.json();
+    res.status(200).json(data.data)
+};
+
+const getArtistsForGenre = async (req, res) => {
+    const genreID = req.params.id;
+
+    const requestOptions = {
+        method: "GET"
+    }
+
+    const response = await fetch(`https://api.deezer.com/genre/${genreID}/artists`, requestOptions);
+
+    if (response.status !== 200) {
+        throw new Error("Unable to fetch artists. Status: ${response.status}. Headers: ${await response.text()}");
+    }
+
+    const data = await response.json();
+    res.status(200).json(data.data)
+};
+
+const getTopTracksForArtist = async (req, res) => {
+    const artistID = req.params.id;
+
+    const requestOptions = {
+        method: "GET"
+    }
+
+    const response = await fetch(`https://api.deezer.com/artist/${artistID}/top`, requestOptions);
+
+    if (response.status !== 200) {
+        throw new Error("Unable to fetch top tracks for artist");
+    }
+
+    const data = await response.json();
+    res.status(200).json(data.data)
+};
+
+const getTrack = async (req, res) => {
+    const trackID = req.params.id;
+
+    const requestOptions = {
+        method: "GET"
+    }
+
+    const response = await fetch(`https://api.deezer.com/track/${trackID}`, requestOptions);
+
+    if (response.status !== 200) {
+        throw new Error("Unable to fetch top tracks for artist");
+    }
+
+    const data = await response.json();
+    res.status(200).json(data)
+};
+
+
+const getAlbumsForArtist = async (req, res) => {
+    const artistID = req.params.id;
+
+    const requestOptions = {
+        method: "GET"
+    }
+
+    const response = await fetch(`https://api.deezer.com/artist/${artistID}/albums`, requestOptions);
+
+    if (response.status !== 200) {
+        throw new Error("Unable to fetch albums for artist");
+    }
+
+    const data = await response.json();
+    res.status(200).json(data.data)
+};
+
+const MusicController = {
+    getGenres: getGenres,
+    getArtistsForGenre: getArtistsForGenre,
+    getTopTracksForArtist: getTopTracksForArtist,
+    getTrack: getTrack,
+    getAlbumsForArtist: getAlbumsForArtist
+};
+
+module.exports = MusicController

api/db/db.js

@@ -1,20 +1,26 @@
 const mongoose = require("mongoose");
 
 const connectToDatabase = async () => {
-  const mongoDbUrl = process.env.MONGODB_URL;
 
-  if (!mongoDbUrl) {
-    console.error(
-      "No MongoDB url provided. Make sure there is a MONGODB_URL environment variable set. See the README for more details."
-    );
-    throw new Error("No connection string provided");
-  }
-
-  await mongoose.connect(mongoDbUrl);
+  const uri = `mongodb+srv://${process.env.DB_USER}:${process.env.DB_PASSWORD}@kwizical.xpmi3dw.mongodb.net/?retryWrites=true&w=majority&appName=kwizical`;
+  const clientOptions = {
+    serverApi: { version: "1", strict: true, deprecationErrors: true },
+  };
 
-  if (process.env.NODE_ENV !== "test") {
-    console.log("Successfully connected to MongoDB");
+  try {
+    // Create a Mongoose client with a MongoClientOptions object to set the Stable API version
+    await mongoose.connect(uri, clientOptions);
+    await mongoose.connection.db.admin().command({ ping: 1 });
+    console.log(
+      "Pinged your deployment. You successfully connected to MongoDB!"
+    );
+  } catch {
+    console.dir
+  } finally {
+    // Ensures that the client will close when you finish/error
+    await mongoose.disconnect();
   }
 };
 
 module.exports = { connectToDatabase };
+

api/index.js

@@ -5,7 +5,7 @@ const app = require("./app.js");
 const { connectToDatabase } = require("./db/db.js");
 
 const listenForRequests = () => {
-  const port = process.env.PORT || 3000;
+  const port = process.env.PORT || 10000;
   app.listen(port, () => {
     console.log("Now listening on port", port);
   });

api/models/post.js

@@ -12,7 +12,7 @@ const Post = mongoose.model("Post", PostSchema);
 
 // These lines will create a test post every time the server starts.
 // You can delete this once you are creating your own posts.
-const dateTimeString = new Date().toLocaleString("en-GB");
-new Post({ message: `Test message, created at ${dateTimeString}` }).save();
+// const dateTimeString = new Date().toLocaleString("en-GB");
+// new Post({ message: `Test message, created at ${dateTimeString}` }).save();
 
 module.exports = Post;

api/routes/music.js

@@ -0,0 +1,12 @@
+const express = require("express");
+const router = express.Router();
+
+const MusicController = require("../controllers/music");
+
+router.get("/genre", MusicController.getGenres);
+router.get("/genre/:id/artists", MusicController.getArtistsForGenre);
+router.get("/artist/:id/top", MusicController.getTopTracksForArtist);
+router.get("/track/:id", MusicController.getTrack);
+router.get("/artist/:id/albums", MusicController.getAlbumsForArtist);
+
+module.exports = router;

api/tests/controllers/music.test.js

@@ -0,0 +1,16 @@
+// const request = require("supertest");
+// const app = require("../../app");
+
+// TODO: Tests to be added. Need to research mocking fetch with Jest
+// test below actually calls Deezer API
+// - Aakash / Katrina
+
+describe("GET, genres", () => {
+    test("the response code is 200", async () => {
+
+    // const response = await request(app)
+    // .get("/music/genre")
+
+    // expect(response.status).toEqual(200);
+    expect(true)
+})});

frontend/helpers/album_generator.js

@@ -0,0 +1,22 @@
+import { shuffle } from "../helpers/shuffle.js";
+import { getAlbumsForArtist } from "../src/services/deezerService.js";
+
+export const randomAlbums = async (artistID) => {
+  try {
+
+    const data = await getAlbumsForArtist(artistID);
+    //create a list of dictionaries with artist ID and name
+    const albumList = data.map(album => ({
+      id: album.id,
+      title: album.title
+    }));
+
+    const shuffledAlbums = shuffle(albumList); // Shuffle the array of albums
+    const selectedAlbums = shuffledAlbums.slice(0, 4); // Select the first 4 albums
+    return selectedAlbums;
+
+  } catch (error) {
+    console.error("Error fetching artists:", error);
+    throw new Error("Unable to fetch random albums");
+  }
+};