fix conflicts and rework routes

api/lottery.js

@@ -1,21 +1,13 @@
-const express = require('express');
 const path = require('path');
 
-const router = express.Router();
 const mongoose = require('mongoose');
 mongoose.connect('mongodb://localhost:27017/vinlottis', {
   useNewUrlParser: true
 })
 
-const mustBeAuthenticated = require(path.join(
-  __dirname + '/../middleware/mustBeAuthenticated'
-));
-const config = require(path.join(__dirname + '/../config/defaults/lottery'));
-
 const Highscore = require(path.join(__dirname + '/../schemas/Highscore'));
 const Wine = require(path.join(__dirname + '/../schemas/Wine'));
 
-
 // Utils
 const epochToDateString = date => new Date(parseInt(date)).toDateString();
 
@@ -62,7 +54,7 @@ const resolveWineReferences = listWithWines => {
 }
 
 // Routes
-router.route('/all').get((req, res) => {
+const all = (req, res) => {
   return Highscore.find()
     .then(highscore => getHighscoreByDates(highscore))
     .then(groupedLotteries => groupedHighscoreToSortedList(groupedLotteries))
@@ -70,9 +62,19 @@ router.route('/all').get((req, res) => {
       message: "Lotteries by date!",
       lotteries
     }))
-})
+}
 
-router.route('/by-date/:date').get((req, res) => {
+const latest = (req, res) => {
+  return Highscore.find()
+    .then(highscore => getHighscoreByDates(highscore))
+    .then(groupedLotteries => groupedHighscoreToSortedList(groupedLotteries))
+    .then(lotteries => res.send({
+      message: "Latest lottery!",
+      lottery: lotteries.slice(-1).pop()
+    }))
+}
+
+const byEpochDate = (req, res) => {
   const { date } = req.params;
   const dateString = epochToDateString(date);
 
@@ -92,10 +94,10 @@ router.route('/by-date/:date').get((req, res) => {
         })
       }
     })
-})
+}
 
-router.route("/by-name").get((req, res) => {
+const byName = (req, res) => {
-  const { name } = req.query;
+  const { name } = req.params;
 
   return Highscore.find({ name })
     .then(async (highscore) => {
@@ -113,6 +115,11 @@ router.route("/by-name").get((req, res) => {
         })
       }
     })
-})
+}
 
-module.exports = router;
+module.exports = {
+  all,
+  latest,
+  byEpochDate,
+  byName
+};

api/message.js

@@ -1,92 +1,109 @@
-const request = require("request");
+const https = require("https");
 const path = require("path");
 const config = require(path.join(__dirname + "/../config/defaults/lottery"));
 
-async function sendMessage(winnerObject) {
+async function sendWineSelectMessage(winnerObject) {
   winnerObject.timestamp_sent = new Date().getTime();
   winnerObject.timestamp_limit = new Date().getTime() * 600000;
   await winnerObject.save();
 
   let url = new URL(`/#/winner/${winnerObject.id}`, "https://lottis.vin");
 
-  await sendMessageToUser(
+  return sendMessageToUser(
     winnerObject.phoneNumber,
     `Gratulerer som heldig vinner av vinlotteriet ${winnerObject.name}! Her er linken for å velge hva slags vin du vil ha, du har 10 minutter på å velge ut noe før du blir lagt bakerst i køen. ${url.href}. (Hvis den siden kommer opp som tom må du prøve å refreshe siden noen ganger.)`
-  );
+  )
-
-  return true;
 }
 
-async function sendWonWineMessage(winnerObject, wineObject) {
+async function sendLastWinnerMessage(winnerObject, wineObject) {
-  console.log(
+  console.log(`User ${winnerObject.id} is only one left, chosing wine for him/her.`);
-    `User ${winnerObject.id} is only one left, chosing wine for him/her.`
-  );
   winnerObject.timestamp_sent = new Date().getTime();
   winnerObject.timestamp_limit = new Date().getTime();
   await winnerObject.save();
 
-  await sendMessageToUser(
+  return sendMessageToUser(
     winnerObject.phoneNumber,
     `Gratulerer som heldig vinner av vinlotteriet ${winnerObject.name}! Du har vunnet vinen ${wineObject.name}, og vil få nærmere info om hvordan/hvor du kan hente vinen snarest. Ha en ellers fin helg!`
   );
-
-  return true;
 }
 
-async function sendMessageTooLate(winnerObject) {
+async function sendWineSelectMessageTooLate(winnerObject) {
-  await sendMessageToUser(
+  return sendMessageToUser(
     winnerObject.phoneNumber,
     `Hei ${winnerObject.name}, du har dessverre brukt mer enn 10 minutter på å velge premie og blir derfor puttet bakerst i køen. Du vil få en ny SMS når det er din tur igjen.`
   );
 }
 
 async function sendMessageToUser(phoneNumber, message) {
-  try {
+  console.log(`Attempting to send message to ${ phoneNumber }.`)
-  request.post(
+
-    {
+  const body = {
-      url: `https://gatewayapi.com/rest/mtsms?token=${config.gatewayToken}`,
+    sender: "Vinlottis",
-      json: true,
+    message: message,
-      body: {
+    recipients: [{ msisdn: `47${ phoneNumber }`}]
-        sender: "Vinlottis",
+  };
-        message: message,
+
-        recipients: [{ msisdn: `47${phoneNumber}` }]
+  return gatewayRequest(body);
-      }
-    },
-    function(err, r, body) {
-      console.log(err ? err : body);
-      if(err) {
-        console.log(phoneNumber, message);
-      }
-    }
-  );
-  } catch(e) {
-    console.log(phoneNumber, message);
-  }
 }
 
-async function sendUpdate(winners) {
+
+async function sendInitialMessageToWinners(winners) {
   let numbers = [];
   for (let i = 0; i < winners.length; i++) {
     numbers.push({ msisdn: `47${winners[i].phoneNumber}` });
   }
-  request.post(
+
-    {
+  const body = {
-      url: `https://gatewayapi.com/rest/mtsms?token=${config.gatewayToken}`,
+    sender: "Vinlottis",
-      json: true,
+    message:
-      body: {
+      "Gratulerer som vinner av vinlottisen! Du vil snart få en SMS med oppdatering om hvordan gangen går!",
-        sender: "Vinlottis",
+    recipients: numbers
-        message:
+  }
-          "Gratulerer som vinner av vinlottisen! Du vil snart få en SMS med oppdatering om hvordan gangen går!",
+
-        recipients: numbers
+  return gatewayRequest(body);
-      }
-    },
-    function(err, r, body) {
-      console.log(err ? err : body);
-    }
-  );
 }
 
-module.exports.sendUpdate = sendUpdate;
+async function gatewayRequest(body) {
-module.exports.sendMessage = sendMessage;
+  return new Promise((resolve, reject) => {
-module.exports.sendMessageTooLate = sendMessageTooLate;
+    const options = {
-module.exports.sendWonWineMessage = sendWonWineMessage;
+      hostname: "gatewayapi.com",
+      post: 443,
+      path: `/rest/mtsms?token=${ config.gatewayToken }`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    }
+
+    const req = https.request(options, (res) => {
+      console.log(`statusCode: ${ res.statusCode }`);
+      console.log(`statusMessage: ${ res.statusMessage }`);
+
+      res.setEncoding('utf8');
+
+      if (res.statusCode == 200) {
+        res.on("data", (d) => resolve(JSON.parse(d)));
+      } else {
+        res.on("data", (data) => {
+          data = JSON.parse(data);
+          return reject('Gateway error: ' + data['message'] || data)
+        });
+      }
+    })
+
+    req.on("error", (error) => {
+      console.error(`Error from sms service: ${ error }`);
+      reject(`Error from sms service: ${ error }`);
+    })
+
+    req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+module.exports = {
+  sendWineSelectMessage,
+  sendLastWinnerMessage,
+  sendWineSelectMessageTooLate,
+  sendInitialMessageToWinners
+}

api/request.js

@@ -1,43 +1,41 @@
 const express = require("express");
 const path = require("path");
-const router = express.Router();
-const fetch = require('node-fetch');
-const { send } = require("process");
 const RequestedWine = require(path.join(
   __dirname + "/../schemas/RequestedWine"
 ));
 const Wine = require(path.join(
   __dirname + "/../schemas/Wine"
 ));
-const mustBeAuthenticated = require(path.join(
-  __dirname + "/../middleware/mustBeAuthenticated"
-));
 
-router.use((req, res, next) => {
+const deleteRequestedWineById = async (req, res) => {
-  next();
+  const { id } = req.params;
-});
+  if(id == null){
+    return res.json({
+      message: "Id er ikke definert",
+      success: false
+    })
+  }
 
-router.route("/request/").delete(mustBeAuthenticated, async (req, res) => {
+  await RequestedWine.deleteOne({wineId: id})
-  await RequestedWine.deleteOne({wineId: req.body.id})
+  return res.json({
-  res.json(true);
+    message: `Slettet vin med id: ${id}`,
-})
+    success: true
+  }); 
+}
 
-router.route("/request").get(async (req, res) => {
+const getAllRequestedWines = async (req, res) => {
-  const rWines = await RequestedWine.find({}).populate("wine")
-  return res.send(rWines)
-})
-
-router.route("/request/all").get(async (req, res) => {
   const allWines = await RequestedWine.find({}).populate("wine");
+  
+  return res.json(allWines);
+}
 
-  res.json(allWines);
+const requestNewWine = async (req, res) => {
-});
-
-router.route("/request").post(async (req, res) => {
   const {wine} = req.body
 
+  console.log(req.body)
+  
   let thisWineIsLOKO = await Wine.findOne({id: wine.id})
-
+  
   if(thisWineIsLOKO == undefined){
     thisWineIsLOKO = new Wine({
       name: wine.name,
@@ -49,7 +47,7 @@ router.route("/request").post(async (req, res) => {
     });
     await thisWineIsLOKO.save()
   }
-
+  
   let requestedWine = await RequestedWine.findOne({ "wineId": wine.id})
   
   if(requestedWine == undefined){
@@ -62,9 +60,12 @@ router.route("/request").post(async (req, res) => {
     requestedWine.count += 1;
   }
   await requestedWine.save()
+  
+  return res.send(requestedWine);
+}
 
-  res.send(requestedWine);
+module.exports = {
-
+  requestNewWine,
-});
+  getAllRequestedWines,
-
+  deleteRequestedWineById
-module.exports = router;
+};

api/retrieve.js

@@ -1,6 +1,6 @@
 const express = require("express");
 const path = require("path");
-const router = express.Router();
+// const router = express.Router();
 const mongoose = require("mongoose");
 mongoose.connect("mongodb://localhost:27017/vinlottis", {
   useNewUrlParser: true
@@ -13,23 +13,19 @@ const PreLotteryWine = require(path.join(
   __dirname + "/../schemas/PreLotteryWine"
 ));
 
-router.use((req, res, next) => {
+const prelotteryWines = async (req, res) => {
-  next();
-});
-
-router.route("/wines/prelottery").get(async (req, res) => {
   let wines = await PreLotteryWine.find();
-  res.json(wines);
+  return res.json(wines);
-});
+};
 
-router.route("/purchase/statistics").get(async (req, res) => {
+const allPurchase = async (req, res) => {
   let purchases = await Purchase.find()
     .populate("wines")
     .sort({ date: 1 });
-  res.json(purchases);
+  return res.json(purchases);
-});
+};
 
-router.route("/purchase/statistics/color").get(async (req, res) => {
+const purchaseByColor = async (req, res) => {
   const countColor = await Purchase.find();
   let red = 0;
   let blue = 0;
@@ -75,7 +71,7 @@ router.route("/purchase/statistics/color").get(async (req, res) => {
 
   const total = red + yellow + blue + green;
 
-  res.json({
+  return res.json({
     red: {
       total: red,
       win: redWin
@@ -95,22 +91,21 @@ router.route("/purchase/statistics/color").get(async (req, res) => {
     stolen: stolen,
     total: total
   });
-});
+};
 
-router.route("/highscore/statistics").get(async (req, res) => {
+const highscore = async (req, res) => {
   const highscore = await Highscore.find().populate("wins.wine");
 
-  res.json(highscore);
+  return res.json(highscore);
-});
+};
 
-
+const allWines = async (req, res) => {
-router.route("/wines/statistics").get(async (req, res) => {
   const wines = await Wine.find();
 
-  res.json(wines);
+  return res.json(wines);
-});
+};
 
-router.route("/wines/statistics/overall").get(async (req, res) => {
+const allWinesSummary = async (req, res) => {
   const highscore = await Highscore.find().populate("wins.wine");
   let wines = {};
 
@@ -150,7 +145,14 @@ router.route("/wines/statistics/overall").get(async (req, res) => {
     }
   }
 
-  res.json(Object.values(wines));
+  return res.json(Object.values(wines));
-});
+};
 
-module.exports = router;
+module.exports = {
+  prelotteryWines,
+  allPurchase,
+  purchaseByColor,
+  highscore,
+  allWines,
+  allWinesSummary
+};

api/router.js

@@ -0,0 +1,69 @@
+const express = require("express");
+const path = require("path");
+
+// Middleware
+const mustBeAuthenticated = require(__dirname + "/../middleware/mustBeAuthenticated");
+
+const update = require(path.join(__dirname + "/update"));
+const retrieve = require(path.join(__dirname + "/retrieve"));
+const request = require(path.join(__dirname + "/request"));
+const subscriptionApi = require(path.join(__dirname + "/subscriptions"));
+const loginApi = require(path.join(__dirname + "/login"));
+const wineinfo = require(path.join(__dirname + "/wineinfo"));
+const virtualApi = require(path.join(__dirname + "/virtualLottery"));
+const virtualRegistrationApi = require(path.join(
+  __dirname + "/virtualRegistration"
+));
+const lottery = require(path.join(__dirname + "/lottery"));
+
+
+const router = express.Router();
+
+router.get("/wineinfo/search", wineinfo.wineSearch);
+
+router.get("/request/all", request.getAllRequestedWines);
+router.post("/request/new-wine", request.requestNewWine);
+router.delete("/request/:id", request.deleteRequestedWineById);
+
+router.get("/wineinfo/schema", mustBeAuthenticated, update.schema);
+router.get("/wineinfo/:ean", wineinfo.byEAN);
+
+router.post("/log/wines", mustBeAuthenticated, update.submitWines);
+router.post("/lottery", update.submitLottery);
+router.post("/lottery/wines", update.submitWinesToLottery);
+// router.delete("/lottery/wine/:id", update.deleteWineFromLottery);
+router.post("/lottery/winners", update.submitWinnersToLottery);
+
+router.get("/wines/prelottery", retrieve.prelotteryWines);
+router.get("/purchase/statistics", retrieve.allPurchase);
+router.get("/purchase/statistics/color", retrieve.purchaseByColor);
+router.get("/highscore/statistics", retrieve.highscore)
+router.get("/wines/statistics", retrieve.allWines);
+router.get("/wines/statistics/overall", retrieve.allWinesSummary);
+
+router.get("/lottery/all", lottery.all);
+router.get("/lottery/latest", lottery.latest);
+router.get("/lottery/by-date/:date", lottery.byEpochDate);
+router.get("/lottery/by-name/:name", lottery.byName);
+
+router.delete('/virtual/winner/all', mustBeAuthenticated, virtualApi.deleteWinners);
+router.delete('/virtual/attendee/all', mustBeAuthenticated, virtualApi.deleteAttendees);
+router.get('/virtual/winner/draw', virtualApi.drawWinner);
+router.get('/virtual/winner/all', virtualApi.winners);
+router.get('/virtual/winner/all/secure', mustBeAuthenticated, virtualApi.winnersSecure);
+router.post('/virtual/finish', mustBeAuthenticated, virtualApi.finish);
+router.get('/virtual/attendee/all', virtualApi.attendees);
+router.get('/virtual/attendee/all/secure', mustBeAuthenticated, virtualApi.attendeesSecure);
+router.post('/virtual/attendee/add', mustBeAuthenticated, virtualApi.addAttendee);
+
+router.post('/winner/notify/:id', virtualRegistrationApi.sendNotificationToWinnerById);
+router.get('/winner/:id', virtualRegistrationApi.getWinesToWinnerById);
+router.post('/winner/:id', virtualRegistrationApi.registerWinnerSelection);
+
+// router.use("/api/", updateApi);
+// router.use("/api/", retrieveApi);
+// router.use("/api/", wineinfoApi);
+// router.use("/api/lottery", lottery);
+// router.use("/virtual-registration/", virtualRegistrationApi);
+
+module.exports = router;

api/update.js

@@ -1,29 +1,21 @@
 const express = require("express");
 const path = require("path");
-const router = express.Router();
 const mongoose = require("mongoose");
 mongoose.connect("mongodb://localhost:27017/vinlottis", {
   useNewUrlParser: true
 });
 
 const sub = require(path.join(__dirname + "/../api/subscriptions"));
-const mustBeAuthenticated = require(path.join(
-  __dirname + "/../middleware/mustBeAuthenticated"
-));
 
 const _wineFunctions = require(path.join(__dirname + "/../api/wine"));
 const _personFunctions = require(path.join(__dirname + "/../api/person"));
 const Subscription = require(path.join(__dirname + "/../schemas/Subscription"));
-const Purchase = require(path.join(__dirname + "/../schemas/Purchase"));
+const Lottery = require(path.join(__dirname + "/../schemas/Purchase"));
 const PreLotteryWine = require(path.join(
   __dirname + "/../schemas/PreLotteryWine"
 ));
 
-router.use((req, res, next) => {
+const submitWines = async (req, res) => {
-  next();
-});
-
-router.route("/log/wines").post(mustBeAuthenticated, async (req, res) => {
   const wines = req.body;
   for (let i = 0; i < wines.length; i++) {
     let wine = wines[i];
@@ -40,69 +32,115 @@ router.route("/log/wines").post(mustBeAuthenticated, async (req, res) => {
   }
 
   let subs = await Subscription.find();
+  console.log("Sending new wines w/ push notification to all subscribers.")
   for (let i = 0; i < subs.length; i++) {
     let subscription = subs[i]; //get subscription from your databse here.
+
     const message = JSON.stringify({
       message: "Dagens vin er lagt til, se den på lottis.vin/dagens!",
       title: "Ny vin!",
       link: "/#/dagens"
     });
-    sub.sendNotification(subscription, message);
+
+    try {
+      sub.sendNotification(subscription, message);
+    } catch (error) {
+      console.error("Error when trying to send push notification to subscriber.");
+      console.error(error);
+    }
   }
 
-  res.send(true);
+  return res.send({
-});
+    message: "Submitted and notified push subscribers of new wines!",
+    success: true
+  });
+};
 
-router.route("/log/schema").get(mustBeAuthenticated, async (req, res) => {
+const schema = async (req, res) => {
   let schema = { ...PreLotteryWine.schema.obj };
   let nulledSchema = Object.keys(schema).reduce((accumulator, current) => {
     accumulator[current] = "";
-    return accumulator;
+    return accumulator
   }, {});
 
-  res.send(nulledSchema);
+  return res.send(nulledSchema);
-});
+}
 
-router.route("/log").post(mustBeAuthenticated, async (req, res) => {
+// TODO IMPLEMENT WITH FRONTEND (unused)
-  await PreLotteryWine.deleteMany();
+const submitWinesToLottery = async (req, res) => {
+  const { lottery } = req.body;
+  const { date, wines } = lottery;
+  const wineObjects = await Promise.all(wines.map(async (wine) => await _wineFunctions.findSaveWine(wine)))
 
-  const purchaseBody = req.body.purchase;
+  return Lottery.findOneAndUpdate({ date: date }, {
-  const winnersBody = req.body.winners;
+      date: date,
+      wines: wineObjects
+    }, {
+      upsert: true
+    }).then(_ => res.send(true))
+      .catch(err => res.status(500).send({ message: 'Unexpected error while updating/saving wine to lottery.',
+                                           success: false,
+                                           exception: err.message }));
+}
 
-  const date = purchaseBody.date;
+ /**
-  const blue = purchaseBody.blue;
+  * @apiParam (Request body) {Array} winners List of winners
-  const red = purchaseBody.red;
+  */
-  const yellow = purchaseBody.yellow;
+const submitWinnersToLottery = async (req, res) => {
-  const green = purchaseBody.green;
+  const { lottery } = req.body;
+  const { winners, date } = lottery;
 
-  const bought = purchaseBody.bought;
+  for (let i = 0; i < winners.length; i++) {
-  const stolen = purchaseBody.stolen;
+    let currentWinner = winners[i];
-
+    let wonWine = await _wineFunctions.findSaveWine(currentWinner.wine); // TODO rename to findAndSaveWineToLottery
-  const winesThisDate = [];
+    await _personFunctions.findSavePerson(currentWinner, wonWine, date); // TODO rename to findAndSaveWineToPerson
-
-  for (let i = 0; i < winnersBody.length; i++) {
-    let currentWinner = winnersBody[i];
-
-    let wonWine = await _wineFunctions.findSaveWine(currentWinner);
-    winesThisDate.push(wonWine);
-
-    await _personFunctions.findSavePerson(currentWinner, wonWine, date);
   }
 
-  let purchase = new Purchase({
+  return res.json(true);
-    date: date,
+}
-    blue: blue,
-    yellow: yellow,
-    red: red,
-    green: green,
-    wines: winesThisDate,
-    bought: bought,
-    stolen: stolen
-  });
 
-  await purchase.save();
+ /**
+  * @apiParam (Request body) {Date} date Date of lottery
+  * @apiParam (Request body) {Number} blue Number of blue tickets
+  * @apiParam (Request body) {Number} red Number of red tickets
+  * @apiParam (Request body) {Number} green Number of green tickets
+  * @apiParam (Request body) {Number} yellow Number of yellow tickets
+  * @apiParam (Request body) {Number} bought Number of tickets bought
+  * @apiParam (Request body) {Number} stolen Number of tickets stolen
+  */
+const submitLottery = async (req, res) => {
+  const { lottery } = req.body
 
-  res.send(true);
+  const { date,
-});
+          blue,
+          red,
+          yellow,
+          green,
+          bought,
+          stolen } = lottery;
 
-module.exports = router;
+  return Lottery.findOneAndUpdate({ date: date }, {
+      date: date,
+      blue: blue,
+      yellow: yellow,
+      red: red,
+      green: green,
+      bought: bought,
+      stolen: stolen
+    }, {
+      upsert: true
+    }).then(_ => res.send(true))
+      .catch(err => res.status(500).send({ message: 'Unexpected error while updating/saving lottery.',
+                                           success: false,
+                                           exception: err.message }));
+
+  return res.send(true);
+};
+
+module.exports = {
+  submitWines,
+  schema,
+  submitLottery,
+  submitWinnersToLottery,
+  submitWinesToLottery
+};

api/virtualLottery.js

@@ -1,44 +1,16 @@
-const express = require("express");
 const path = require("path");
-const router = express.Router();
 const crypto = require("crypto");
-const mongoose = require("mongoose");
+
-mongoose.connect("mongodb://localhost:27017/vinlottis", {
-  useNewUrlParser: true
-});
-let io;
-const mustBeAuthenticated = require(path.join(
-  __dirname + "/../middleware/mustBeAuthenticated"
-));
 const config = require(path.join(__dirname + "/../config/defaults/lottery"));
+const Message = require(path.join(__dirname + "/message"));
+const { findAndNotifyNextWinner } = require(path.join(__dirname + "/virtualRegistration"));
 
 const Attendee = require(path.join(__dirname + "/../schemas/Attendee"));
-const VirtualWinner = require(path.join(
+const VirtualWinner = require(path.join(__dirname + "/../schemas/VirtualWinner"));
-  __dirname + "/../schemas/VirtualWinner"
+const PreLotteryWine = require(path.join(__dirname + "/../schemas/PreLotteryWine"));
-));
-const PreLotteryWine = require(path.join(
-  __dirname + "/../schemas/PreLotteryWine"
-));
 
-const Message = require(path.join(__dirname + "/../api/message"));
 
-router.use((req, res, next) => {
+const winners = async (req, res) => {
-  next();
-});
-
-router.route("/winners").delete(mustBeAuthenticated, async (req, res) => {
-  await VirtualWinner.deleteMany();
-  io.emit("refresh_data", {});
-  res.json(true);
-});
-
-router.route("/attendees").delete(mustBeAuthenticated, async (req, res) => {
-  await Attendee.deleteMany();
-  io.emit("refresh_data", {});
-  res.json(true);
-});
-
-router.route("/winners").get(async (req, res) => {
   let winners = await VirtualWinner.find();
   let winnersRedacted = [];
   let winner;
@@ -50,19 +22,82 @@ router.route("/winners").get(async (req, res) => {
     });
   }
   res.json(winnersRedacted);
-});
+};
 
-router.route("/winners/secure").get(mustBeAuthenticated, async (req, res) => {
+const winnersSecure = async (req, res) => {
   let winners = await VirtualWinner.find();
 
-  res.json(winners);
+  return res.json(winners);
-});
+};
 
-router.route("/winner").get(mustBeAuthenticated, async (req, res) => {
+const deleteWinners = async (req, res) => {
+  await VirtualWinner.deleteMany();
+  var io = req.app.get('socketio');
+  io.emit("refresh_data", {});
+  return res.json(true);
+};
+
+const attendees = async (req, res) => {
+  let attendees = await Attendee.find();
+  let attendeesRedacted = [];
+  let attendee;
+  for (let i = 0; i < attendees.length; i++) {
+    attendee = attendees[i];
+    attendeesRedacted.push({
+      name: attendee.name,
+      ballots: attendee.red + attendee.blue + attendee.yellow + attendee.green,
+      red: attendee.red,
+      blue: attendee.blue,
+      green: attendee.green,
+      yellow: attendee.yellow
+    });
+  }
+  return res.json(attendeesRedacted);
+};
+
+const attendeesSecure = async (req, res) => {
+  let attendees = await Attendee.find();
+
+  return res.json(attendees);
+};
+
+const addAttendee = async (req, res) => {
+  const attendee = req.body;
+  const { red, blue, yellow, green } = attendee;
+
+  let newAttendee = new Attendee({
+    name: attendee.name,
+    red,
+    blue,
+    green,
+    yellow,
+    phoneNumber: attendee.phoneNumber,
+    winner: false
+  });
+  await newAttendee.save();
+
+
+  var io = req.app.get('socketio');
+  io.emit("new_attendee", {});
+
+  return res.send(true);
+};
+
+const deleteAttendees = async (req, res) => {
+  await Attendee.deleteMany();
+  var io = req.app.get('socketio');
+  io.emit("refresh_data", {});
+  return res.json(true);
+};
+
+const drawWinner = async (req, res) => {
   let allContestants = await Attendee.find({ winner: false });
+
   if (allContestants.length == 0) {
-    res.json(false);
+    return res.json({
-    return;
+      success: false,
+      message: "No attendees left that have not won."
+    });
   }
   let ballotColors = [];
   for (let i = 0; i < allContestants.length; i++) {
@@ -131,6 +166,7 @@ router.route("/winner").get(mustBeAuthenticated, async (req, res) => {
       Math.floor(Math.random() * attendeeListDemocratic.length)
     ];
 
+  var io = req.app.get('socketio');
   io.emit("winner", { color: colorToChooseFrom, name: winner.name });
 
   let newWinnerElement = new VirtualWinner({
@@ -151,8 +187,40 @@ router.route("/winner").get(mustBeAuthenticated, async (req, res) => {
   );
 
   await newWinnerElement.save();
-  res.json(winner);
+  return res.json(winner);
-});
+};
+
+const finish = async (req, res) => {
+  if (!config.gatewayToken) {
+    return res.json({
+      message: "Missing api token for sms gateway.",
+      success: false
+    });
+  }
+
+  let winners = await VirtualWinner.find({ timestamp_sent: undefined }).sort({
+    timestamp_drawn: 1
+  });
+
+  if (winners.length == 0) {
+    return res.json({
+      message: "No winners to draw from.",
+      success: false
+    });
+  }
+
+  Message.sendInitialMessageToWinners(winners.slice(1));
+
+  return findAndNotifyNextWinner()
+    .then(() => res.json({
+      success: true,
+      message: "Sent wine select message to first winner and update message to rest of winners."
+    }))
+    .catch(error => res.json({
+      message: error["message"] || "Unable to send message to first winner.",
+      success: false
+    }))
+};
 
 const genRandomString = function(length) {
   return crypto
@@ -168,87 +236,6 @@ const sha512 = function(password, salt) {
   return value;
 };
 
-router.route("/finish").get(mustBeAuthenticated, async (req, res) => {
-  if (!config.gatewayToken) {
-    res.json(false);
-    return;
-  }
-  let winners = await VirtualWinner.find({ timestamp_sent: undefined }).sort({
-    timestamp_drawn: 1
-  });
-
-  if (winners.length == 0) {
-    res.json(false);
-    return;
-  }
-
-  let firstWinner = winners[0];
-  messageSent = false;
-  try {
-    let messageSent = await Message.sendMessage(firstWinner);
-    Message.sendUpdate(winners.slice(1));
-    if (!messageSent) {
-      res.json(false);
-      return;
-    }
-  } catch (e) {
-    res.json(false);
-    return;
-  }
-
-  firstWinner.timestamp_sent = new Date().getTime();
-  firstWinner.timestamp_limit = new Date().getTime() + 600000;
-
-  await firstWinner.save();
-  startTimeout(firstWinner.id);
-  res.json(true);
-  return;
-});
-
-router.route("/attendees").get(async (req, res) => {
-  let attendees = await Attendee.find();
-  let attendeesRedacted = [];
-  let attendee;
-  for (let i = 0; i < attendees.length; i++) {
-    attendee = attendees[i];
-    attendeesRedacted.push({
-      name: attendee.name,
-      ballots: attendee.red + attendee.blue + attendee.yellow + attendee.green,
-      red: attendee.red,
-      blue: attendee.blue,
-      green: attendee.green,
-      yellow: attendee.yellow
-    });
-  }
-  res.json(attendeesRedacted);
-});
-
-router.route("/attendees/secure").get(mustBeAuthenticated, async (req, res) => {
-  let attendees = await Attendee.find();
-
-  res.json(attendees);
-});
-
-router.route("/attendee").post(mustBeAuthenticated, async (req, res) => {
-  const attendee = req.body;
-  const { red, blue, yellow, green } = attendee;
-
-  let newAttendee = new Attendee({
-    name: attendee.name,
-    red,
-    blue,
-    green,
-    yellow,
-    phoneNumber: attendee.phoneNumber,
-    winner: false
-  });
-  await newAttendee.save();
-
-  io.emit("new_attendee", {});
-
-  res.send(true);
-});
-
 function shuffle(array) {
   let currentIndex = array.length,
     temporaryValue,
@@ -269,43 +256,15 @@ function shuffle(array) {
   return array;
 }
 
-
+module.exports = {
-function startTimeout(id) {
+  deleteWinners,
-  console.log(`Starting timeout for user ${id}.`);
+  deleteAttendees,
-  setTimeout(async () => {
+  winners,
-    let virtualWinner = await VirtualWinner.findOne({ id: id });
+  winnersSecure,
-    if (!virtualWinner) {
+  drawWinner,
-      console.log(
+  finish,
-        `Timeout done for user ${id}, but user has already sent data.`
+  attendees,
-      );
+  attendeesSecure,
-      return;
+  addAttendee
-    }
-    console.log(`Timeout done for user ${id}, sending update to user.`);
-
-    Message.sendMessageTooLate(virtualWinner);
-
-    virtualWinner.timestamp_drawn = new Date().getTime();
-    virtualWinner.timestamp_limit = null;
-    virtualWinner.timestamp_sent = null;
-
-    await virtualWinner.save();
-
-    let prelotteryWine = await PreLotteryWine.find();
-    let nextWinner = await VirtualWinner.find().sort({ timestamp_drawn: 1 });
-    if (nextWinner.length == 1 && prelotteryWine.length == 1) {
-      chooseForUser(nextWinner[0], prelotteryWine[0]);
-    } else {
-      nextWinner[0].timestamp_sent = new Date().getTime();
-      nextWinner[0].timestamp_limit = new Date().getTime() + 600000;
-      await nextWinner[0].save();
-      Message.sendMessage(nextWinner[0]);
-      startTimeout(nextWinner[0].id); 
-    }
-    
-  }, 600000);
 }
 
-module.exports = function(_io) {
-  io = _io;
-  return router;
-};

api/virtualRegistration.js

@@ -1,11 +1,4 @@
-const express = require("express");
 const path = require("path");
-const router = express.Router();
-const mongoose = require("mongoose");
-
-mongoose.connect("mongodb://localhost:27017/vinlottis", {
-  useNewUrlParser: true
-});
 
 const _wineFunctions = require(path.join(__dirname + "/../api/wine"));
 const _personFunctions = require(path.join(__dirname + "/../api/person"));
@@ -17,72 +10,70 @@ const PreLotteryWine = require(path.join(
   __dirname + "/../schemas/PreLotteryWine"
 ));
 
-router.use((req, res, next) => {
-  next();
-});
 
-router.route("/winner/:id").get((req, res) => {
+const getWinesToWinnerById = async (req, res) => {
-  res.redirect(`/#/winner/${req.params.id}`);
-});
-
-router.route("/:id").get(async (req, res) => {
   let id = req.params.id;
   let foundWinner = await VirtualWinner.findOne({ id: id });
 
   if (!foundWinner) {
-    res.json({
+    return res.json({
+      success: false,
+      message: "No winner with this id.",
       existing: false,
       turn: false
     });
-    return;
   }
 
   let allWinners = await VirtualWinner.find().sort({ timestamp_drawn: 1 });
-
   if (
     allWinners[0].id != foundWinner.id ||
     foundWinner.timestamp_limit == undefined ||
     foundWinner.timestamp_sent == undefined
   ) {
-    res.json({ existing: true, turn: false });
+    return res.json({
-    return;
+      success: false,
+      message: "Not the winner next in line!",
+      existing: true,
+      turn: false
+    });
   }
 
-  res.json({
+  return res.json({
+    success: true,
     existing: true,
     turn: true,
     name: foundWinner.name,
     color: foundWinner.color
   });
-  return;
+};
-});
 
-router.route("/:id").post(async (req, res) => {
+const registerWinnerSelection = async (req, res) => {
   let id = req.params.id;
   let wineName = req.body.wineName;
   let foundWinner = await VirtualWinner.findOne({ id: id });
 
   if (!foundWinner) {
-    res.json(false);
+    return res.json({
-    return;
+      success: false,
+      message: "No winner with this id."
+    })
+  } else if (foundWinner.timestamp_limit < new Date().getTime()) {
+    return res.json({
+      success: false,
+      message: "Timelimit expired, you will receive a wine after other users have chosen.",
+      limit: true
+    })
   }
 
-  if (foundWinner.timestamp_limit < new Date().getTime()) {
-    res.json({
-      success: false,
-      limit: true
-    });
-    return;
-  }
   let date = new Date();
   date.setHours(5, 0, 0, 0);
-
   let prelotteryWine = await PreLotteryWine.findOne({ name: wineName });
 
   if (!prelotteryWine) {
-    res.json({
+    return res.json({
       success: false,
-      wine: true
+      message: "No wine with this name.",
+      wine: false
     });
   }
 
@@ -91,31 +82,78 @@ router.route("/:id").post(async (req, res) => {
   await _personFunctions.findSavePerson(foundWinner, wonWine, date);
 
   await foundWinner.delete();
+  console.info("Saved winners choice.");
 
-  let nextWineBottle = await PreLotteryWine.find();
+  return findAndNotifyNextWinner()
-  let nextWinner = await VirtualWinner.find().sort({ timestamp_drawn: 1 });
+    .then(() => res.json({
-  if (nextWinner.length > 1 && nextWineBottle.length > 1) {
+      message: "Choice saved and next in line notified.",
-    Message.sendMessage(nextWinner[0]);
+      success: true
-    startTimeout(id);
+    }))
-  } else if (nextWinner.length == 1 && nextWineBottle.length == 1) {
+    .catch(error => res.json({
-    chooseForUser(nextWinner[0], nextWineBottle[0]);
+      message: error["message"] || "Error when notifing next winner.",
-  }
+      success: false
+    }))
+};
 
-  res.json({
+const chooseLastWineForUser = (winner, prelotteryWine) => {
-    success: true
-  });
-  return;
-});
-
-async function chooseForUser(winner, prelotteryWine) {
   let date = new Date();
   date.setHours(5, 0, 0, 0);
-  let wonWine = await _wineFunctions.findSaveWine(prelotteryWine);
-  await _personFunctions.findSavePerson(winner, wonWine, date);
 
-  await prelotteryWine.delete();
+  return _wineFunctions.findSaveWine(preLotteryWine)
-  await Message.sendWonWineMessage(winner, prelotteryWine);
+    .then(wonWine => _personFunctions.findSavePerson(winner, wonWine, date))
-  await winner.delete();
+    .then(() => prelotteryWine.delete())
+    .then(() => Message.sendLastWinnerMessage(winner, preLotteryWine))
+    .then(() => winner.delete());
+}
+
+const findAndNotifyNextWinner = async () => {
+  let nextWinner = undefined;
+
+  let winnersLeft = await VirtualWinner.find().sort({ timestamp_drawn: 1 });
+  let winesLeft = await PreLotteryWine.find();
+
+  if (winnersLeft.length > 1) {
+    nextWinner = winnersLeft[0]; // multiple winners left, choose next in line
+  } else if (winnersLeft.length == 1 && winesLeft.length > 1) {
+    nextWinner = winnersLeft[0] // one winner left, but multiple wines
+  } else if (winnersLeft.length == 1 && winesLeft.length == 1) {
+    nextWinner = winnersLeft[0] // one winner and one wine left, choose for user
+    wine = winesLeft[0]
+    return chooseLastWineForUser(nextWinner, wine);
+  }
+
+  if (nextWinner) {
+    return Message.sendWineSelectMessage(nextWinner)
+      .then(messageResponse => startTimeout(nextWinner.id))
+  } else {
+    console.info("All winners notified. Could start cleanup here.");
+    return Promise.resolve({
+      message: "All winners notified."
+    })
+  }
+};
+
+const sendNotificationToWinnerById = async (req, res) => {
+  const { id } = req.params;
+  let winner = await VirtualWinner.findOne({ id: id });
+
+  if (!winner) {
+    return res.json({
+      message: "No winner with this id.",
+      success: false
+    })
+  }
+
+  return Message.sendWineSelectMessage(winner)
+    .then(success => res.json({
+      success: success,
+      message: `Message sent to winner ${id} successfully!`
+    }))
+    .catch(err => res.json({
+      success: false,
+      message: "Error while trying to send sms.",
+      error: err
+    }))
 }
 
 function startTimeout(id) {
@@ -123,27 +161,28 @@ function startTimeout(id) {
   setTimeout(async () => {
     let virtualWinner = await VirtualWinner.findOne({ id: id });
     if (!virtualWinner) {
-      console.log(
+      console.log(`Timeout done for user ${id}, but user has already sent data.`);
-        `Timeout done for user ${id}, but user has already sent data.`
-      );
       return;
     }
     console.log(`Timeout done for user ${id}, sending update to user.`);
 
-    Message.sendMessageTooLate(virtualWinner);
+    Message.sendWineSelectMessageTooLate(virtualWinner);
 
     virtualWinner.timestamp_drawn = new Date().getTime();
     virtualWinner.timestamp_limit = null;
     virtualWinner.timestamp_sent = null;
-
     await virtualWinner.save();
 
-    let prelotteryWine = await PreLotteryWine.find();
+    findAndNotifyNextWinner();
-    let nextWinner = await VirtualWinner.find().sort({ timestamp_drawn: 1 });
+  }, 60000);
-    if (nextWinner.length == 1 && prelotteryWine.length == 1) {
+
-      chooseForUser(nextWinner[0], prelotteryWine[0]);
+  return Promise.resolve()
-    }
-  }, 600000);
 }
 
-module.exports = router;
+module.exports = {
+  getWinesToWinnerById,
+  registerWinnerSelection,
+  findAndNotifyNextWinner,
+
+  sendNotificationToWinnerById
+};

api/wineinfo.js

@@ -1,15 +1,8 @@
-const express = require("express");
-const path = require("path");
-const router = express.Router();
 const fetch = require('node-fetch')
+const path = require('path')
 const config = require(path.join(__dirname + "/../config/env/lottery.config"));
-
 const mustBeAuthenticated = require(path.join(__dirname + "/../middleware/mustBeAuthenticated"))
 
-router.use((req, res, next) => {
-  next();
-});
-
 const convertToOurWineObject = wine => {
   if(wine.basic.ageLimit === "18"){
     return {
@@ -25,11 +18,11 @@ const convertToOurWineObject = wine => {
   }
 }
 
-router.route("/wineinfo/search").get(async (req, res) => {
+const wineSearch = async (req, res) => {
   const {query} = req.query
   let url = new URL(`https://apis.vinmonopolet.no/products/v0/details-normal?productShortNameContains=test&maxResults=15`)
   url.searchParams.set('productShortNameContains', query)
-
+  
   const vinmonopoletResponse = await fetch(url, {
     headers: {
       "Ocp-Apim-Subscription-Key": config.vinmonopoletToken
@@ -37,8 +30,8 @@ router.route("/wineinfo/search").get(async (req, res) => {
   })
     .then(resp => resp.json())
     .catch(err => console.error(err))
-
+  
-
+  
   if (vinmonopoletResponse.errors != null) {
     return vinmonopoletResponse.errors.map(error => {
       if (error.type == "UnknownProductError") {
@@ -51,12 +44,11 @@ router.route("/wineinfo/search").get(async (req, res) => {
     })
   }
   const winesConverted = vinmonopoletResponse.map(convertToOurWineObject).filter(Boolean)
-  res.send(winesConverted);
-});
 
+  return res.send(winesConverted);
+}
 
-
+const byEAN = async (req, res) => {
-router.route("/wineinfo/:ean").get(async (req, res) => {
   const vinmonopoletResponse = await fetch("https://app.vinmonopolet.no/vmpws/v2/vmp/products/barCodeSearch/" + req.params.ean)
     .then(resp => resp.json())
 
@@ -72,7 +64,10 @@ router.route("/wineinfo/:ean").get(async (req, res) => {
     })
   }
 
-  res.send(vinmonopoletResponse);
+  return res.send(vinmonopoletResponse);
-});
+};
 
-module.exports = router;
+module.exports = {
+  byEAN,
+  wineSearch
+};

package.json

@@ -6,7 +6,7 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "start": "node server.js",
-    "dev": "cross-env NODE_ENV=development webpack-dev-server --progress",
+    "dev": "cross-env NODE_ENV=development webpack-dev-server",
     "build": "cross-env NODE_ENV=production webpack --progress --hide-modules"
   },
   "author": "",
@@ -35,7 +35,6 @@
     "passport-local-mongoose": "^6.0.1",
     "qrcode": "^1.4.4",
     "referrer-policy": "^1.2.0",
-    "request": "^2.88.2",
     "socket.io": "^2.3.0",
     "socket.io-client": "^2.3.0",
     "vue": "~2.6",

server.js

@@ -6,17 +6,13 @@ const path = require("path");
 const session = require("express-session");
 const User = require(path.join(__dirname + "/schemas/User"));
 
-const updateApi = require(path.join(__dirname + "/api/update"));
+const apiRouter = require(path.join(__dirname + "/api/router.js"));
-const retrieveApi = require(path.join(__dirname + "/api/retrieve"));
+
-const subscriptionApi = require(path.join(__dirname + "/api/subscriptions"));
 const loginApi = require(path.join(__dirname + "/api/login"));
 const wineinfoApi = require(path.join(__dirname + "/api/wineinfo"));
 const requestApi = require(path.join(__dirname + "/api/request"));
 const virtualApi = require(path.join(__dirname + "/api/virtualLottery"));
-const virtualRegistrationApi = require(path.join(
+const subscriptionApi = require(path.join(__dirname + "/api/subscriptions"));
-  __dirname + "/api/virtualRegistration"
-));
-const lottery = require(path.join(__dirname + "/api/lottery"));
 
 //This is required for the chat to work
 const chat = require(path.join(__dirname + "/api/chat"))(io);
@@ -77,6 +73,8 @@ app.use(
   })
 );
 
+app.set('socketio', io);
+
 const passport = require("passport");
 const LocalStrategy = require("passport-local");
 
@@ -92,19 +90,20 @@ passport.deserializeUser(User.deserializeUser());
 app.use("/public", express.static(path.join(__dirname, "public")));
 app.use("/dist", express.static(path.join(__dirname, "public/dist")));
 app.use("/", loginApi);
-app.use("/api/", updateApi);
+// app.use("/api/", updateApi);
-app.use("/api/", retrieveApi);
+// app.use("/api/", retrieveApi);
-app.use("/api/", wineinfoApi);
+// app.use("/api/", wineinfoApi);
-app.use("/api/", requestApi);
+// app.use("/api/", requestApi);
 app.use("/api/", chatHistory);
-app.use("/api/lottery", lottery);
+app.use("/api/", apiRouter);
-app.use("/api/virtual/", virtualApi(io));
-app.use("/api/virtual-registration/", virtualRegistrationApi);
 app.use("/subscription", subscriptionApi);
 
 app.get("/dagens", function(req, res) {
   res.redirect("/#/dagens");
 });
+app.get("/winner/:id", function(req, res) {
+  res.redirect("/#/winner/" + req.params.id);
+});
 
 app.use("/service-worker.js", function(req, res) {
   res.sendFile(path.join(__dirname, "public/sw/serviceWorker.js"));

src/Vinlottis.vue

@@ -52,6 +52,7 @@ export default {
 
 <style lang="scss">
 @import "./styles/global.scss";
+@import "./styles/positioning.scss";
 @font-face {
   font-family: "knowit";
   font-weight: 600;

src/api.js

@@ -1,3 +1,5 @@
+import fetch from "node-fetch";
+
 const BASE_URL = __APIURL__ || window.location.origin;
 
 const statistics = () => {
@@ -48,8 +50,22 @@ const prelottery = () => {
   return fetch(url.href).then(resp => resp.json());
 };
 
-const log = sendObject => {
+const sendLottery = sendObject => {
-  const url = new URL("/api/log", BASE_URL);
+  const url = new URL("/api/lottery", BASE_URL);
+
+  const options = {
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST",
+    body: JSON.stringify(sendObject)
+  };
+
+  return fetch(url.href, options).then(resp => resp.json());
+};
+
+const sendLotteryWinners = sendObject => {
+  const url = new URL("/api/lottery/winners", BASE_URL);
 
   const options = {
     headers: {
@@ -63,7 +79,7 @@ const log = sendObject => {
 };
 
 const addAttendee = sendObject => {
-  const url = new URL("/api/virtual/attendee", BASE_URL);
+  const url = new URL("/api/virtual/attendee/add", BASE_URL);
 
   const options = {
     headers: {
@@ -77,32 +93,32 @@ const addAttendee = sendObject => {
 };
 
 const getVirtualWinner = () => {
-  const url = new URL("/api/virtual/winner", BASE_URL);
+  const url = new URL("/api/virtual/winner/draw", BASE_URL);
 
   return fetch(url.href).then(resp => resp.json());
 };
 
 const attendeesSecure = () => {
-  const url = new URL("/api/virtual/attendees/secure", BASE_URL);
+  const url = new URL("/api/virtual/attendee/all/secure", BASE_URL);
 
   return fetch(url.href).then(resp => resp.json());
 };
 
 const winnersSecure = () => {
-  const url = new URL("/api/virtual/winners/secure", BASE_URL);
+  const url = new URL("/api/virtual/winner/all/secure", BASE_URL);
 
   return fetch(url.href).then(resp => resp.json());
 };
 
 const winners = () => {
-  const url = new URL("/api/virtual/winners", BASE_URL);
+  const url = new URL("/api/virtual/winner/all", BASE_URL);
 
   return fetch(url.href).then(resp => resp.json());
 };
 
 const deleteRequestedWine = wineToBeDeleted => {
 
-  const url = new URL("api/request", BASE_URL);
+  const url = new URL("api/request/"+ wineToBeDeleted._id, BASE_URL);
 
   const options = {
     headers: {
@@ -116,7 +132,7 @@ const deleteRequestedWine = wineToBeDeleted => {
 }
 
 const deleteWinners = () => {
-  const url = new URL("/api/virtual/winners", BASE_URL);
+  const url = new URL("/api/virtual/winner/all", BASE_URL);
 
   const options = {
     headers: {
@@ -129,7 +145,7 @@ const deleteWinners = () => {
 };
 
 const deleteAttendees = () => {
-  const url = new URL("/api/virtual/attendees", BASE_URL);
+  const url = new URL("/api/virtual/attendee/all", BASE_URL);
 
   const options = {
     headers: {
@@ -142,11 +158,28 @@ const deleteAttendees = () => {
 };
 
 const attendees = () => {
-  const url = new URL("/api/virtual/attendees", BASE_URL);
+  const url = new URL("/api/virtual/attendee/all", BASE_URL);
 
   return fetch(url.href).then(resp => resp.json());
 };
 
+const requestNewWine = (wine) => {
+  const options = {
+    body: JSON.stringify({
+      wine: wine
+    }),
+     headers: {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json'
+    },
+    method: "post"
+  }
+
+  const url = new URL("/api/request/new-wine", BASE_URL)
+
+  return fetch(url.href, options).then(resp => resp.json())
+}
+
 const logWines = wines => {
   const url = new URL("/api/log/wines", BASE_URL);
 
@@ -162,7 +195,7 @@ const logWines = wines => {
 };
 
 const wineSchema = () => {
-  const url = new URL("/api/log/schema", BASE_URL);
+  const url = new URL("/api/wineinfo/schema", BASE_URL);
 
   return fetch(url.href).then(resp => resp.json());
 };
@@ -253,17 +286,20 @@ const getChatHistory = (skip = null, take = null) => {
 
 const finishedDraw = () => {
   const url = new URL("/api/virtual/finish", BASE_URL);
+  const options = {
+    method: 'POST'
+  }
 
-  return fetch(url.href).then(resp => resp.json());
+  return fetch(url.href, options).then(resp => resp.json());
 };
 
 const getAmIWinner = id => {
-  const url = new URL(`/api/virtual-registration/${id}`, BASE_URL);
+  const url = new URL(`/api/winner/${id}`, BASE_URL);
   return fetch(url.href).then(resp => resp.json());
 };
 
 const postWineChosen = (id, wineName) => {
-  const url = new URL(`/api/virtual-registration/${id}`, BASE_URL);
+  const url = new URL(`/api/winner/${id}`, BASE_URL);
   const options = {
     headers: {
       "Content-Type": "application/json"
@@ -301,11 +337,13 @@ export {
   chartWinsByColor,
   chartPurchaseByColor,
   prelottery,
-  log,
+  sendLottery,
+  sendLotteryWinners,
   logWines,
   wineSchema,
   barcodeToVinmonopolet,
   searchForWine,
+  requestNewWine,
   allRequestedWines,
   login,
   register,

src/components/RegisterPage.vue

@@ -78,6 +78,10 @@
       </div>
     </div>
 
+    <div class="button-container">
+      <button class="vin-button" @click="submitLottery">Send inn lotteri</button>
+    </div>
+
     <h3>Vinnere</h3>
     <a class="wine-link" @click="fetchColorsAndWinners()">Refresh data fra virtuelt lotteri</a>
     <div class="winner-container" v-if="winners.length > 0">
@@ -130,8 +134,8 @@
         </div>
       </wine>
 
-      <div class="button-container">
+      <div class="button-container column">
-        <button class="vin-button" @click="sendInfo">Send inn vinnere</button>
+        <button class="vin-button" @click="submitLotteryWinners">Send inn vinnere</button>
         <button class="vin-button" @click="resetWinnerDataInStorage">Reset local wines</button>
       </div>
     </div>
@@ -142,9 +146,11 @@
 
 <script>
 import eventBus from "@/mixins/EventBus";
+import { dateString } from '@/utils'
 import {
   prelottery,
-  log,
+  sendLotteryWinners,
+  sendLottery,
   logWines,
   wineSchema,
   winnersSecure,
@@ -306,7 +312,7 @@ export default {
     },
     sendWines: async function() {
       let response = await logWines(this.wines);
-      if (response == true) {
+      if (response.success == true) {
         alert("Sendt!");
         window.location.reload();
       } else {
@@ -324,7 +330,7 @@ export default {
         }
       });
     },
-    sendInfo: async function(event) {
+    submitLottery: async function(event) {
       const colors = {
         red: this.lotteryColors.filter(c => c.css == "red")[0].value,
         green: this.lotteryColors.filter(c => c.css == "green")[0].value,
@@ -333,48 +339,63 @@ export default {
       };
 
       let sendObject = {
-        purchase: {
+        lottery: {
-          date: new Date(),
+          date: dateString(new Date()),
           ...colors
-        },
+        }
-        winners: this.winners
       };
 
-      if (sendObject.purchase.red == undefined) {
+      if (sendObject.lottery.red == undefined) {
         alert("Rød må defineres");
         return;
       }
-      if (sendObject.purchase.green == undefined) {
+      if (sendObject.lottery.green == undefined) {
         alert("Grønn må defineres");
         return;
       }
-      if (sendObject.purchase.yellow == undefined) {
+      if (sendObject.lottery.yellow == undefined) {
         alert("Gul må defineres");
         return;
       }
-      if (sendObject.purchase.blue == undefined) {
+      if (sendObject.lottery.blue == undefined) {
         alert("Blå må defineres");
         return;
       }
 
-      sendObject.purchase.bought =
+      sendObject.lottery.bought =
         parseInt(colors.blue) +
         parseInt(colors.red) +
         parseInt(colors.green) +
         parseInt(colors.yellow);
-      const stolen = sendObject.purchase.bought - parseInt(this.payed) / 10;
+      const stolen = sendObject.lottery.bought - parseInt(this.payed) / 10;
       if (isNaN(stolen) || stolen == undefined) {
         alert("Betalt må registreres");
         return;
       }
-      sendObject.purchase.stolen = stolen;
+      sendObject.lottery.stolen = stolen;
 
-      if (sendObject.winners.length == 0) {
+      let response = await sendLottery(sendObject);
+      if (response == true) {
+        alert("Sendt!");
+        window.location.reload();
+      } else {
+        alert(response.message || "Noe gikk galt under innsending");
+      }
+    },
+    submitLotteryWinners: async function(event) {
+      let sendObject = {
+        lottery: {
+          date: dateString(new Date()),
+          winners: this.winners
+        }
+      }
+
+      if (sendObject.lottery.winners.length == 0) {
         alert("Det må være med vinnere");
         return;
       }
-      for (let i = 0; i < sendObject.winners.length; i++) {
+      for (let i = 0; i < sendObject.lottery.winners.length; i++) {
-        let currentWinner = sendObject.winners[i];
+        let currentWinner = sendObject.lottery.winners[i];
 
         if (currentWinner.name == undefined || currentWinner.name == "") {
           alert("Navn må defineres");
@@ -386,7 +407,7 @@ export default {
         }
       }
 
-      let response = await log(sendObject);
+      let response = await sendLotteryWinners(sendObject);
       if (response == true) {
         alert("Sendt!");
         window.location.reload();
@@ -613,7 +634,7 @@ hr {
   flex-wrap: wrap;
   justify-content: center;
   max-width: 1400px;
-  margin: 3rem auto 0;
+  margin: 3rem auto 1rem;
 
   @include mobile {
     margin: 1.8rem auto 0;

src/components/RequestWine.vue

@@ -95,7 +95,7 @@ export default {
         method: "post"
       }
 
-      fetch("http://localhost:30030/api/request", options)
+      fetch("http://localhost:30030/api/request/new-wine", options)
         .then(res => res.json())
         .then(() => this.showModal = true)
     },

src/components/VirtualLotteryRegistrationPage.vue

@@ -106,6 +106,8 @@
     </div>
     <br />
     <button class="vin-button" @click="sendAttendee">Send deltaker</button>
+
+    <TextToast v-if="showToast" :text="toastText" v-on:closeToast="showToast = false" />
   </div>
 </template>
 
@@ -119,13 +121,16 @@ import {
   winnersSecure,
   deleteWinners,
   deleteAttendees,
-  finishedDraw
+  finishedDraw,
+  prelottery
 } from "@/api";
+import TextToast from "@/ui/TextToast";
 import RaffleGenerator from "@/ui/RaffleGenerator";
 
 export default {
   components: {
-    RaffleGenerator
+    RaffleGenerator,
+    TextToast
   },
   data() {
     return {
@@ -144,7 +149,9 @@ export default {
       drawTime: 20,
       currentWinners: 1,
       numberOfWinners: 4,
-      socket: null
+      socket: null,
+      toastText: undefined,
+      showToast: false
     };
   },
   mounted() {
@@ -168,13 +175,21 @@ export default {
     });
 
     window.finishedDraw = finishedDraw;
-    console.log("here");
   },
   methods: {
     setWithRandomColors(colors) {
       Object.keys(colors).forEach(color => (this[color] = colors[color]));
     },
     sendAttendee: async function() {
+      if (this.red == 0 && this.blue == 0 && this.green == 0 && this.yellow == 0) {
+        alert('Ingen farger valgt!')
+        return;
+      }
+      if (this.name == 0 && this.phoneNumber) {
+        alert('Ingen navn eller tlf satt!')
+        return;
+      }
+
       let response = await addAttendee({
         name: this.name,
         phoneNumber: this.phoneNumber,
@@ -184,10 +199,15 @@ export default {
         yellow: this.yellow,
         ballots: this.ballots
       });
+
       if (response == true) {
-        alert("Sendt inn deltaker!");
+        this.toastText = `Sendt inn deltaker: ${this.name}`;
+        this.showToast = true;
+
         this.name = null;
         this.phoneNumber = null;
+        this.yellow = 0;
+        this.green = 0;
         this.red = 0;
         this.blue = 0;
 
@@ -208,6 +228,7 @@ export default {
       if (window.confirm("Er du sikker på at du vil trekke vinnere?")) {
         this.drawingWinner = true;
         let response = await getVirtualWinner();
+
         if (response) {
           if (this.currentWinners < this.numberOfWinners) {
             this.countdown();

src/components/WinnerPage.vue

@@ -62,11 +62,9 @@ export default {
     this.name = winnerObject.name;
     const _wines = await fetch("/api/wines/prelottery");
     this.wines = await _wines.json();
-    console.log(this.wines);
   },
   methods: {
     chosenWine: async function(name) {
-      console.log("chosen a wine");
       let posted = await postWineChosen(this.id, name);
       console.log("response", posted);
       if (posted.success) {
@@ -82,7 +80,8 @@ export default {
 .container {
   display: flex;
   justify-content: center;
-  margin-top: 4rem;
+  margin-top: 2rem;
+  padding: 2rem;
 }
 .sent-container {
   width: 100%;

src/styles/global.scss

@@ -74,6 +74,16 @@ body {
     margin-right: 2rem;
   }
 
+  &.column {
+    flex-direction: column;
+    align-items: center;
+
+    > * {
+      margin-right: unset;
+      margin-bottom: 1rem;
+    }
+  }
+
   @include mobile {
     &:not(.row) {
       flex-direction: column;
@@ -108,6 +118,7 @@ textarea {
   border: 0;
   width: fit-content;
   font-size: 1.3rem;
+  line-height: 1.3rem;
   height: 4rem;
   max-height: 4rem;
   cursor: pointer;

src/styles/positioning.scss

@@ -0,0 +1,7 @@
+.flex {
+  display: flex;
+
+  &-column {
+    flex-direction: column;
+  }
+}

src/ui/RequestedWineCard.vue

@@ -56,13 +56,13 @@ export default {
         },
         method: "post"
       }
-      fetch("http://localhost:30030/api/request", options)
+      fetch("http://localhost:30030/api/request/new-wine", options)
         .then(res => res.json())
     },
     async deleteWine(wine) {
       if (window.confirm("Er du sikker på at du vil slette vinen?")) {
         let response = await deleteRequestedWine(wine);
-        if (response) {
+        if (response['success'] == true) {
           this.$emit('wineDeleted', wine);
         } else {
           alert("Klarte ikke slette vinen");

src/ui/Wine.vue

@@ -22,6 +22,7 @@
           :href="wine.vivinoLink"
           class="wine-link"
         >Les mer på {{ hostname(wine.vivinoLink) }}</a>
+
         <button
           v-if="winner"
           @click="choseWine(wine.name)"
@@ -174,4 +175,8 @@ a:visited {
     color: $red;
   }
 }
+
+.vin-button {
+  margin-top: 1rem;
+}
 </style>

src/ui/Winners.vue

@@ -34,8 +34,10 @@ h2 {
 
 .winners {
   display: flex;
+  flex-flow: wrap;
   justify-content: space-around;
   align-items: center;
+  flex-wrap: wrap;
 }
 
 .ballot-element {

src/utils.js

@@ -0,0 +1,12 @@
+ 
+const dateString = (date) => {
+  const ye = new Intl.DateTimeFormat('en', { year: 'numeric' }).format(date)
+  const mo = new Intl.DateTimeFormat('en', { month: '2-digit' }).format(date)
+  const da = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(date)
+
+  return `${ye}-${mo}-${da}`
+}
+
+module.exports = {
+  dateString
+}

src/vinlottis-init.js

@@ -1,6 +1,6 @@
 import Vue from "vue";
 import VueRouter from "vue-router";
-import { routes } from "@/routes/vinlottisRouter";
+import { routes } from "@/router.js";
 import Vinlottis from "@/Vinlottis";
 import VueAnalytics from "vue-analytics";