Merge pull request #29 from demokratie-live/sprint#6/user-activity

ActivityIndex

Author: ulfgebhardt

package.json

@@ -7,8 +7,7 @@
   "private": true,
   "scripts": {
     "start": "babel-node src/index.js",
-    "dev":
-      "nodemon -L -e js,graphql src/index.js --exec \"node --require dotenv/config --require babel-register\"",
+    "dev": "nodemon -L -e js,graphql src/index.js --exec \"node --require dotenv/config --require babel-register\"",
     "lint": "eslint .",
     "build": "babel src -d dist -s",
     "serve": "node dist/index.js"
@@ -27,11 +26,15 @@
     "graphql-date": "^1.0.3",
     "graphql-tag": "^2.7.3",
     "graphql-tools": "^2.0.0",
+    "jsonwebtoken": "^8.2.0",
     "lodash": "^4.17.4",
     "merge-graphql-schemas": "^1.3.0",
     "mongoose": "^5.0.3",
     "node-fetch": "^2.0.0",
-    "prettier-eslint": "^8.2.0"
+    "passport": "^0.4.0",
+    "passport-jwt": "^4.0.0",
+    "prettier-eslint": "^8.2.0",
+    "react-native-rsa": "^0.0.3"
   },
   "devDependencies": {
     "babel-cli": "^6.26.0",

scripts/importAll.js

@@ -1,6 +1,3 @@
-import ProgressBar from 'cli-progress'; // eslint-disable-line
-import program from 'commander'; // eslint-disable-line
-
 import client from '../src/graphql/client';
 import Procedure from '../src/models/Procedure';
 import getAllProcedures from '../src/graphql/queries/getAllProcedures';

src/express/auth/index.js

@@ -0,0 +1,21 @@
+import mongoose from 'mongoose';
+import passport from 'passport';
+
+import jwt from './jsonWebToken';
+
+export default (app) => {
+  const User = mongoose.model('User');
+
+  app.use(passport.initialize());
+  //   app.use(passport.session());
+
+  passport.serializeUser((user, done) => {
+    done(null, user.id);
+  });
+
+  passport.deserializeUser(async (id, done) => {
+    done(null, await User.findById(id));
+  });
+
+  jwt(app);
+};

src/express/auth/jsonWebToken.js

@@ -0,0 +1,43 @@
+/* eslint no-underscore-dangle: ["error", { "allow": ["_id"] }] */
+import { Strategy, ExtractJwt } from 'passport-jwt';
+import passport from 'passport';
+import mongoose from 'mongoose';
+
+export default (app) => {
+  const UserModel = mongoose.model('User');
+
+  passport.use(new Strategy(
+    {
+      jwtFromRequest: ExtractJwt.fromExtractors([
+        ExtractJwt.fromUrlQueryParameter('auth_token'),
+        ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ]),
+      secretOrKey: process.env.AUTH_JWT_SECRET,
+    },
+    async (jwtPayload, done) => {
+      try {
+        const user = await UserModel.findById(jwtPayload._id);
+        if (!user) {
+          return done(null, false);
+        }
+        return done(null, user);
+      } catch (err) {
+        return done(err, false);
+      }
+    },
+  ));
+
+  app.use((req, res, next) => {
+    passport.authenticate('jwt', { session: true }, (err, user) => {
+      // console.log(info);
+      if (user) {
+        req.user = user;
+      }
+      next();
+    })(req, res, next);
+  });
+
+  app.get('/test', (req, res) => {
+    res.send({ query: req.query, user: req.user });
+  });
+};

src/graphql/resolvers/Activity.js

@@ -0,0 +1,42 @@
+/* eslint no-underscore-dangle: ["error", { "allow": ["_id"] }] */
+
+export default {
+  Query: {
+    activityIndex: async (parent, { procedureId }, { ProcedureModel, ActivityModel, user }) => {
+      if (!user) {
+        throw new Error('No auth');
+      }
+      const procedure = await ProcedureModel.findOne({ procedureId });
+      const activityIndex = await ActivityModel.find({ procedure }).count();
+      const active = await ActivityModel.findOne({
+        user,
+        procedure,
+      });
+      return {
+        activityIndex,
+        active: !!active,
+      };
+    },
+  },
+
+  Mutation: {
+    increaseActivity: async (parent, { procedureId }, { ProcedureModel, ActivityModel, user }) => {
+      if (!user) {
+        throw new Error('No auth');
+      }
+      const procedure = await ProcedureModel.findOne({ procedureId });
+      if (!procedure) {
+        throw new Error('Procedure not found');
+      }
+      let active = await ActivityModel.findOne({
+        user,
+        procedure,
+      });
+      if (!active) {
+        active = await ActivityModel.create({ user, procedure });
+      }
+      const activityIndex = await ActivityModel.find({ procedure }).count();
+      return { activityIndex, active };
+    },
+  },
+};

src/graphql/resolvers/Procedure.js

@@ -80,6 +80,7 @@ export default {
         .limit(pageSize - activeVotings.length)
         .then(finishedVotings => [...activeVotings, ...finishedVotings]);
     },
+
     procedure: async (parent, { id }, { ProcedureModel }) =>
       ProcedureModel.findOne({ procedureId: id }),
 
@@ -89,4 +90,18 @@ export default {
         { score: { $meta: 'textScore' } },
       ).sort({ score: { $meta: 'textScore' } }),
   },
+
+  Procedure: {
+    activityIndex: async (procedure, args, { ActivityModel, user }) => {
+      const activityIndex = await ActivityModel.find({ procedure }).count();
+      const active = await ActivityModel.findOne({
+        user,
+        procedure,
+      });
+      return {
+        activityIndex,
+        active: !!active,
+      };
+    },
+  },
 };

src/graphql/resolvers/User.js

@@ -0,0 +1,41 @@
+/* eslint no-underscore-dangle: ["error", { "allow": ["_id"] }] */
+import RSAKey from 'react-native-rsa';
+
+export default {
+  Query: {
+    me: (parent, args, { UserModel, user }) => {
+      if (user) {
+        return UserModel.findById(user._id);
+      }
+      return null;
+    },
+  },
+
+  Mutation: {
+    signUp: async (parent, { deviceHashEncrypted }, { UserModel }) => {
+      const rsa = new RSAKey();
+
+      rsa.setPrivateString(process.env.SECRET_KEY);
+      const deviceHash = rsa.decrypt(deviceHashEncrypted);
+      if (!deviceHash) {
+        throw new Error('invalid deviceHash');
+      }
+      let user;
+      user = await UserModel.findOne({ deviceHash });
+      if (!user) {
+        user = await UserModel.create({ deviceHash });
+      }
+
+      return { token: user.createToken() };
+    },
+
+    signIn: async (parent, { deviceHashEncrypted }, { UserModel }) => {
+      const user = await UserModel.findOne({ deviceHashEncrypted });
+      if (!user) {
+        throw new Error('User does not exsit!');
+      }
+
+      return { token: user.createToken() };
+    },
+  },
+};

src/graphql/schemas/Activity.js

@@ -0,0 +1,15 @@
+export default `
+
+type ActivityIndex {
+  activityIndex: Int
+  active: Boolean
+}
+
+type Query {
+  activityIndex(procedureId: String!): ActivityIndex
+}
+ 
+type Mutation {
+  increaseActivity(procedureId: String!): ActivityIndex
+}
+`;

src/graphql/schemas/Procedure.js

@@ -8,7 +8,7 @@ enum ProcedureType {
 type Procedure {
   _id: ID!
   title: String!
-  procedureId: String
+  procedureId: String!
   type: String
   period: Int
   currentStatus: String
@@ -17,6 +17,7 @@ type Procedure {
   voteDate: Date
   subjectGroups: [String]
   submissionDate: Date
+  activityIndex: ActivityIndex
   importantDocuments: [Document]
 }
 

src/graphql/schemas/User.js

@@ -0,0 +1,19 @@
+export default `
+  type User {
+    _id: String!
+    deviceHash: String!
+  }
+  
+  type Auth {
+    token: String!
+  }
+  
+  type Mutation {
+    signUp(deviceHashEncrypted: String!): Auth
+    signIn(deviceHashEncrypted: String!): Auth
+  }
+  
+  type Query {
+    me: User
+  }
+  `;