orders update

Author: ZhongyanLiang

examples_new/microservices/orders/src/__test__/Order.test.ts

@@ -0,0 +1,16 @@
+import request from 'supertest';
+import { app } from '../app';
+// Mongo Memory Server - Users collection always starts out empty**
+it('success if there is itemid and units', async () => {
+  const itemId = '6581bbc692686e6e68d25d7d';
+  const sellerID = '123123';
+  await global.createItem(itemId);
+  const response = await request(app)
+    .get('/api/orders/getMyOrder')
+    .send({
+      itemId: itemId,
+    })
+    .expect(200);
+  // console.log(response);
+  expect(response.body.units).toEqual(50);
+});

examples_new/microservices/orders/src/controllers/order-controller.ts

@@ -1,18 +1,51 @@
 import { Request, Response } from 'express';
 import axios from 'axios';
+import { Order } from '../models/Order';
+import { BadRequestError, CurrentUserRequest, Events } from '@chronosrx/common';
+import { Inventory } from '../models/Inventory';
 
-export const getOrder =async (req:Request,res:Response) => {
-    
-}
+export const createOrder = async (req: CurrentUserRequest, res: Response) => {
+  //deconstruct req.body
+  const buyerId = req.currentUser;
+  const { itemId, amount, totalPrice, sellerId } = req.body;
+  //create Order document in the databse
+  const newOrder = Inventory.build({});
+  await newOrder.save();
+  //send created order to event bus
+  await axios.post('http://localhost:3005/', {
+    event: {
+      type: Events.ORDER_CREATED,
+      payload: newOrder,
+    },
+  });
+  res.status(201).send(newOrder);
+};
 
-export const getSale =async (req:Request,res:Response) => {
-    
-}
+export const getOrder = async (req: Request, res: Response) => {
+  // check if order already exists
+  const { buyerId } = req.body;
+  const exsitingOrder = await Order.findOne({ buyerId });
+  if (!exsitingOrder) {
+    throw new BadRequestError('Order with that id does not exists');
+  }
+  //check inventory itemId, amount
+  res.status(200).send(exsitingOrder);
+};
 
-export const createOrder =async (req:Request,res:Response) => {
-    
-}
+export const getSale = async (req: Request, res: Response) => {
+  const { sellerId } = req.body;
+  const sales = await Order.find({ sellerId });
+  if (!sales) {
+    throw new BadRequestError('Sales with that sellerId does not exist');
+  }
+  res.status(200).send(sales);
+};
 
-export const deleteOrder =async (req:Request,res:Response) => {
-    
-}
+export const deleteOrder = async (req: Request, res: Response) => {
+  const { id } = req.body;
+  const deletedOrder = await Order.findOneAndDelete({ id });
+  if (!deletedOrder) {
+    throw new BadRequestError(`Could not find that order by id to delete`);
+  }
+  res.status(200).send(deletedOrder);
+};

examples_new/microservices/orders/src/models/Inventory.ts

@@ -0,0 +1,62 @@
+import mongoose from 'mongoose';
+interface InventoryAttrs {
+  itemName: string;
+  sellerId: string; // some user's id)
+  unitPrice: number;
+}
+// define item attributes
+interface InventoryModel extends mongoose.Model<InventoryDoc> {
+  build(attrs: InventoryAttrs): InventoryDoc;
+}
+//create item data in the database with these types;
+interface InventoryDoc extends mongoose.Document {
+  itemName: string;
+  sellerId: string;
+  unitPrice: number;
+  itemId: string;
+  units: number;
+}
+// create the Schema in mongoose with defines requirements
+const InventorySchema = new mongoose.Schema(
+  {
+    itemName: {
+      type: String,
+      required: true,
+      // unique: true,
+    },
+    sellerId: {
+      type: mongoose.Types.ObjectId,
+      required: true,
+      ref: 'User',
+    },
+    unitPrice: {
+      type: Number,
+      required: true,
+    },
+    itemId: {
+      type: mongoose.Types.ObjectId,
+      required: true,
+      unique: true,
+    },
+    units: {
+      type: Number,
+      required: true,
+    },
+  },
+  {
+    //anytime we create JSON formatted data, transform item using following rules
+    toJSON: {
+      transform(doc, ret) {
+        ret.id = ret._id;
+        delete ret._id;
+        delete ret.__v;
+      },
+    },
+  }
+);
+InventorySchema.statics.build = (attrs: InventoryAttrs) => {
+  //returning item document with (attrs) passed in
+  return new Inventory(attrs);
+};
+const Inventory = mongoose.model<InventoryDoc, InventoryModel>('Inventory', InventorySchema);
+export { Inventory };

examples_new/microservices/orders/src/models/Order.ts

@@ -4,7 +4,6 @@ interface OrderAttrs {
   itemId: string;
   amount: number;
   totalPrice: number;
-  buyerId: string;
   sellerId: string;
 }
 
@@ -16,7 +15,6 @@ interface OrderDoc extends mongoose.Document {
   itemId: string;
   amount: number;
   totalPrice: number;
-  buyerId: string;
   sellerId: string;
 }
 
@@ -36,10 +34,6 @@ const OrderSchema = new mongoose.Schema(
       type: Number,
       required: true,
     },
-    buyerId: {
-      type: String,
-      require: true,
-    },
     sellerId: {
       type: String,
       require: true,
@@ -62,7 +56,6 @@ OrderSchema.statics.build = (attrs: OrderAttrs) => {
     itemId: attrs.itemId,
     amount: attrs.amount,
     totalPrice: attrs.totalPrice,
-    buyerId: attrs.buyerId,
     sellerId: attrs.sellerId,
   });
 };

examples_new/microservices/orders/src/routes/event-router.ts

@@ -1,6 +1,7 @@
 import express from 'express';
 import { Events } from '@chronosrx/common';
 import { Order } from '../models/Order';
+import { Inventory } from '../models/Inventory';
 
 const router = express.Router();
 
@@ -9,7 +10,7 @@ router.post('/', async (req, res) => {
   console.log(event);
   switch (event.type) {
     case Events.ITEM_CREATED:
-      const newOrder = Order.build(event.payload);
+      const newOrder = Inventory.build(event.payload);
       await newOrder.save();
       break;
     default:

examples_new/microservices/orders/src/routes/order-router.ts

@@ -1,9 +1,10 @@
 import express from 'express';
-import {getOrder,getSale,createOrder,deleteOrder} from '../controllers/order-controller';
-import { currentUser } from '@chronosrx/common';
+import { getOrder, getSale, createOrder, deleteOrder } from '../controllers/order-controller';
+import { currentUser, requireAuth } from '@chronosrx/common';
 
 const router = express.Router();
-
+router.use(currentUser);
+router.use(requireAuth);
 router.get('/getMyOrders', getOrder);
 router.get('/getMySales', getSale);
 router.post('/createOrder', createOrder);

examples_new/microservices/orders/src/test/setup.ts

@@ -0,0 +1,46 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import mongoose from 'mongoose';
+import { app } from '../app';
+import request from 'supertest';
+import { Order } from '../models/Order';
+
+declare global {
+  function createOrder(itemId: string, sellerId: string): void;
+}
+
+let mongo: any;
+
+beforeAll(async () => {
+  process.env.JWT_KEY = 'erreoivcxspasfgj';
+
+  mongo = await MongoMemoryServer.create();
+  const mongoUri = mongo.getUri();
+
+  await mongoose.connect(mongoUri, {});
+});
+
+beforeEach(async () => {
+  const collections = await mongoose.connection.db.collections();
+
+  for (let collection of collections) {
+    await collection.deleteMany({});
+  }
+});
+
+afterAll(async () => {
+  if (mongo) {
+    await mongo.stop();
+  }
+
+  await mongoose.connection.close();
+});
+
+global.createOrder = async (itemId, sellerId) => {
+  const data = Order.build({
+    itemId: itemId,
+    amount: 50,
+    totalPrice: 5000,
+    sellerId: sellerId,
+  });
+  await data.save();
+};