Running prettier

src/api/user/account.ts

@@ -4,13 +4,16 @@ import { GetUserMiddleware } from "../middlewares/user";
 import LoginToken, { CheckToken } from "../../models/login_token";
 import RequestError, { HttpStatusCode } from "../../helper/request_error";
 
-export const GetAccount = Stacker(GetUserMiddleware(true, true), async (req: Request, res: Response) => {
-   let user = {
-      id: req.user.uid,
-      name: req.user.name,
-      username: req.user.username,
-      birthday: req.user.birthday,
-      gender: req.user.gender,
-   };
-   res.json({ user });
-});
+export const GetAccount = Stacker(
+   GetUserMiddleware(true, true),
+   async (req: Request, res: Response) => {
+      let user = {
+         id: req.user.uid,
+         name: req.user.name,
+         username: req.user.username,
+         birthday: req.user.birthday,
+         gender: req.user.gender,
+      };
+      res.json({ user });
+   }
+);

src/api/user/contact.ts

@@ -3,14 +3,17 @@ import Stacker from "../middlewares/stacker";
 import { GetUserMiddleware } from "../middlewares/user";
 import Mail from "../../models/mail";
 
-export const GetContactInfos = Stacker(GetUserMiddleware(true, true), async (req: Request, res: Response) => {
-   let mails = await Promise.all(
-      req.user.mails.map(mail => Mail.findById(mail))
-   );
+export const GetContactInfos = Stacker(
+   GetUserMiddleware(true, true),
+   async (req: Request, res: Response) => {
+      let mails = await Promise.all(
+         req.user.mails.map((mail) => Mail.findById(mail))
+      );
 
-   let contact = {
-      mails: mails.filter(e => !!e),
-      phones: req.user.phones
-   };
-   res.json({ contact });
-});
+      let contact = {
+         mails: mails.filter((e) => !!e),
+         phones: req.user.phones,
+      };
+      res.json({ contact });
+   }
+);

src/api/user/index.ts

@@ -41,20 +41,20 @@ UserRoute.post("/register", Register);
 /**
  * @api {post} /user/login?type=:type
  * @apiName UserLogin
- * 
+ *
  * @apiParam {String} type Type could be either "username" or "password"
- * 
+ *
  * @apiGroup user
  * @apiPermission none
- * 
+ *
  * @apiParam  {String} username Username (either username or uid required)
  * @apiParam  {String} uid (either username or uid required)
  * @apiParam  {String} password Password hashed and salted like specification (only on type password)
  * @apiParam  {Number} time in milliseconds used to hash password. This is used to make passwords "expire"
- * 
+ *
  * @apiSuccess {String} uid On type = "username"
  * @apiSuccess {String} salt On type = "username"
- * 
+ *
  * @apiSuccess {String} login On type = "password". Login Token
  * @apiSuccess {String} special On type = "password". Special Token
  * @apiSuccess {Object[]} tfa Will be set when TwoFactorAuthentication is required
@@ -62,16 +62,16 @@ UserRoute.post("/register", Register);
  * @apiSuccess {String} tfa.name The name of the TFA Method
  * @apiSuccess {String} tfa.type The type of the TFA Method
  */
-UserRoute.post("/login", Login)
+UserRoute.post("/login", Login);
 UserRoute.use("/twofactor", TwoFactorRoute);
 
 /**
  * @api {get} /user/token
  * @apiName UserGetToken
- * 
+ *
  * @apiGroup user
  * @apiPermission user
- * 
+ *
  * @apiSuccess {Object[]} token
  * @apiSuccess {String} token.id The Token ID
  * @apiSuccess {String} token.special Identifies Special Token
@@ -84,25 +84,24 @@ UserRoute.get("/token", GetToken);
 /**
  * @api {delete} /user/token/:id
  * @apiParam {String} id The id of the token to be deleted
- * 
+ *
  * @apiName UserDeleteToken
- * 
- * 
+ *
+ *
  * @apiGroup user
  * @apiPermission user
- * 
+ *
  * @apiSuccess {Boolean} success
  */
 UserRoute.delete("/token/:id", DeleteToken);
 
-
 /**
  * @api {delete} /user/account
  * @apiName UserGetAccount
- * 
+ *
  * @apiGroup user
  * @apiPermission user
- * 
+ *
  * @apiSuccess {Boolean} success
  * @apiSuccess {Object[]} user
  * @apiSuccess {String} user.id User ID
@@ -126,4 +125,4 @@ UserRoute.get("/account", GetAccount);
  * @apiSuccess {Object[]} user.phone Phone numbers
  */
 UserRoute.get("/contact", GetContactInfos);
-export default UserRoute;
+export default UserRoute;

src/api/user/login.ts

@@ -1,4 +1,4 @@
-import { Request, Response } from "express"
+import { Request, Response } from "express";
 import User, { IUser } from "../../models/user";
 import { randomBytes } from "crypto";
 import moment = require("moment");
@@ -12,36 +12,39 @@ const Login = promiseMiddleware(async (req: Request, res: Response) => {
    let type = req.query.type;
    if (type === "username") {
       let { username, uid } = req.query;
-      let user = await User.findOne(username ? { username: username.toLowerCase() } : { uid: uid });
+      let user = await User.findOne(
+         username ? { username: username.toLowerCase() } : { uid: uid }
+      );
       if (!user) {
-         res.json({ error: req.__("User not found") })
+         res.json({ error: req.__("User not found") });
       } else {
          res.json({ salt: user.salt, uid: user.uid });
       }
       return;
    } else if (type === "password") {
       const sendToken = async (user: IUser, tfa?: any[]) => {
-         let ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress
+         let ip =
+            req.headers["x-forwarded-for"] || req.connection.remoteAddress;
          let client = {
             ip: Array.isArray(ip) ? ip[0] : ip,
-            browser: req.headers["user-agent"]
-         }
+            browser: req.headers["user-agent"],
+         };
 
          let token_str = randomBytes(16).toString("hex");
-         let tfa_exp = moment().add(5, "minutes").toDate()
-         let token_exp = moment().add(6, "months").toDate()
+         let tfa_exp = moment().add(5, "minutes").toDate();
+         let token_exp = moment().add(6, "months").toDate();
          let token = LoginToken.new({
             token: token_str,
             valid: true,
             validTill: tfa ? tfa_exp : token_exp,
             user: user._id,
             validated: tfa ? false : true,
-            ...client
+            ...client,
          });
          await LoginToken.save(token);
 
          let special_str = randomBytes(24).toString("hex");
-         let special_exp = moment().add(30, "minutes").toDate()
+         let special_exp = moment().add(30, "minutes").toDate();
          let special = LoginToken.new({
             token: special_str,
             valid: true,
@@ -49,50 +52,74 @@ const Login = promiseMiddleware(async (req: Request, res: Response) => {
             special: true,
             user: user._id,
             validated: tfa ? false : true,
-            ...client
+            ...client,
          });
          await LoginToken.save(special);
 
          res.json({
             login: { token: token_str, expires: token.validTill.toUTCString() },
-            special: { token: special_str, expires: special.validTill.toUTCString() },
-            tfa
+            special: {
+               token: special_str,
+               expires: special.validTill.toUTCString(),
+            },
+            tfa,
          });
-      }
+      };
 
       let { username, password, uid, date } = req.body;
 
-      let user = await User.findOne(username ? { username: username.toLowerCase() } : { uid: uid })
+      let user = await User.findOne(
+         username ? { username: username.toLowerCase() } : { uid: uid }
+      );
       if (!user) {
-         res.json({ error: req.__("User not found") })
+         res.json({ error: req.__("User not found") });
       } else {
          let upw = user.password;
          if (date) {
-            if (!moment(date).isBetween(moment().subtract(1, "minute"), moment().add(1, "minute"))) {
-               res.json({ error: req.__("Invalid timestamp. Please check your devices time!") });
+            if (
+               !moment(date).isBetween(
+                  moment().subtract(1, "minute"),
+                  moment().add(1, "minute")
+               )
+            ) {
+               res.json({
+                  error: req.__(
+                     "Invalid timestamp. Please check your devices time!"
+                  ),
+               });
                return;
             } else {
-               upw = crypto.createHash("sha512").update(upw + date.toString()).digest("hex");
+               upw = crypto
+                  .createHash("sha512")
+                  .update(upw + date.toString())
+                  .digest("hex");
             }
          }
          if (upw !== password) {
-            res.json({ error: req.__("Password or username wrong") })
+            res.json({ error: req.__("Password or username wrong") });
          } else {
-            let twofactor = await TwoFactor.find({ user: user._id, valid: true })
-            let expired = twofactor.filter(e => e.expires ? moment().isAfter(moment(e.expires)) : false)
-            await Promise.all(expired.map(e => {
-               e.valid = false;
-               return TwoFactor.save(e);
-            }));
-            twofactor = twofactor.filter(e => e.valid);
+            let twofactor = await TwoFactor.find({
+               user: user._id,
+               valid: true,
+            });
+            let expired = twofactor.filter((e) =>
+               e.expires ? moment().isAfter(moment(e.expires)) : false
+            );
+            await Promise.all(
+               expired.map((e) => {
+                  e.valid = false;
+                  return TwoFactor.save(e);
+               })
+            );
+            twofactor = twofactor.filter((e) => e.valid);
             if (twofactor && twofactor.length > 0) {
-               let tfa = twofactor.map(e => {
+               let tfa = twofactor.map((e) => {
                   return {
                      id: e._id,
                      name: e.name || TFANames.get(e.type),
-                     type: e.type
-                  }
-               })
+                     type: e.type,
+                  };
+               });
                await sendToken(user, tfa);
             } else {
                await sendToken(user);
@@ -104,4 +131,4 @@ const Login = promiseMiddleware(async (req: Request, res: Response) => {
    }
 });
 
-export default Login;
+export default Login;

src/api/user/register.ts

@@ -1,4 +1,4 @@
-import { Request, Response, Router } from "express"
+import { Request, Response, Router } from "express";
 import Stacker from "../middlewares/stacker";
 import verify, { Types } from "../middlewares/verify";
 import promiseMiddleware from "../../helper/promiseMiddleware";
@@ -7,138 +7,149 @@ import { HttpStatusCode } from "../../helper/request_error";
 import Mail from "../../models/mail";
 import RegCode from "../../models/regcodes";
 
-const Register = Stacker(verify({
-   mail: {
-      type: Types.EMAIL,
-      notempty: true
-   },
-   username: {
-      type: Types.STRING,
-      notempty: true
-   },
-   password: {
-      type: Types.STRING,
-      notempty: true
-   },
-   salt: {
-      type: Types.STRING,
-      notempty: true
-   },
-   regcode: {
-      type: Types.STRING,
-      notempty: true
-   },
-   gender: {
-      type: Types.STRING,
-      notempty: true
-   },
-   name: {
-      type: Types.STRING,
-      notempty: true
-   },
-   // birthday: {
-   //    type: Types.DATE
-   // }
-}), promiseMiddleware(async (req: Request, res: Response) => {
-   let { username, password, salt, mail, gender, name, birthday, regcode } = req.body;
-   let u = await User.findOne({ username: username.toLowerCase() })
-   if (u) {
-      let err = {
-         message: [
-            {
-               message: req.__("Username taken"),
-               field: "username"
-            }
-         ],
-         status: HttpStatusCode.BAD_REQUEST,
-         nolog: true
+const Register = Stacker(
+   verify({
+      mail: {
+         type: Types.EMAIL,
+         notempty: true,
+      },
+      username: {
+         type: Types.STRING,
+         notempty: true,
+      },
+      password: {
+         type: Types.STRING,
+         notempty: true,
+      },
+      salt: {
+         type: Types.STRING,
+         notempty: true,
+      },
+      regcode: {
+         type: Types.STRING,
+         notempty: true,
+      },
+      gender: {
+         type: Types.STRING,
+         notempty: true,
+      },
+      name: {
+         type: Types.STRING,
+         notempty: true,
+      },
+      // birthday: {
+      //    type: Types.DATE
+      // }
+   }),
+   promiseMiddleware(async (req: Request, res: Response) => {
+      let {
+         username,
+         password,
+         salt,
+         mail,
+         gender,
+         name,
+         birthday,
+         regcode,
+      } = req.body;
+      let u = await User.findOne({ username: username.toLowerCase() });
+      if (u) {
+         let err = {
+            message: [
+               {
+                  message: req.__("Username taken"),
+                  field: "username",
+               },
+            ],
+            status: HttpStatusCode.BAD_REQUEST,
+            nolog: true,
+         };
+         throw err;
       }
-      throw err;
-   }
 
-
-   let m = await Mail.findOne({ mail: mail })
-   if (m) {
-      let err = {
-         message: [
-            {
-               message: req.__("Mail linked with other account"),
-               field: "mail"
-            }
-         ],
-         status: HttpStatusCode.BAD_REQUEST,
-         nolog: true
+      let m = await Mail.findOne({ mail: mail });
+      if (m) {
+         let err = {
+            message: [
+               {
+                  message: req.__("Mail linked with other account"),
+                  field: "mail",
+               },
+            ],
+            status: HttpStatusCode.BAD_REQUEST,
+            nolog: true,
+         };
+         throw err;
       }
-      throw err;
-   }
 
-   let regc = await RegCode.findOne({ token: regcode })
-   if (!regc) {
-      let err = {
-         message: [
-            {
-               message: req.__("Invalid registration code"),
-               field: "regcode"
-            }
-         ],
-         status: HttpStatusCode.BAD_REQUEST,
-         nolog: true
+      let regc = await RegCode.findOne({ token: regcode });
+      if (!regc) {
+         let err = {
+            message: [
+               {
+                  message: req.__("Invalid registration code"),
+                  field: "regcode",
+               },
+            ],
+            status: HttpStatusCode.BAD_REQUEST,
+            nolog: true,
+         };
+         throw err;
       }
-      throw err;
-   }
 
-   if (!regc.valid) {
-      let err = {
-         message: [
-            {
-               message: req.__("Registration code already used"),
-               field: "regcode"
-            }
-         ],
-         status: HttpStatusCode.BAD_REQUEST,
-         nolog: true
+      if (!regc.valid) {
+         let err = {
+            message: [
+               {
+                  message: req.__("Registration code already used"),
+                  field: "regcode",
+               },
+            ],
+            status: HttpStatusCode.BAD_REQUEST,
+            nolog: true,
+         };
+         throw err;
       }
-      throw err;
-   }
 
-   let g = -1;
-   switch (gender) {
-      case "male":
-         g = Gender.male
-         break;
-      case "female":
-         g = Gender.female
-         break;
-      case "other":
-         g = Gender.other
-         break;
-      default:
-         g = Gender.none
-         break;
-   }
+      let g = -1;
+      switch (gender) {
+         case "male":
+            g = Gender.male;
+            break;
+         case "female":
+            g = Gender.female;
+            break;
+         case "other":
+            g = Gender.other;
+            break;
+         default:
+            g = Gender.none;
+            break;
+      }
 
-   let user = User.new({
-      username: username.toLowerCase(),
-      password: password,
-      salt: salt,
-      gender: g,
-      name: name,
-      // birthday: birthday,
-      admin: false
+      let user = User.new({
+         username: username.toLowerCase(),
+         password: password,
+         salt: salt,
+         gender: g,
+         name: name,
+         // birthday: birthday,
+         admin: false,
+      });
+
+      regc.valid = false;
+      await RegCode.save(regc);
+
+      let ml = Mail.new({
+         mail: mail,
+         primary: true,
+      });
+
+      await Mail.save(ml);
+
+      user.mails.push(ml._id);
+      await User.save(user);
+      res.json({ success: true });
    })
-
-   regc.valid = false;
-   await RegCode.save(regc);
-
-   let ml = Mail.new({
-      mail: mail,
-      primary: true
-   })
-
-   await Mail.save(ml);
-
-   user.mails.push(ml._id);
-   await User.save(user)
-   res.json({ success: true });
-}))
-export default Register;
+);
+export default Register;

src/api/user/token.ts

@@ -4,26 +4,42 @@ import { GetUserMiddleware } from "../middlewares/user";
 import LoginToken, { CheckToken } from "../../models/login_token";
 import RequestError, { HttpStatusCode } from "../../helper/request_error";
 
-export const GetToken = Stacker(GetUserMiddleware(true, true), async (req: Request, res: Response) => {
-   let raw_token = await LoginToken.find({ user: req.user._id, valid: true });
-   let token = await Promise.all(raw_token.map(async token => {
-      await CheckToken(token);
-      return {
-         id: token._id,
-         special: token.special,
-         ip: token.ip,
-         browser: token.browser,
-         isthis: token._id.equals(token.special ? req.token.special._id : req.token.login._id)
-      }
-   }).filter(t => t !== undefined));
-   res.json({ token });
-});
+export const GetToken = Stacker(
+   GetUserMiddleware(true, true),
+   async (req: Request, res: Response) => {
+      let raw_token = await LoginToken.find({
+         user: req.user._id,
+         valid: true,
+      });
+      let token = await Promise.all(
+         raw_token
+            .map(async (token) => {
+               await CheckToken(token);
+               return {
+                  id: token._id,
+                  special: token.special,
+                  ip: token.ip,
+                  browser: token.browser,
+                  isthis: token._id.equals(
+                     token.special ? req.token.special._id : req.token.login._id
+                  ),
+               };
+            })
+            .filter((t) => t !== undefined)
+      );
+      res.json({ token });
+   }
+);
 
-export const DeleteToken = Stacker(GetUserMiddleware(true, true), async (req: Request, res: Response) => {
-   let { id } = req.params;
-   let token = await LoginToken.findById(id);
-   if (!token || !token.user.equals(req.user._id)) throw new RequestError("Invalid ID", HttpStatusCode.BAD_REQUEST);
-   token.valid = false;
-   await LoginToken.save(token);
-   res.json({ success: true });
-});
+export const DeleteToken = Stacker(
+   GetUserMiddleware(true, true),
+   async (req: Request, res: Response) => {
+      let { id } = req.params;
+      let token = await LoginToken.findById(id);
+      if (!token || !token.user.equals(req.user._id))
+         throw new RequestError("Invalid ID", HttpStatusCode.BAD_REQUEST);
+      token.valid = false;
+      await LoginToken.save(token);
+      res.json({ success: true });
+   }
+);

src/api/user/twofactor/backup/index.ts

@@ -1,7 +1,10 @@
-import { Router } from "express"
+import { Router } from "express";
 import Stacker from "../../../middlewares/stacker";
 import { GetUserMiddleware } from "../../../middlewares/user";
-import TwoFactor, { TFATypes as TwoFATypes, IBackupCode } from "../../../../models/twofactor";
+import TwoFactor, {
+   TFATypes as TwoFATypes,
+   IBackupCode,
+} from "../../../../models/twofactor";
 import RequestError, { HttpStatusCode } from "../../../../helper/request_error";
 import moment = require("moment");
 import { upgradeToken } from "../helper";
@@ -15,60 +18,83 @@ function generateCode(length: number) {
    let bytes = crypto.randomBytes(length);
    let nrs = "";
    bytes.forEach((b, idx) => {
-      let nr = Math.floor((b / 255) * 9.9999)
+      let nr = Math.floor((b / 255) * 9.9999);
       if (nr > 9) nr = 9;
       nrs += String(nr);
-   })
+   });
    return nrs;
 }
 
-BackupCodeRoute.post("/", Stacker(GetUserMiddleware(true, true), async (req, res) => {
-   //Generating new 
-   let codes = Array(10).map(() => generateCode(8));
-   console.log(codes);
-   let twofactor = TwoFactor.new(<IBackupCode>{
-      user: req.user._id,
-      type: TwoFATypes.OTC,
-      valid: true,
-      data: codes,
-      name: ""
-   })
-   await TwoFactor.save(twofactor);
-   res.json({
-      codes,
-      id: twofactor._id
-   })
-}));
-
-BackupCodeRoute.put("/", Stacker(GetUserMiddleware(true, false, undefined, false), async (req, res) => {
-   let { login, special } = req.token;
-   let { id, code }: { id: string, code: string } = req.body;
-
-   let twofactor: IBackupCode = await TwoFactor.findById(id);
-
-   if (!twofactor || !twofactor.valid || !twofactor.user.equals(req.user._id) || twofactor.type !== TwoFATypes.OTC) {
-      throw new RequestError("Invalid Method!", HttpStatusCode.BAD_REQUEST);
-   }
-
-   if (twofactor.expires && moment().isAfter(twofactor.expires)) {
-      twofactor.valid = false;
+BackupCodeRoute.post(
+   "/",
+   Stacker(GetUserMiddleware(true, true), async (req, res) => {
+      //Generating new
+      let codes = Array(10).map(() => generateCode(8));
+      console.log(codes);
+      let twofactor = TwoFactor.new(<IBackupCode>{
+         user: req.user._id,
+         type: TwoFATypes.OTC,
+         valid: true,
+         data: codes,
+         name: "",
+      });
       await TwoFactor.save(twofactor);
-      throw new RequestError("Invalid Method!", HttpStatusCode.BAD_REQUEST);
-   }
-   code = code.replace(/\s/g, "");
-   let valid = twofactor.data.find(c => c === code);
+      res.json({
+         codes,
+         id: twofactor._id,
+      });
+   })
+);
 
-   if (valid) {
-      twofactor.data = twofactor.data.filter(c => c !== code);
-      await TwoFactor.save(twofactor);
-      let [login_exp, special_exp] = await Promise.all([
-         upgradeToken(login),
-         upgradeToken(special)
-      ]);
-      res.json({ success: true, login_exp, special_exp })
-   } else {
-      throw new RequestError("Invalid or already used code!", HttpStatusCode.BAD_REQUEST);
-   }
-}))
+BackupCodeRoute.put(
+   "/",
+   Stacker(
+      GetUserMiddleware(true, false, undefined, false),
+      async (req, res) => {
+         let { login, special } = req.token;
+         let { id, code }: { id: string; code: string } = req.body;
+
+         let twofactor: IBackupCode = await TwoFactor.findById(id);
+
+         if (
+            !twofactor ||
+            !twofactor.valid ||
+            !twofactor.user.equals(req.user._id) ||
+            twofactor.type !== TwoFATypes.OTC
+         ) {
+            throw new RequestError(
+               "Invalid Method!",
+               HttpStatusCode.BAD_REQUEST
+            );
+         }
+
+         if (twofactor.expires && moment().isAfter(twofactor.expires)) {
+            twofactor.valid = false;
+            await TwoFactor.save(twofactor);
+            throw new RequestError(
+               "Invalid Method!",
+               HttpStatusCode.BAD_REQUEST
+            );
+         }
+         code = code.replace(/\s/g, "");
+         let valid = twofactor.data.find((c) => c === code);
+
+         if (valid) {
+            twofactor.data = twofactor.data.filter((c) => c !== code);
+            await TwoFactor.save(twofactor);
+            let [login_exp, special_exp] = await Promise.all([
+               upgradeToken(login),
+               upgradeToken(special),
+            ]);
+            res.json({ success: true, login_exp, special_exp });
+         } else {
+            throw new RequestError(
+               "Invalid or already used code!",
+               HttpStatusCode.BAD_REQUEST
+            );
+         }
+      }
+   )
+);
 
 export default BackupCodeRoute;

src/api/user/twofactor/helper.ts

@@ -6,8 +6,11 @@ export async function upgradeToken(token: ILoginToken) {
    token.valid = true;
    token.validated = true;
    //TODO durations from config
-   let expires = (token.special ? moment().add(30, "minute") : moment().add(6, "months")).toDate();
+   let expires = (token.special
+      ? moment().add(30, "minute")
+      : moment().add(6, "months")
+   ).toDate();
    token.validTill = expires;
    await LoginToken.save(token);
    return expires;
-}
+}

src/api/user/twofactor/index.ts

@@ -3,44 +3,54 @@ import YubiKeyRoute from "./yubikey";
 import { GetUserMiddleware } from "../../middlewares/user";
 import Stacker from "../../middlewares/stacker";
 import TwoFactor from "../../../models/twofactor";
-import * as moment from "moment"
+import * as moment from "moment";
 import RequestError, { HttpStatusCode } from "../../../helper/request_error";
 import OTCRoute from "./otc";
 import BackupCodeRoute from "./backup";
 
 const TwoFactorRouter = Router();
 
-TwoFactorRouter.get("/", Stacker(GetUserMiddleware(true, true), async (req, res) => {
-   let twofactor = await TwoFactor.find({ user: req.user._id, valid: true })
-   let expired = twofactor.filter(e => e.expires ? moment().isAfter(moment(e.expires)) : false)
-   await Promise.all(expired.map(e => {
-      e.valid = false;
-      return TwoFactor.save(e);
-   }));
-   twofactor = twofactor.filter(e => e.valid);
-   let tfa = twofactor.map(e => {
-      return {
-         id: e._id,
-         name: e.name,
-         type: e.type
-      }
+TwoFactorRouter.get(
+   "/",
+   Stacker(GetUserMiddleware(true, true), async (req, res) => {
+      let twofactor = await TwoFactor.find({ user: req.user._id, valid: true });
+      let expired = twofactor.filter((e) =>
+         e.expires ? moment().isAfter(moment(e.expires)) : false
+      );
+      await Promise.all(
+         expired.map((e) => {
+            e.valid = false;
+            return TwoFactor.save(e);
+         })
+      );
+      twofactor = twofactor.filter((e) => e.valid);
+      let tfa = twofactor.map((e) => {
+         return {
+            id: e._id,
+            name: e.name,
+            type: e.type,
+         };
+      });
+      res.json({ methods: tfa });
    })
-   res.json({ methods: tfa });
-}));
+);
 
-TwoFactorRouter.delete("/:id", Stacker(GetUserMiddleware(true, true), async (req, res) => {
-   let { id } = req.params;
-   let tfa = await TwoFactor.findById(id);
-   if (!tfa || !tfa.user.equals(req.user._id)) {
-      throw new RequestError("Invalid id", HttpStatusCode.BAD_REQUEST);
-   }
-   tfa.valid = false;
-   await TwoFactor.save(tfa);
-   res.json({ success: true });
-}));
+TwoFactorRouter.delete(
+   "/:id",
+   Stacker(GetUserMiddleware(true, true), async (req, res) => {
+      let { id } = req.params;
+      let tfa = await TwoFactor.findById(id);
+      if (!tfa || !tfa.user.equals(req.user._id)) {
+         throw new RequestError("Invalid id", HttpStatusCode.BAD_REQUEST);
+      }
+      tfa.valid = false;
+      await TwoFactor.save(tfa);
+      res.json({ success: true });
+   })
+);
 
 TwoFactorRouter.use("/yubikey", YubiKeyRoute);
 TwoFactorRouter.use("/otc", OTCRoute);
 TwoFactorRouter.use("/backup", BackupCodeRoute);
 
-export default TwoFactorRouter;
+export default TwoFactorRouter;

src/api/user/twofactor/otc/index.ts

@@ -1,7 +1,10 @@
-import { Router } from "express"
+import { Router } from "express";
 import Stacker from "../../../middlewares/stacker";
 import { GetUserMiddleware } from "../../../middlewares/user";
-import TwoFactor, { TFATypes as TwoFATypes, IOTC } from "../../../../models/twofactor";
+import TwoFactor, {
+   TFATypes as TwoFATypes,
+   IOTC,
+} from "../../../../models/twofactor";
 import RequestError, { HttpStatusCode } from "../../../../helper/request_error";
 import moment = require("moment");
 import { upgradeToken } from "../helper";
@@ -13,93 +16,120 @@ import config from "../../../../config";
 
 const OTCRoute = Router();
 
-OTCRoute.post("/", Stacker(GetUserMiddleware(true, true), async (req, res) => {
-   const { type } = req.query;
-   if (type === "create") {
-      //Generating new 
-      let secret = speakeasy.generateSecret({
-         name: config.core.name,
-         issuer: config.core.name
-      });
-      let twofactor = TwoFactor.new(<IOTC>{
-         user: req.user._id,
-         type: TwoFATypes.OTC,
-         valid: false,
-         data: secret.base32
-      })
-      let dataurl = await qrcode.toDataURL(secret.otpauth_url);
-      await TwoFactor.save(twofactor);
-      res.json({
-         image: dataurl,
-         id: twofactor._id
-      })
-   } else if (type === "validate") {
-      // Checking code and marking as valid
-      const { code, id } = req.body;
-      Logging.debug(req.body, id);
-      let twofactor: IOTC = await TwoFactor.findById(id);
-      const err = () => { throw new RequestError("Invalid ID!", HttpStatusCode.BAD_REQUEST) };
-      if (!twofactor || !twofactor.user.equals(req.user._id) || twofactor.type !== TwoFATypes.OTC || !twofactor.data || twofactor.valid) {
-         Logging.debug("Not found or wrong user", twofactor);
-         err();
-      }
-
-      if (twofactor.expires && moment().isAfter(moment(twofactor.expires))) {
-         await TwoFactor.delete(twofactor);
-         Logging.debug("Expired!", twofactor);
-         err();
-      }
-
-      let valid = speakeasy.totp.verify({
-         secret: twofactor.data,
-         encoding: "base32",
-         token: code
-      })
-
-      if (valid) {
-         twofactor.expires = undefined;
-         twofactor.valid = true;
+OTCRoute.post(
+   "/",
+   Stacker(GetUserMiddleware(true, true), async (req, res) => {
+      const { type } = req.query;
+      if (type === "create") {
+         //Generating new
+         let secret = speakeasy.generateSecret({
+            name: config.core.name,
+            issuer: config.core.name,
+         });
+         let twofactor = TwoFactor.new(<IOTC>{
+            user: req.user._id,
+            type: TwoFATypes.OTC,
+            valid: false,
+            data: secret.base32,
+         });
+         let dataurl = await qrcode.toDataURL(secret.otpauth_url);
          await TwoFactor.save(twofactor);
-         res.json({ success: true });
+         res.json({
+            image: dataurl,
+            id: twofactor._id,
+         });
+      } else if (type === "validate") {
+         // Checking code and marking as valid
+         const { code, id } = req.body;
+         Logging.debug(req.body, id);
+         let twofactor: IOTC = await TwoFactor.findById(id);
+         const err = () => {
+            throw new RequestError("Invalid ID!", HttpStatusCode.BAD_REQUEST);
+         };
+         if (
+            !twofactor ||
+            !twofactor.user.equals(req.user._id) ||
+            twofactor.type !== TwoFATypes.OTC ||
+            !twofactor.data ||
+            twofactor.valid
+         ) {
+            Logging.debug("Not found or wrong user", twofactor);
+            err();
+         }
+
+         if (twofactor.expires && moment().isAfter(moment(twofactor.expires))) {
+            await TwoFactor.delete(twofactor);
+            Logging.debug("Expired!", twofactor);
+            err();
+         }
+
+         let valid = speakeasy.totp.verify({
+            secret: twofactor.data,
+            encoding: "base32",
+            token: code,
+         });
+
+         if (valid) {
+            twofactor.expires = undefined;
+            twofactor.valid = true;
+            await TwoFactor.save(twofactor);
+            res.json({ success: true });
+         } else {
+            throw new RequestError("Invalid Code!", HttpStatusCode.BAD_REQUEST);
+         }
       } else {
-         throw new RequestError("Invalid Code!", HttpStatusCode.BAD_REQUEST);
+         throw new RequestError("Invalid type", HttpStatusCode.BAD_REQUEST);
       }
-   } else {
-      throw new RequestError("Invalid type", HttpStatusCode.BAD_REQUEST);
-   }
-}));
-
-OTCRoute.put("/", Stacker(GetUserMiddleware(true, false, undefined, false), async (req, res) => {
-   let { login, special } = req.token;
-   let { id, code } = req.body;
-   let twofactor: IOTC = await TwoFactor.findById(id);
-
-   if (!twofactor || !twofactor.valid || !twofactor.user.equals(req.user._id) || twofactor.type !== TwoFATypes.OTC) {
-      throw new RequestError("Invalid Method!", HttpStatusCode.BAD_REQUEST);
-   }
-
-   if (twofactor.expires && moment().isAfter(twofactor.expires)) {
-      twofactor.valid = false;
-      await TwoFactor.save(twofactor);
-      throw new RequestError("Invalid Method!", HttpStatusCode.BAD_REQUEST);
-   }
-
-
-   let valid = speakeasy.totp.verify({
-      secret: twofactor.data,
-      encoding: "base32",
-      token: code
    })
+);
 
-   if (valid) {
-      let [login_exp, special_exp] = await Promise.all([
-         upgradeToken(login),
-         upgradeToken(special)
-      ]);
-      res.json({ success: true, login_exp, special_exp })
-   } else {
-      throw new RequestError("Invalid Code", HttpStatusCode.BAD_REQUEST);
-   }
-}))
+OTCRoute.put(
+   "/",
+   Stacker(
+      GetUserMiddleware(true, false, undefined, false),
+      async (req, res) => {
+         let { login, special } = req.token;
+         let { id, code } = req.body;
+         let twofactor: IOTC = await TwoFactor.findById(id);
+
+         if (
+            !twofactor ||
+            !twofactor.valid ||
+            !twofactor.user.equals(req.user._id) ||
+            twofactor.type !== TwoFATypes.OTC
+         ) {
+            throw new RequestError(
+               "Invalid Method!",
+               HttpStatusCode.BAD_REQUEST
+            );
+         }
+
+         if (twofactor.expires && moment().isAfter(twofactor.expires)) {
+            twofactor.valid = false;
+            await TwoFactor.save(twofactor);
+            throw new RequestError(
+               "Invalid Method!",
+               HttpStatusCode.BAD_REQUEST
+            );
+         }
+
+         let valid = speakeasy.totp.verify({
+            secret: twofactor.data,
+            encoding: "base32",
+            token: code,
+         });
+
+         if (valid) {
+            let [login_exp, special_exp] = await Promise.all([
+               upgradeToken(login),
+               upgradeToken(special),
+            ]);
+            res.json({ success: true, login_exp, special_exp });
+         } else {
+            throw new RequestError("Invalid Code", HttpStatusCode.BAD_REQUEST);
+         }
+      }
+   )
+);
 
 export default OTCRoute;

src/api/user/twofactor/yubikey/index.ts

@@ -1,9 +1,12 @@
-import { Router, Request } from "express"
+import { Router, Request } from "express";
 import Stacker from "../../../middlewares/stacker";
 import { UserMiddleware, GetUserMiddleware } from "../../../middlewares/user";
 import * as u2f from "u2f";
 import config from "../../../../config";
-import TwoFactor, { TFATypes as TwoFATypes, IYubiKey } from "../../../../models/twofactor";
+import TwoFactor, {
+   TFATypes as TwoFATypes,
+   IYubiKey,
+} from "../../../../models/twofactor";
 import RequestError, { HttpStatusCode } from "../../../../helper/request_error";
 import moment = require("moment");
 import LoginToken from "../../../../models/login_token";
@@ -15,120 +18,189 @@ const U2FRoute = Router();
 /**
  * Registerinf a new YubiKey
  */
-U2FRoute.post("/", Stacker(GetUserMiddleware(true, true), async (req, res) => {
-   const { type } = req.query;
-   if (type === "challenge") {
-      const registrationRequest = u2f.request(config.core.url);
+U2FRoute.post(
+   "/",
+   Stacker(GetUserMiddleware(true, true), async (req, res) => {
+      const { type } = req.query;
+      if (type === "challenge") {
+         const registrationRequest = u2f.request(config.core.url);
 
-      let twofactor = TwoFactor.new(<IYubiKey>{
-         user: req.user._id,
-         type: TwoFATypes.U2F,
-         valid: false,
-         data: {
-            registration: registrationRequest
-         }
-      })
-      await TwoFactor.save(twofactor);
-      res.json({ request: registrationRequest, id: twofactor._id, appid: config.core.url });
-   } else {
-      const { response, id } = req.body;
-      Logging.debug(req.body, id);
-      let twofactor: IYubiKey = await TwoFactor.findById(id);
-      const err = () => { throw new RequestError("Invalid ID!", HttpStatusCode.BAD_REQUEST) };
-      if (!twofactor || !twofactor.user.equals(req.user._id) || twofactor.type !== TwoFATypes.U2F || !twofactor.data.registration || twofactor.valid) {
-         Logging.debug("Not found or wrong user", twofactor);
-         err();
-      }
-
-      if (twofactor.expires && moment().isAfter(moment(twofactor.expires))) {
-         await TwoFactor.delete(twofactor);
-         Logging.debug("Expired!", twofactor);
-         err();
-      }
-
-      const result = u2f.checkRegistration(twofactor.data.registration, response);
-
-      if (result.successful) {
-         twofactor.data = {
-            keyHandle: result.keyHandle,
-            publicKey: result.publicKey
-         }
-         twofactor.expires = undefined;
-         twofactor.valid = true;
+         let twofactor = TwoFactor.new(<IYubiKey>{
+            user: req.user._id,
+            type: TwoFATypes.U2F,
+            valid: false,
+            data: {
+               registration: registrationRequest,
+            },
+         });
          await TwoFactor.save(twofactor);
-         res.json({ success: true });
+         res.json({
+            request: registrationRequest,
+            id: twofactor._id,
+            appid: config.core.url,
+         });
       } else {
-         throw new RequestError(result.errorMessage, HttpStatusCode.BAD_REQUEST);
-      }
-   }
-}));
+         const { response, id } = req.body;
+         Logging.debug(req.body, id);
+         let twofactor: IYubiKey = await TwoFactor.findById(id);
+         const err = () => {
+            throw new RequestError("Invalid ID!", HttpStatusCode.BAD_REQUEST);
+         };
+         if (
+            !twofactor ||
+            !twofactor.user.equals(req.user._id) ||
+            twofactor.type !== TwoFATypes.U2F ||
+            !twofactor.data.registration ||
+            twofactor.valid
+         ) {
+            Logging.debug("Not found or wrong user", twofactor);
+            err();
+         }
 
-U2FRoute.get("/", Stacker(GetUserMiddleware(true, false, undefined, false), async (req, res) => {
-   let { login, special } = req.token;
-   let twofactor: IYubiKey = await TwoFactor.findOne({ user: req.user._id, type: TwoFATypes.U2F, valid: true })
+         if (twofactor.expires && moment().isAfter(moment(twofactor.expires))) {
+            await TwoFactor.delete(twofactor);
+            Logging.debug("Expired!", twofactor);
+            err();
+         }
 
-   if (!twofactor) {
-      throw new RequestError("Invalid Method!", HttpStatusCode.BAD_REQUEST);
-   }
+         const result = u2f.checkRegistration(
+            twofactor.data.registration,
+            response
+         );
 
-   if (twofactor.expires) {
-      if (moment().isAfter(twofactor.expires)) {
-         twofactor.valid = false;
-         await TwoFactor.save(twofactor);
-         throw new RequestError("Invalid Method!", HttpStatusCode.BAD_REQUEST);
-      }
-   }
-
-   let request = u2f.request(config.core.url, twofactor.data.keyHandle);
-   login.data = {
-      type: "ykr",
-      request
-   };
-   let r;;
-   if (special) {
-      special.data = login.data;
-      r = LoginToken.save(special);
-   }
-
-   await Promise.all([r, LoginToken.save(login)]);
-   res.json({ request });
-}))
-
-U2FRoute.put("/", Stacker(GetUserMiddleware(true, false, undefined, false), async (req, res) => {
-   let { login, special } = req.token;
-   let twofactor: IYubiKey = await TwoFactor.findOne({ user: req.user._id, type: TwoFATypes.U2F, valid: true })
-
-
-   let { response } = req.body;
-   if (!twofactor || !login.data || login.data.type !== "ykr" || special && (!special.data || special.data.type !== "ykr")) {
-      throw new RequestError("Invalid Method!", HttpStatusCode.BAD_REQUEST);
-   }
-
-   if (twofactor.expires && moment().isAfter(twofactor.expires)) {
-      twofactor.valid = false;
-      await TwoFactor.save(twofactor);
-      throw new RequestError("Invalid Method!", HttpStatusCode.BAD_REQUEST);
-   }
-
-   let login_exp;
-   let special_exp;
-   let result = u2f.checkSignature(login.data.request, response, twofactor.data.publicKey);
-   if (result.successful) {
-      if (special) {
-         let result = u2f.checkSignature(special.data.request, response, twofactor.data.publicKey);
          if (result.successful) {
-            special_exp = await upgradeToken(special);
-         }
-         else {
-            throw new RequestError(result.errorMessage, HttpStatusCode.BAD_REQUEST);
+            twofactor.data = {
+               keyHandle: result.keyHandle,
+               publicKey: result.publicKey,
+            };
+            twofactor.expires = undefined;
+            twofactor.valid = true;
+            await TwoFactor.save(twofactor);
+            res.json({ success: true });
+         } else {
+            throw new RequestError(
+               result.errorMessage,
+               HttpStatusCode.BAD_REQUEST
+            );
          }
       }
-      login_exp = await upgradeToken(login);
-   }
-   else {
-      throw new RequestError(result.errorMessage, HttpStatusCode.BAD_REQUEST);
-   }
-   res.json({ success: true, login_exp, special_exp })
-}))
+   })
+);
+
+U2FRoute.get(
+   "/",
+   Stacker(
+      GetUserMiddleware(true, false, undefined, false),
+      async (req, res) => {
+         let { login, special } = req.token;
+         let twofactor: IYubiKey = await TwoFactor.findOne({
+            user: req.user._id,
+            type: TwoFATypes.U2F,
+            valid: true,
+         });
+
+         if (!twofactor) {
+            throw new RequestError(
+               "Invalid Method!",
+               HttpStatusCode.BAD_REQUEST
+            );
+         }
+
+         if (twofactor.expires) {
+            if (moment().isAfter(twofactor.expires)) {
+               twofactor.valid = false;
+               await TwoFactor.save(twofactor);
+               throw new RequestError(
+                  "Invalid Method!",
+                  HttpStatusCode.BAD_REQUEST
+               );
+            }
+         }
+
+         let request = u2f.request(config.core.url, twofactor.data.keyHandle);
+         login.data = {
+            type: "ykr",
+            request,
+         };
+         let r;
+         if (special) {
+            special.data = login.data;
+            r = LoginToken.save(special);
+         }
+
+         await Promise.all([r, LoginToken.save(login)]);
+         res.json({ request });
+      }
+   )
+);
+
+U2FRoute.put(
+   "/",
+   Stacker(
+      GetUserMiddleware(true, false, undefined, false),
+      async (req, res) => {
+         let { login, special } = req.token;
+         let twofactor: IYubiKey = await TwoFactor.findOne({
+            user: req.user._id,
+            type: TwoFATypes.U2F,
+            valid: true,
+         });
+
+         let { response } = req.body;
+         if (
+            !twofactor ||
+            !login.data ||
+            login.data.type !== "ykr" ||
+            (special && (!special.data || special.data.type !== "ykr"))
+         ) {
+            throw new RequestError(
+               "Invalid Method!",
+               HttpStatusCode.BAD_REQUEST
+            );
+         }
+
+         if (twofactor.expires && moment().isAfter(twofactor.expires)) {
+            twofactor.valid = false;
+            await TwoFactor.save(twofactor);
+            throw new RequestError(
+               "Invalid Method!",
+               HttpStatusCode.BAD_REQUEST
+            );
+         }
+
+         let login_exp;
+         let special_exp;
+         let result = u2f.checkSignature(
+            login.data.request,
+            response,
+            twofactor.data.publicKey
+         );
+         if (result.successful) {
+            if (special) {
+               let result = u2f.checkSignature(
+                  special.data.request,
+                  response,
+                  twofactor.data.publicKey
+               );
+               if (result.successful) {
+                  special_exp = await upgradeToken(special);
+               } else {
+                  throw new RequestError(
+                     result.errorMessage,
+                     HttpStatusCode.BAD_REQUEST
+                  );
+               }
+            }
+            login_exp = await upgradeToken(login);
+         } else {
+            throw new RequestError(
+               result.errorMessage,
+               HttpStatusCode.BAD_REQUEST
+            );
+         }
+         res.json({ success: true, login_exp, special_exp });
+      }
+   )
+);
 
 export default U2FRoute;