Merge pull request #15 from oslabs-beta/inventory

inventory

Author: seantokuzo

examples_new/microservices/inventory/src/__test__/inventory.test.ts

@@ -20,14 +20,15 @@ it('fails if item id or units are missing', async () => {
 });
 it('success if there is itemid and units', async () => {
   const itemId = '6581bbc692686e6e68d25d7d';
-  await global.createItem(itemId);
+  const sellerId = '6581bbc692686e6e68d25xxx';
+  await global.createItem(itemId, sellerId);
   const response = await request(app)
     .get('/api/inventory/getItemInventory')
     .send({
       itemId: itemId,
     })
     .expect(200);
-  // console.log(response);
+  console.log(response);
   expect(response.body.units).toEqual(50);
 });
 //testing updateItemInventory route, fail if id or units are missing
@@ -47,7 +48,8 @@ it('fails if item id or units are missing when trying to update', async () => {
 });
 it('successful updated the item with updated units', async () => {
   const itemId = '6581bbc692686e6e68d25d7d';
-  await global.createItem(itemId);
+  const sellerId = '6581bbc692686e6e68d25xxx';
+  await global.createItem(itemId, sellerId);
 
   const response = await request(app)
     .patch('/api/inventory/updateItemInventory')

examples_new/microservices/inventory/src/controllers/inventory-controllers.ts

@@ -3,10 +3,10 @@ import axios from 'axios';
 import { Inventory } from '../models/Inventory';
 import { BadRequestError, CurrentUserRequest, Events } from '@chronosrx/common';
 
-export const getItemInventory = async (req: Request, res: Response) => {
+export const getAllItems = async (req: Request, res: Response) => {
   console.log(req.body);
   const { itemId, units } = req.body;
-  const exsitingItem = await Inventory.findOne({ itemId });
+  const exsitingItem = await Inventory.find({ itemId });
   if (!exsitingItem) {
     throw new BadRequestError('Item with that ID does not exist');
   }
@@ -17,7 +17,16 @@ export const getItemInventory = async (req: Request, res: Response) => {
   //     payload: newInventory,
   //   },
   // });
+  res.status(200).send(exsitingItem);
+};
 
+export const getMyItems = async (req: Request, res: Response) => {
+  console.log(req.body);
+  const { sellerId } = req.body;
+  const exsitingItem = await Inventory.find({ sellerId });
+  if (!exsitingItem) {
+    throw new BadRequestError('Could not find items with that sellerId');
+  }
   res.status(200).send(exsitingItem);
 };
 

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

@@ -1,33 +1,47 @@
 import mongoose from 'mongoose';
-//define type of objects that is being passed into build method
+
 interface InventoryAttrs {
-  itemId: string;
-  units: number;
+  id: string;
+  itemName: string;
+  sellerId: string; // some user's id)
+  unitPrice: number;
 }
-
+// define item attributes
 interface InventoryModel extends mongoose.Model<InventoryDoc> {
   build(attrs: InventoryAttrs): InventoryDoc;
 }
-//create inventory data in the database in this shape
+//create item data in the database with these types;
 interface InventoryDoc extends mongoose.Document {
-  itemId: string;
+  itemName: string;
+  sellerId: mongoose.Types.ObjectId;
+  unitPrice: number;
   units: number;
 }
-//create the Schema in mongoose with defined requirements
-const inventorySchema = new mongoose.Schema(
+// create the Schema in mongoose with defines requirements
+const InventorySchema = new mongoose.Schema(
   {
-    itemId: {
+    itemName: {
       type: String,
       required: true,
-      unique: true,
+      // unique: true,
+    },
+    sellerId: {
+      type: mongoose.Types.ObjectId,
+      required: true,
+      ref: 'User',
+    },
+    unitPrice: {
+      type: Number,
+      required: true,
     },
     units: {
       type: Number,
       required: true,
+      default: 1,
     },
   },
   {
-    //anytime we create Json formatted data, transform the user document as following
+    //anytime we create JSON formatted data, transform item using following rules
     toJSON: {
       transform(doc, ret) {
         ret.id = ret._id;
@@ -37,14 +51,14 @@ const inventorySchema = new mongoose.Schema(
     },
   }
 );
-
-inventorySchema.statics.build = (attrs: InventoryAttrs) => {
+InventorySchema.statics.build = (attrs: InventoryAttrs) => {
+  //returning item document with (attrs) passed in
   return new Inventory({
-    itemId: attrs.itemId,
-    units: attrs.units,
+    _id: new mongoose.Types.ObjectId(attrs.id),
+    itemName: attrs.itemName,
+    sellerId: attrs.sellerId,
+    unitPrice: attrs.unitPrice,
   });
 };
-
-const Inventory = mongoose.model<InventoryDoc, InventoryModel>('Inventory', inventorySchema);
-
+const Inventory = mongoose.model<InventoryDoc, InventoryModel>('Inventory', InventorySchema);
 export { Inventory };

examples_new/microservices/inventory/src/models/user.ts

@@ -0,0 +1,48 @@
+import mongoose from 'mongoose';
+
+//define attrs
+interface UserAttrs {
+  username: string;
+  id: string;
+}
+// add a method 'build' to the UserModel
+// mongoose has built-in Model class that takes 'UserDoc'
+interface UserModel extends mongoose.Model<UserDoc> {
+  build(attrs: UserAttrs): UserDoc;
+}
+//create user data in the database in this shape
+interface UserDoc extends mongoose.Document {
+  username: string;
+}
+//create the Schema in mongoose with defined requirements
+const userSchema = new mongoose.Schema(
+  {
+    username: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+  },
+  {
+    //anytime we create Json formatted data, transform the user document as following
+    toJSON: {
+      transform(doc, ret) {
+        ret.id = ret._id;
+        delete ret._id;
+        delete ret.__v;
+      },
+    },
+  }
+);
+
+userSchema.statics.build = (attrs: UserAttrs) => {
+  //returning user document with (attrs) passed in
+  return new User({
+    _id: attrs.id,
+    username: attrs.username,
+  });
+};
+
+const User = mongoose.model<UserDoc, UserModel>('User', userSchema);
+
+export { User };

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

@@ -1,18 +1,22 @@
-import { Events } from '@chronosrx/common';
+import { EventTypes, Events } from '@chronosrx/common';
 import express from 'express';
 import { Inventory } from '../models/Inventory';
+import { User } from '../models/user';
 
 const router = express.Router();
 
 router.post('/', async (req, res) => {
-  const { event } = req.body;
-  // console.log('Event received:', event);
+  const event: Events = req.body.event;
+  console.log(event);
   switch (event.type) {
-    case Events.ITEM_CREATED:
-      console.log(event);
+    case EventTypes.USER_CREATED:
+      // console.log(event);
+      const newUser = User.build(event.payload);
+      await newUser.save();
+      break;
+    case EventTypes.ITEM_CREATED:
       const newInventory = Inventory.build(event.payload);
       await newInventory.save();
-      break;
     default:
       res.send({});
   }

examples_new/microservices/inventory/src/routes/inventory-router.ts

@@ -1,5 +1,5 @@
 import express from 'express';
-import { getItemInventory, updateItemInventory } from '../controllers/inventory-controllers';
+import { getAllItems, updateItemInventory, getMyItems } from '../controllers/inventory-controllers';
 
 const router = express.Router();
 
@@ -8,7 +8,8 @@ const router = express.Router();
 
 // });
 
-router.get('/getItemInventory', getItemInventory);
+router.get('/getAllItems', getAllItems);
+router.get('/getMyItems', getMyItems);
 router.patch('/updateItemInventory', updateItemInventory);
 
 export default router;

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

@@ -1,11 +1,9 @@
 import { MongoMemoryServer } from 'mongodb-memory-server';
 import mongoose from 'mongoose';
-import { app } from '../app';
-import request from 'supertest';
 import { Inventory } from '../models/Inventory';
 
 declare global {
-  function createItem(itemId: string): void;
+  function createItem(itemId: string, sellerId: string): void;
 }
 
 let mongo: any;
@@ -35,10 +33,13 @@ afterAll(async () => {
   await mongoose.connection.close();
 });
 
-global.createItem = async itemId => {
+global.createItem = async (itemId, sellerId) => {
   const data = Inventory.build({
     itemId: itemId,
+    itemName: 'crap',
+    sellerId: sellerId,
     units: 50,
+    unitPrice: 5,
   });
   await data.save();
 };