@feardread/fear 1.2.1 → 2.0.1

package/routes/mail.js

@@ -1,170 +1,15 @@
-const smtp = require("../libs/emailer/smtp");
-const mailinfo = require("../libs/emailer/info");
-const Mail = new smtp(mailinfo);
 
-module.exports = ( fear ) => {
-    const router = fear.createRouter();
-
-    router.get('/', (req, res) => {
-        Mail.sendEmail()
-            .then((response) => res.send(response.message))
-            .catch((error) => res.status(500).send(error.message));
-    });
 
-    router.post('/contact', (req, res) => {
-        Mail.sendContactEmail(req.body)
-            .then((response) => res.json({ success: true, message: response.message }))
-            .catch((error) => res.status(500).json({ success: false, message: error.message }))
-    });
+module.exports = (fear) => {
+    const router = fear.createRouter();
+    const handler = fear.getHandler();
+    const mailer = fear.getMailer();
 
-    router.post("/project", (req, res) => {
-        Mail.sendProjectEmail(req.body)
-            .then((response) => res.json({ success: true, message: response.message }))
-            .catch((error) => res.status(500).json({ success: false, message: error.message }))
-    })
 
+    router.post("/send", handler.async(mailer.sendEmail))
+    router.post("/contact", handler.async(mailer.sendContactEmail))
+    router.post("/project", handler.async(mailer.sendProjectEmail))
+    router.post("/subscribe", handler.async(mailer.sendSubscriptionEmail))
+    router.post("/test", handler.async(mailer.sendTestEmail));
     return router;
-};
-
-/*
-router.get("/mailboxes", async (req, res) => {
-    const imapWorker = new imap.Worker(ServerInfo);
-    
-    await imapWorker.listMailboxes()
-        .then((response) => { return res.status(200).json(response); })
-        .catch((error) => { throw new Error(error); })
-);
-
-// REST Endpoint: List Messages
-router.get("/mailboxes/:mailbox", // specify the name of the mailbox to get messages for
-    async (inRequest: Request, inResponse: Response) => {
-        try {
-            const imapWorker: IMAP.Worker = new IMAP.Worker(serverInfo);
-            const messages: IMAP.IMessage[] = await imapWorker.listMessages({
-                mailbox: inRequest.params.mailbox // access dynamic value after /mailboxes/
-            });
-            inResponse.status(200);
-            inResponse.json(messages);
-        } catch (inError) {
-            inResponse.status(400);
-            inResponse.send("error");
-        }
-    }
-);
-
-// REST Endpoint: Get a Message
-router.get("/messages/:mailbox/:id",
-    async (inRequest: Request, inResponse: Response) => {
-        try {
-            const imapWorker: IMAP.Worker = new IMAP.Worker(serverInfo);
-            const messageBody: string = await imapWorker.getMessageBody({
-                mailbox: inRequest.params.mailbox, //  the name of the mailbox 
-                id: parseInt(inRequest.params.id, 10) // the ID of the message (str -> int)
-            });
-            inResponse.status(200);
-            inResponse.send(messageBody); // returned as plain text 
-        } catch (inError) {
-            inResponse.status(400);
-            inResponse.send("error");
-        }
-    }
-);
-
-// REST Endpoint: Delete a Message
-// the app.delete() method is used to register this endpoint.
-router.delete("/messages/:mailbox/:id",
-    async (inRequest: Request, inResponse: Response) => {
-        try {
-            const imapWorker: IMAP.Worker = new IMAP.Worker(serverInfo);
-            await imapWorker.deleteMessage({
-                mailbox: inRequest.params.mailbox,
-                id: parseInt(inRequest.params.id, 10)
-            });
-            inResponse.status(200);
-            inResponse.send("ok");
-        } catch (inError) {
-            inResponse.status(400);
-            inResponse.send("error");
-        }
-    }
-);
-
-// REST Endpoint: Send a Message
-// app.post() is used to send a message
-// IMAP protocol: retrieving mailboxes and messages
-// SMTP protocol: send messages
-router.post("/messages",
-    async (inRequest: Request, inResponse: Response) => {
-        try {
-            const smtpWorker: SMTP.Worker = new SMTP.Worker(serverInfo);
-            await smtpWorker.sendMessage(inRequest.body);
-            inResponse.status(201);
-            inResponse.send("ok");
-        } catch (inError) {
-            inResponse.status(400);
-            inResponse.send("error");
-        }
-    }
-);
-
-// REST Endpoint: List Contacts
-router.get("/contacts",
-    async (inRequest: Request, inResponse: Response) => {
-        try {
-            const contactsWorker: Contacts.Worker = new Contacts.Worker();
-            const contacts: IContact[] = await contactsWorker.listContacts();
-            inResponse.status(200);
-            inResponse.json(contacts);
-        } catch (inError) {
-            inResponse.status(400);
-            inResponse.send("error");
-        }
-    }
-);
-
-// REST Endpoint: Add Contact
-router.post("/contacts",
-    async (inRequest: Request, inResponse: Response) => {
-        try {
-            const contactsWorker: Contacts.Worker = new Contacts.Worker();
-            const contact: IContact = await contactsWorker.addContact(inRequest.body); // contain a unique identifier
-            inResponse.status(201);
-            inResponse.json(contact);
-        } catch (inError) {
-            inResponse.status(400);
-            inResponse.send("error");
-        }
-    }
-);
-
-// REST Endpoint: Update Contacts
-router.put("/contacts",
-    async (inRequest: Request, inResponse: Response) => {
-        try {
-            const contactsWorker: Contacts.Worker = new Contacts.Worker();
-            const contact: IContact = await contactsWorker.updateContact(inRequest.body);
-            inResponse.status(202);
-            inResponse.json(contact);
-        } catch (inError) {
-            inResponse.status(400);
-            inResponse.send("error");
-        }
-    }
-);
-
-// REST Endpoint: Delete Contact
-router.delete("/contacts/:id",
-    async (inRequest: Request, inResponse: Response) => {
-        try {
-            const contactsWorker: Contacts.Worker = new Contacts.Worker();
-            await contactsWorker.deleteContact(inRequest.params.id); // includes the ID of the contact to delete
-            inResponse.status(200);
-            inResponse.send("ok");
-        } catch (inError) {
-            inResponse.status(400);
-            inResponse.send("error");
-        }
-    }
-);
-*/
-
+};

package/routes/order.js

@@ -5,11 +5,14 @@ module.exports = ( fear ) => {
         const handler = fear.getHandler();
         const validator = fear.getValidator();
 
-        router.get("/all", Order.list);
-        router.post("/new", Order.create);
+        router.get("/all", handler.async(Order.list));
+        router.post("/new", handler.async(Order.create));
+        router.post("/create", handler.async(Order.create));
+
         router.route('/:id')
-                .get(Order.read)
-                .put(Order.update);
+                .post(handler.async(Order.update))
+                .get(handler.async(Order.read))
+                .put(handler.async(Order.update));
 
         router.get("/myOrders", Order.getMyOrders);
         router.get("/monthly", Order.getMonthWiseOrderIncome);

package/routes/password.js

@@ -0,0 +1,17 @@
+const Password = require("../controllers/auth/password");
+
+module.exports = (fear) => {
+    const router = fear.createRouter();
+    const handler = fear.getHandler();
+
+    // Forgot password - sends reset email
+    router.post('/forgot-password', Password.forgotPasswordToken);
+    // Reset password with token
+    router.post('/reset-password/:token', Password.resetPassword);
+    // Update password (requires authentication) TODO: Add auth middleware
+    router.put('/update-password', Password.updatePassword);
+    // Verify reset token validity (optional - for frontend validation)
+    router.get('/verify-reset-token/:token', Password.verifyResetToken);
+
+    return router;
+};

package/routes/payment.js

@@ -5,14 +5,10 @@ module.exports = (fear) => {
     const handler = fear.getHandler();
     const validator = fear.getValidator();
 
-    router.get("/all", Payment.list);
-    router.post("/new", Payment.create);
-    router.post("/:params", Payment.create);
     
-    router.route('/:id')
-        .get(Payment.read)
-        .put(Payment.update);
-
-
+    router.get("/all", handler.async(Payment.list));
+    router.post("/new", handler.async(Payment.create));
+    router.post("/create", handler.async(Payment.create));
+    
     return router;
 }

package/routes/paypal.js

@@ -0,0 +1,12 @@
+
+
+module.exports = ( fear ) => {
+    const router = fear.createRouter();
+    const handler = fear.getHandler();
+    const paypal = fear.getPaypal();
+
+    router.post('/order', handler.async(paypal.createPayPalOrder))
+    router.post('/capture', handler.async(paypal.capturePayPalOrder))
+
+    return router;
+}

package/routes/stripe.js

@@ -0,0 +1,27 @@
+const Payment = require('../controllers/payment');
+
+
+module.exports = (fear) => {
+  const router = fear.createRouter();
+  const validator = fear.getValidator();
+  const handler = fear.getHandler();
+  const Stripe = fear.stripe;
+
+  router.post('/intent', handler.async(Stripe.createPaymentIntent));
+  router.get('/intent/:id', handler.async(Stripe.retrievePaymentIntent));
+  router.post('/intent/:id/cancel', handler.async(Stripe.cancelPaymentIntent));
+
+  /*
+  router.post('/customer', handler.async(stripe.createCustomer));
+  router.get('/customer/:id', handler.async(stripe.retrieveCustomer));
+  router.get('/customers', handler.async(stripe.listCustomers));
+  
+  router.post('/checkout', handler.async(stripe.createCheckoutSession));
+  router.post('/subscription', handler.async(stripe.createSubscription));
+  router.post('/subscription/:id/cancel', handler.async(stripe.cancelSubscription));
+  router.post('/refund', handler.async(stripe.createRefund));
+
+  //router.post('/webhook', express.raw({ type: 'application/json' }), handler.async(Payment.handleWebhook);
+*/
+  return router;
+};

package/libs/passport/passport.js

@@ -1,109 +0,0 @@
-// needed for local authentication
-const passport = require("passport");
-const LocalStrategy = require("passport-local").Strategy;
-const FacebookStrategy = require("passport-facebook").Strategy;
-const secret = require("../config/secret");
-const User = require("../models/user");
-const async = require("async");
-const Cart = require("../models/cart");
-
-// serialize and deserialize
-passport.serializeUser((user, done) => {
-  done(null, user);
-});
-
-passport.deserializeUser((id, done) => {
-  User.findById(id, (err, user) => {
-    done(err, user);
-  });
-});
-
-// custom function validate
-exports.isAuthenticated = (req, res, next) => {
-  if (req.isAuthenticated()) {
-    return next();
-  }
-  res.redirect("/login");
-};
-// give the middleware a name, and create a new anonymous instance of LocalStrategy
-passport.use(
-  "login",
-  new LocalStrategy(
-    {
-      usernameField: "email",
-      passwordField: "password",
-      passReqToCallback: true,
-    },
-    (req, email, password, done) => {
-      // find a specific email
-      User.findOne({ email: email }, (err, user) => {
-        // incase of an error return a callback
-        if (err) return done(err);
-
-        if (!user) {
-          return done(
-            null,
-            false,
-            req.flash("loginMessage", "No user with such credentials found")
-          );
-        }
-
-        // compare user provided password and the database one
-        if (!user.comparePassword(password)) {
-          return done(
-            null,
-            false,
-            req.flash("loginMessage", "Oops! Wrong credentials")
-          );
-        }
-
-        // return user object
-        return done(null, user);
-      });
-    }
-  )
-);
-
-passport.use(
-  new FacebookStrategy(
-    secret.facebook,
-    (token, refreshToken, profile, done) => {
-      User.findOne({ facebook: profile.id }, (err, user) => {
-        if (err) return next(err);
-
-        if (user) {
-          return done(null, user);
-        } else {
-          async.waterfall([
-            (callback) => {
-              const newUser = new User();
-              newUser.email = profile._json.email;
-              newUser.facebook = profile.id;
-              newUser.tokens.push({ kind: "facebook", token: token });
-              newUser.profile.name = profile.displayName;
-              newUser.profile.picture =
-                "https://graph.facebook.com/" +
-                profile.id +
-                "/picture?type=large";
-
-              newUser.save((err) => {
-                if (err) return next(err);
-                callback(err, newUser._id);
-              });
-            },
-            (newUser) => {
-              const cart = new Cart();
-
-              cart.owner = newUser._id;
-              cart.save((err) => {
-                if (err) return done(err);
-                return done(err, newUser);
-              });
-            },
-          ]);
-        }
-      });
-    }
-  )
-);
-