Backend documentation

backend/routes/band.routes.ts

@@ -166,8 +166,6 @@ band.get("/band/:name", (req: Request, res: Response) => {
  */
 band.get("/search", async (req: Request, res: Response) => {
   // Workaround, because SQLite can't handle stacked queries
-  console.log(1)
-  console.log(req.query.value)
   let prompts = decodeURI(String(req.query.value)).split(";")
 
   // On stacked prompts, execute last prompt

backend/routes/concert.routes.ts

@@ -17,18 +17,68 @@ import { Op } from "sequelize";
 
 export const concert = Router()
 
+const concertStructure = [
+  {
+    model: Band
+  },
+  {
+    model: Location,
+    include: [
+      {
+        model: City
+      },
+      {
+        model: SeatGroup,
+        include: [
+          {
+            model: SeatRow,
+            include: [
+              {
+                model: Seat,
+                include: [
+                  {
+                    model: Ticket
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    attributes: {
+      exclude: [ "cityId" ]
+    }
+  }
+]
 
+
+/**
+ * @swagger
+ * /concerts:
+ *   get:
+ *     summary: Get all available concerts
+ *     tags: [Concerts]
+ *     parameters:
+ *        - in: query
+ *          name: count
+ *          schema:
+ *            type: number
+ *          required: false
+ *          description: Limit number of results
+ *     responses:
+ *       200:
+ *         description: OK
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/concert'
+ */
 concert.get("/", (req: Request, res: Response) => {
   let count = req.query.count
 
   Concert.findAll({
-    include: [
-      {
-        model: Location,
-        include: [ City ]
-      },
-      Band
-    ],
+    include: concertStructure,
     order: [
       [ 'date', 'ASC' ]
     ]
@@ -47,47 +97,31 @@ concert.get("/", (req: Request, res: Response) => {
 })
 
 
-// Get all available data about a band by it's ID
+/**
+ * @swagger
+ * /concerts/concert/{id}:
+ *   get:
+ *     summary: Download all available informations about a specific concert
+ *     tags: [Concerts]
+ *     parameters:
+ *        - in: path
+ *          name: id
+ *          schema:
+ *            type: number
+ *          required: true
+ *          description: ID of concert in database
+ *     responses:
+ *       200:
+ *         description: Single concert object
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/concert'
+ *       404:
+ *         description: Not found
+ */
 concert.get("/concert/:id", (req: Request, res: Response) => {
-  Concert.findByPk(req.params.id, {
-    include: [
-      {
-        model: Band,
-      },
-      {
-        model: Location,
-        include: [
-          {
-            model: City
-          },
-          {
-            model: SeatGroup,
-            include: [
-              {
-                model: SeatRow,
-                include: [
-                  {
-                    model: Seat,
-                    include: [
-                      {
-                        model: Ticket
-                      }
-                    ]
-                  }
-                ]
-              }
-            ]
-          }
-        ],
-        attributes: {
-          exclude: [ "cityId" ]
-        }
-      }
-    ],
-    attributes: {
-      exclude: [ "locationId", "tourId" ]
-    }
-  })
+  Concert.findByPk(req.params.id, { include: concertStructure })
     .then(concert => {
       concert.dataValues["capacity"] = 0
 
@@ -125,7 +159,29 @@ concert.get("/concert/:id", (req: Request, res: Response) => {
 })
 
 
-// Concert search
+/**
+ * @swagger
+ * /concerts/search:
+ *   get:
+ *     summary: Search for concerts
+ *     tags: [Concerts]
+ *     parameters:
+ *        - in: query
+ *          name: value
+ *          schema:
+ *            type: string
+ *          required: true
+ *          description: Search term
+ *     responses:
+ *       200:
+ *         description: List of concert objects
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/concert'
+ *       500:
+ *         description: Internal server error
+ */
 concert.get("/search", (req: Request, res: Response) => {
   Concert.findAll({
     where: {

backend/routes/location.routes.ts

@@ -113,7 +113,7 @@ location.get("/", (req: Request, res: Response) => {
  *          description: Url name of the location to request for
  *     responses:
  *       200:
- *         description: List of band objects
+ *         description: Single of location objects
  *         content:
  *           application/json:
  *             schema:

backend/routes/order.routes.ts

@@ -129,8 +129,6 @@ order.get("/", verifyToken, (req: Request, res: Response) => {
 order.post("/", verifyToken, (req: Request, res: Response) => {
   req.body["accountId"] = req["id"]
 
-  console.log(req.body)
-
   Order.create(req.body)
     .then(async order => {
       for (let ticket of req.body.tickets) {
@@ -158,6 +156,30 @@ order.post("/", verifyToken, (req: Request, res: Response) => {
     })
 })
 
+
+/**
+ * @swagger
+ * /orders:
+ *   patch:
+ *     summary: Update an order
+ *     tags: [Orders]
+ *     parameters:
+ *        - in: body
+ *          name: order
+ *          schema:
+ *            type: object
+ *          required: true
+ *          description: Updated order object
+ *     responses:
+ *       200:
+ *         description: OK
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/order'
+ *       500:
+ *         description: Internal server error
+ */
 order.patch("/", (req: Request, res: Response) => {
   Order.update(req.body, {
     where: {