Add events

README.md

@@ -11,15 +11,24 @@ Server for Integrated Project, powered by Express.js and Redis, listens only on
     * [Running](#running)
 * [API](#api)
     * [/hello/:name/](#helloname)
+
     * [/user/register/](#userregister)
     * [/user/auth/](#userauth)
     * [/user/view/](#userview)
     * [/user/view/:user](#userviewuser)
+
     * [/society/create/](#societycreate)
     * [/society/view/](#societyview)
     * [/society/view/:society\_name](#societyviewsociety_name)
+    * [/society/view/:society\_name/events](#societyviewsociety_nameevents)
     * [/society/join/](#societyjoin)
 
+    * [/events/create/](#eventscreate)
+    * [/events/view/:eventid](#eventsvieweventid)
+    * [/events/pending/](#eventspending)
+    * [/events/accept/:eventid](#eventsaccepteventid)
+    * [/events/decline/:eventid](#eventsdeclineeventid)
+
 ### Installation
 Instructions are for OSX El Capitan at time of writing.
 
@@ -222,6 +231,47 @@ no data. The response will then be formed as follows:
 ```
 The error codes are as follows, `1` indicates that the society does not exist.
 
+### /society/view/:society\_name/events
+To view all the events for a society, :society\_name, a `GET` request should be
+sent with the following data:
+```javascript
+{
+  "auth": "$2a$10$ruuu6QfYLjW1QKOwONVvkelXuh8EVFyug/kJvfaTNL0aXNGyODZ9K"
+}
+```
+Then the server will respond like this:
+```javascript
+{
+  "events": [
+    {
+      "name": "Super Mario Kart Party",
+      "location": "Marioland",
+      "society": "TestSociety",
+      "start": "14605026110490",
+      "end": "14605026110500",
+      "details": "Play some Mario Kart with us",
+      "organiser": "test1"
+    },
+    {
+      "name": "Super Mario Kart Party 2",
+      "location": "Marioland",
+      "society": "TestSociety",
+      "start": "14605026110490",
+      "end": "14605026110500",
+      "details": "Play some Mario Kart with us",
+      "organiser": "test1"
+    },
+    { ... },
+    { ... },
+    { ... },
+    { ... }
+  ],
+  "error": 0
+}
+```
+The error codes are as follows, `1` indicates an invalid authentication key and
+`2` indicates a malformed request.
+
 ### /society/join/
 To join a society, a `POST` request should be sent with the following data:
 ```javascript
@@ -239,3 +289,20 @@ The response is then formed as follows:
 ```
 The error codes are as follows, `1` indicates that the user is already a member
 of that society and `2` indicates a malformed request.
+
+### /events/create/
+To create a new event, a `POST` request... its 4:30am and im shit tired of
+writing documentation, essentially just give it an auth key for all the following
+requests and you'll be golden, you can check what shit gets returned for yourself
+until I get a chance to write this up
+
+### /events/view/:eventid
+
+
+### /events/pending/
+
+
+### /events/accept/:eventid
+
+
+### /events/decline/:eventid

presenters/event-controller.js

@@ -0,0 +1,250 @@
+var Redis = require("ioredis");
+var redis = new Redis();
+var permissions_controller = require("./permissions-controller.js");
+var user_controller = require("./user-controller.js");
+var society_controller = require("./society-controller.js");
+
+module.exports = {
+  create_event: function (soc_name, event, auth, complete) {
+    var self = this;
+    permissions_controller.user_can_manage_soc_events(auth, soc_name, function (manageable) {
+      if (manageable) {
+        user_controller.get_user_from_auth(auth, function(organiser) {
+          if (event.end > event.start && event.start > Date.now()) {
+            self.get_random_event_id(function(event_id) {
+              event_query = "event:" + event_id;
+              soc_query = "society:" + soc_name.toLowerCase();
+              self.invite_all(soc_name, event_id);
+              redis.hset(event_query, "name", event.name);
+              redis.hset(event_query, "location", event.location);
+              redis.hset(event_query, "society", soc_name);
+              redis.hset(event_query, "start", event.start);
+              redis.hset(event_query, "end", event.end);
+              redis.hset(event_query, "details", event.details);
+              redis.hset(event_query, "organiser", organiser);
+              redis.hset(event_query, "id", event_id);
+              redis.hget(soc_query, "events", function (err, events) {
+                redis.hset(soc_query, "events", JSON.stringify(JSON.parse(events).concat(event_id)));
+              });
+              complete({
+                "success": 1,
+                "event": {
+                  "id": event_id,
+                  "name": event.name,
+                  "organiser": organiser,
+                  "location": event.location,
+                  "society": soc_name,
+                  "start": event.start,
+                  "end": event.end,
+                  "details": event.details
+                },
+                "error": 0
+              })
+            });
+          } else {
+            complete({
+              "success": 0,
+              "error": 2
+            })
+          }
+        });
+      } else {
+        complete({
+          "success": 0,
+          "error": 1
+        });
+      }
+    });
+  },
+
+  invite_all: function (soc_name, event_id) {
+    society_controller.get_society(soc_name, function (response) {
+      response.society.users.map(function (user) {
+        user_controller.get_raw_user(user, function (userdata) {
+          redis.hset("user:" + user, "pending_events", JSON.stringify(JSON.parse(userdata.pending_events).concat(event_id)));
+        });
+      });
+    });
+  },
+
+  get_event: function (event_id, auth, complete, preauth) {
+    redis.hgetall("event:" + event_id, function (err, event) {
+      if (preauth) {
+        complete({
+          "event": event,
+          "error": 0
+        });
+        return;
+      }
+      permissions_controller.user_is_in_society(auth, event.society, function (canview) {
+        if (canview) {
+          complete({
+            "event": event,
+            "error": 0
+          });
+        } else {
+          complete({
+            "event": {},
+            "error": 1
+          });
+        }
+      });
+    });
+  },
+
+  get_all_soc_events: function (soc_name, auth, complete) {
+    var self = this;
+    permissions_controller.user_is_in_society(auth, soc_name, function (canview) {
+      if (canview) {
+        society_controller.get_society(soc_name, function (response) {
+          var events = response.society.events;
+          var event_objs = [];
+          for (var ii = 0; ii < events.length; ii++) {
+            self.get_event(events[ii], "", function(response) {
+              event_objs.push(response.event);
+              if (event_objs.length === events.length) {
+                complete({
+                  "events": event_objs,
+                  "error": 0
+                });
+              }
+            }, true);
+          }
+        });
+      } else {
+        complete({
+          "events": [],
+          "error": 1
+        })
+      }
+    });
+  },
+
+  get_random_event_id: function (complete) {
+    var tmp_id = Math.floor(Math.random() * (1000000000-1)+1);
+    this.event_exists(tmp_id, function (exists) {
+      if (exists) {
+        get_random_event_id(complete);
+      } else {
+        complete(String(tmp_id));
+      }
+    });
+  },
+
+  event_exists: function (event_id, complete) {
+    redis.hget("event:" + event_id, "name", function (err, result) {
+      complete(!!result);
+    });
+  },
+
+  accept_event: function (event_id, auth, complete) {
+    user_controller.get_user_from_auth(auth, function (username) {
+      if (username) {
+        user_controller.get_raw_user(username, function (userdata) {
+          var pending_events = JSON.parse(userdata.pending_events);
+          var declined_events = JSON.parse(userdata.declined_events);
+          var accepted_events = JSON.parse(userdata.accepted_events);
+          if (pending_events.indexOf(event_id) > -1) {
+            pending_events.splice(pending_events.indexOf(event_id), 1);
+            accepted_events.push(event_id);
+            redis.hset("user:" + username, "pending_events", JSON.stringify(pending_events));
+            redis.hset("user:" + username, "accepted_events", JSON.stringify(accepted_events));
+            complete({
+              "success": 1,
+              "error": 0
+            });
+          } else if (declined_events.indexOf(event_id) > -1) {
+            declined_events.splice(declined_events.indexOf(event_id), 1);
+            accepted_events.push(event_id);
+            redis.hset("user:" + username, "declined_events", JSON.stringify(declined_events));
+            redis.hset("user:" + username, "accepted_events", JSON.stringify(accepted_events));
+            complete({
+              "success": 1,
+              "error": 0
+            });
+          } else {
+            complete({
+              "success": 0,
+              "error": 2
+            });
+          }
+        });
+      } else {
+        complete({
+          "success": 0,
+          "error": 1
+        });
+      }
+    });
+  },
+
+  decline_event: function (event_id, auth, complete) {
+    user_controller.get_user_from_auth(auth, function (username) {
+      if (username) {
+        user_controller.get_raw_user(username, function (userdata) {
+          var pending_events = JSON.parse(userdata.pending_events);
+          var declined_events = JSON.parse(userdata.declined_events);
+          var accepted_events = JSON.parse(userdata.accepted_events);
+          if (pending_events.indexOf(event_id) > -1) {
+            pending_events.splice(pending_events.indexOf(event_id), 1);
+            declined_events.push(event_id);
+            redis.hset("user:" + username, "pending_events", JSON.stringify(pending_events));
+            redis.hset("user:" + username, "declined_events", JSON.stringify(declined_events));
+            complete({
+              "success": 1,
+              "error": 0
+            });
+          } else if (accepted_events.indexOf(event_id) > -1) {
+            accepted_events.splice(accepted_events.indexOf(event_id), 1);
+            declined_events.push(event_id);
+            redis.hset("user:" + username, "accepted_events", JSON.stringify(accepted_events));
+            redis.hset("user:" + username, "declined_events", JSON.stringify(declined_events));
+            complete({
+              "success": 1,
+              "error": 0
+            });
+          } else {
+            complete({
+              "success": 0,
+              "error": 2
+            });
+          }
+        });
+      } else {
+        complete({
+          "success": 0,
+          "error": 1
+        });
+      }
+    });
+  },
+
+  get_all_pending_events: function (auth, complete) {
+    var self = this;
+    user_controller.get_user_from_auth(auth, function (username) {
+      if (username) {
+        user_controller.get_raw_user(username, function (userdata) {
+          var pending_events = JSON.parse(userdata.pending_events);
+          var pending_events_objs = [];
+          pending_events.map(function (event_id) {
+            self.get_event(event_id, "", function (response) {
+              response.event.id = event_id;
+              pending_events_objs.push(response.event);
+              if (pending_events_objs.length === pending_events.length) {
+                complete({
+                  "pending_events": pending_events_objs,
+                  "error": 0
+                });
+              }
+            }, true);
+          })
+        });
+      } else {
+        complete({
+          "pending_events": [],
+          "error": 1
+        });
+      }
+    });
+  }
+}

presenters/user-controller.js

@@ -26,6 +26,7 @@ module.exports = {
         public.societies = JSON.parse(result.societies) || [];
         public.friends = JSON.parse(result.friends) || [];
         public.accepted_events = JSON.parse(result.accepted_events) || [];
+        public.declined_events = JSON.parse(result.declined_events) || [];
         complete({
           "user": public,
           "error": 0
@@ -39,6 +40,15 @@ module.exports = {
     });
   },
 
+  get_raw_user: function (user, complete) {
+    console.warn("WARNING: Accessing raw user info, use with care and do not expose to API endpoints.");
+    var user_key = "user:" + user;
+
+    redis.hgetall(user_key, function(err, result) {
+      complete(result);
+    });
+  },
+
   get_all_public_infos: function (complete) {
     var self = this;
     var stream = redis.scanStream({

routes/events/accept-event.js

@@ -0,0 +1,23 @@
+var event_controller = require("./../../presenters/event-controller.js");
+
+module.exports = {
+  perform: function (a,b) {
+    perform(a,b);
+  }
+}
+
+var perform = function (req, res) {
+  var event_id = req.params.eventid;
+  var auth = req.body.auth || req.query.auth;
+
+  if (event_id && auth) {
+    event_controller.accept_event(event_id, auth, function (response) {
+      res.send(response);
+    });
+  } else {
+    res.send({
+      "success": 0,
+      "error": 3
+    });
+  }
+};

routes/events/create-society-event.js

@@ -0,0 +1,35 @@
+var event_controller = require("./../../presenters/event-controller.js");
+
+module.exports = {
+  perform: function (a,b) {
+    perform(a,b);
+  }
+}
+
+var perform = function (req, res) {
+  var soc_name = decodeURIComponent(req.body.society || req.query.society);
+  var event_name = decodeURIComponent(req.body.name || req.query.name);
+  var event_loc = decodeURIComponent(req.body.location || req.query.location);
+  var event_start = decodeURIComponent(req.body.start || req.query.start);
+  var event_end = decodeURIComponent(req.body.end || req.query.end);
+  var event_details = decodeURIComponent(req.body.details || req.query.details);
+  var auth_key = decodeURIComponent(req.body.auth || req.query.auth);
+
+  if (soc_name && event_name && event_loc && event_start && event_end && event_details && auth_key) {
+    var event = {
+      name: event_name,
+      location: event_loc,
+      start: event_start,
+      end: event_end,
+      details: event_details
+    };
+    event_controller.create_event(soc_name, event, auth_key, function (response) {
+      res.send(response);
+    });
+  } else {
+    res.send({
+      "success": 0,
+      "error": 3
+    });
+  }
+};

routes/events/decline-event.js

@@ -0,0 +1,23 @@
+var event_controller = require("./../../presenters/event-controller.js");
+
+module.exports = {
+  perform: function (a,b) {
+    perform(a,b);
+  }
+}
+
+var perform = function (req, res) {
+  var event_id = req.params.eventid;
+  var auth = req.body.auth || req.query.auth;
+
+  if (event_id && auth) {
+    event_controller.decline_event(event_id, auth, function (response) {
+      res.send(response);
+    });
+  } else {
+    res.send({
+      "success": 0,
+      "error": 3
+    });
+  }
+};

routes/events/view-all-society-events.js

@@ -0,0 +1,23 @@
+var event_controller = require("./../../presenters/event-controller.js");
+
+module.exports = {
+  perform: function (a,b) {
+    perform(a,b);
+  }
+}
+
+var perform = function (req, res) {
+  var soc_name = req.params.societyid;
+  var auth = req.body.auth || req.query.auth;
+
+  if (soc_name && auth) {
+    event_controller.get_all_soc_events(soc_name, auth, function (response) {
+      res.send(response);
+    });
+  } else {
+    res.send({
+      "events": [],
+      "error": 2
+    })
+  }
+};

routes/events/view-pending-events.js

@@ -0,0 +1,22 @@
+var event_controller = require("./../../presenters/event-controller.js");
+
+module.exports = {
+  perform: function (a,b) {
+    perform(a,b);
+  }
+}
+
+var perform = function (req, res) {
+  var auth = req.body.auth || req.query.auth;
+
+  if (auth) {
+    event_controller.get_all_pending_events(auth, function (response) {
+      res.send(response);
+    });
+  } else {
+    res.send({
+      "pending_events": [],
+      "error": 2
+    });
+  }
+};

routes/events/view-society-events.js

@@ -0,0 +1,22 @@
+var event_controller = require("./../../presenters/event-controller.js");
+
+module.exports = {
+  perform: function (a,b) {
+    perform(a,b);
+  }
+}
+
+var perform = function (req, res) {
+  var auth_key = req.body.auth || req.query.auth;
+
+  if (auth_key) {
+    event_controller.get_event(req.params.eventid, auth_key, function (response) {
+      res.send(response);
+    });
+  } else {
+    res.send({
+      "event": {},
+      "error": 2
+    });
+  }
+};

routes/society/events/create-society-event.js

@@ -1,12 +0,0 @@
-var Redis = require("ioredis");
-var redis = new Redis();
-
-module.exports = {
-  perform: function (a,b) {
-    perform(a,b);
-  }
-}
-
-var perform = function (req, res) {
-
-};

routes/society/events/view-society-events.js

@@ -1,12 +0,0 @@
-var Redis = require("ioredis");
-var redis = new Redis();
-
-module.exports = {
-  perform: function (a,b) {
-    perform(a,b);
-  }
-}
-
-var perform = function (req, res) {
-
-};

utils/route-manager.js

@@ -7,6 +7,12 @@ var user_view = require("../routes/user/view.js");
 var soc_create = require("../routes/society/create-society.js");
 var soc_view = require("../routes/society/view-society.js");
 var soc_join = require("../routes/society/join-society.js");
+var soc_events = require("../routes/events/view-all-society-events.js");
+var event_create = require("../routes/events/create-society-event.js");
+var event_view = require("../routes/events/view-society-events.js");
+var event_pending = require("../routes/events/view-pending-events.js");
+var event_accept = require("../routes/events/accept-event.js");
+var event_decline = require("../routes/events/decline-event.js");
 
 module.exports = router;
 
@@ -16,6 +22,13 @@ router.all('/user/register/', register.perform);
 router.all('/user/auth/', login.perform);
 router.all('/user/view/(:user)?', user_view.perform);
 
-router.all('/society/create', soc_create.perform);
+router.all('/society/create/', soc_create.perform);
 router.all('/society/view/(:societyid)?', soc_view.perform);
+router.all('/society/view/:societyid/events/', soc_events.perform);
 router.all('/society/join/', soc_join.perform);
+
+router.all('/events/create/', event_create.perform);
+router.all('/events/view/:eventid', event_view.perform);
+router.all('/events/pending/', event_pending.perform);
+router.all('/events/accept/:eventid', event_accept.perform);
+router.all('/events/decline/:eventid', event_decline.perform);