Merge pull request #2 from CastleKey/backend-setup

Backend setup

Author: Yiwen Dong

.gitignore

@@ -2,3 +2,13 @@
 
 ## This project is a collaborative effort required for Web Dev
 
+Start server on windows, don't forget to "SET EVANBUSSE_APIKEY=$$" to set the api key replacing $$ with the actual api key before doing npm start.  
+
+Start server on Mac OS or linux, do EVANBUSSE_APIKEY=$$ npm start  
+
+[Search for a strain contain letter b](https://tranquil-stream-31009.herokuapp.com/api/strain/b)  
+
+[Search for a strain contain name afpak](https://tranquil-stream-31009.herokuapp.com/api/strain/afpak)  
+
+[Search for a strain with name that doesn't existe](https://tranquil-stream-31009.herokuapp.com/api/strain/afpakaa)  
+

README.md

@@ -0,0 +1,29 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var effectSchema = new Schema({
+  _id: { type: String },
+  category: { type: String, 
+              required: true,
+              default: "POSITIVE",
+              validate: {
+                  validator: function(text) {
+                    return text === "POSITIVE" || text === "NEGATIVE" || text === "MEDICAL";
+                  },
+                  message: "effect must be one of positive, negative or medical"
+              }
+            }
+});
+
+effectSchema.virtual("name")
+    .get(function() {
+      return this._id;
+    })
+    .set(function(n) {
+      this._id = n;
+    });
+
+
+var Effect = mongoose.model("Effect", effectSchema);
+
+module.exports = Effect;

nodesrc/model/effect.model.js

@@ -0,0 +1,18 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var flavorSchema = new Schema({
+  _id: { type: String }
+});
+
+flavorSchema.virtual("name")
+    .get(function() {
+      return this._id;
+    })
+    .set(function(n) {
+      this._id = n;
+    });
+
+var Flavor = mongoose.model("Flavor", flavorSchema);
+
+module.exports = Flavor;

nodesrc/model/flavor.model.js

@@ -0,0 +1,40 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+var strainSchema = new Schema({
+  _id: { type: String },
+  eb_id: { type: Number, required: true, unique: true },
+  desc: { type: String, required: false },
+  race: { type: String, 
+          required: true,
+          default: "HYBRID",
+          validate: {
+              validator: function(text) {
+                return text === "HYBRID" || text === "SATIVA" || text === "INDICA";
+              },
+              message: "Race is hybrid or sativa or indica"
+          }
+        },
+  flavors: 
+      { type: [{ type: Schema.Types.String, ref: 'Flavor' }], 
+        required: true,
+        default: []
+      },
+  effects: 
+      { type: [{ type: Schema.Types.String, ref: 'Effect' }], 
+        required: true,
+        default: []
+      }
+});
+
+strainSchema.virtual("name")
+    .get(function() {
+      return this._id;
+    })
+    .set(function(n) {
+      this._id = n;
+    });
+    
+var Strain = mongoose.model("Strain", strainSchema);
+
+module.exports = Strain;

nodesrc/model/strain.model.js

@@ -0,0 +1,43 @@
+const effectModel = require('../model/effect.model');
+
+findAllEffects = () => {
+  return effectModel.find();
+}
+
+findEffect = (name) => {
+  return effectModel.findById(name);
+}
+
+saveEffect = (effect) => {
+  return effectModel(effect).save();
+}
+
+upsertEffect = (effect) => {
+  return effectModel.findByIdAndUpdate(effect._id, effect, {upsert:true, new:true}).exec();
+}
+
+saveEffects = (effects) => {
+  effects.forEach((effect) => {
+    saveEffect(effect).then((err) => {if (err) {throw JSON.stringify(err);}});
+  });
+}
+
+upsertEffects = (effects) => {
+  effects.forEach((effect) => {
+    upsertEffect(effect).then((err) => {});
+  });
+}
+
+searchEffectsByName = (q) => {
+  return effects.find({_id: new RegExp('^'+q+'$', "i")})
+}
+
+module.exports = {
+  findAllEffects,
+  findEffect, 
+  saveEffect,
+  saveEffects,
+  upsertEffect,
+  upsertEffects,
+  searchEffectsByName
+}

nodesrc/repository/effect.repository.js

@@ -0,0 +1,43 @@
+const flavorModel = require('../model/flavor.model');
+
+findAllFlavors = () => {
+  return flavorModel.find();
+}
+
+findFlavor = (name) => {
+  return flavorModel.findById(name);
+}
+
+saveFlavor = (flavor) => {
+  return flavorModel(flavor).save();
+}
+
+upsertFlavor = (flavor) => {
+  return flavorModel.findByIdAndUpdate(flavor._id, flavor, {upsert:true, new:true}).exec();
+}
+
+saveFlavors = (flavors) => {
+  flavors.forEach((flavor) => {
+    saveFlavor(flavor).then((err) => {if (err) {throw JSON.stringify(err);}});
+  });
+}
+
+upsertFlavors = (flavors) => {
+  flavors.forEach((flavor) => {
+    upsertFlavor(flavor).then((err) => {});
+  });
+}
+
+searchFlavorsByName = (q) => {
+  return flavors.find({_id: new RegExp('^'+q+'$', "i")})
+}
+
+module.exports = {
+  findAllFlavors,
+  findFlavor, 
+  saveFlavor,
+  saveFlavors,
+  upsertFlavor,
+  upsertFlavors,
+  searchFlavorsByName
+}

nodesrc/repository/flavor.repository.js

@@ -0,0 +1,45 @@
+const strainModel = require('../model/strain.model');
+
+findAllStrains = () => {
+  return strainModel.find();//.then((err, strains) => {
+    
+//  });
+}
+
+findStrain = (name) => {
+  return strainModel.findById(name);
+}
+
+saveStrain = (strain) => {
+  return strainModel(strain).save();
+}
+
+upsertStrain = (strain) => {
+  return strainModel.findByIdAndUpdate(strain._id, strain, {upsert:true, new:true}).exec();
+}
+
+saveStrains = (strains) => {
+  strains.forEach((strain) => {
+    saveStrain(strain).then((err) => {if (err) {throw JSON.stringify(err);}});
+  });
+}
+
+upsertStrains = (strains) => {
+  strains.forEach((strain) => {
+    upsertStrain(strain).then((err) => {});
+  });
+}
+
+searchStrainsByName = (q) => {
+  return strains.find({_id: new RegExp('^'+q+'$', "i")})
+}
+
+module.exports = {
+  findAllStrains,
+  findStrain, 
+  saveStrain,
+  saveStrains,
+  upsertStrain,
+  upsertStrains,
+  searchStrainsByName
+}

nodesrc/repository/strain.repository.js

@@ -0,0 +1,88 @@
+module.exports = app => {
+  const mongoose = require('mongoose');
+  const strainRepo = require('../repository/strain.repository');
+  const http = require('http');
+  const url = "http://strainapi.evanbusse.com/" + process.env.EVANBUSSE_APIKEY;
+  
+  var makeReq = (link, func) => {
+    http.get(link, res => {
+      res.setEncoding("utf8");
+      let body = "";
+      res.on("data", data => {
+        body += data;
+      });
+      res.on("end", () => {
+        let parsedBd = JSON.parse(body);
+        func(parsedBd)
+      });
+    });
+  };
+  
+  app.get("/api/strain", function (req, res) {
+    strainRepo.findAllStrains().then((err, strains) => {
+      if (err || strains == null) {
+        res.status(400).send(JSON.stringify(err));
+        return;
+      }
+      res.json(strains);
+    });
+  });
+  
+  app.get("/api/strain/:sname", function (req, res) {
+    strainRepo.findStrain().then((err, strain) => {
+      if (err) {
+        res.status(400).send(JSON.stringify(err));
+        return;
+      }
+      if (strain == null) {
+        makeReq(url + "/strains/search/name/" + req.params['sname'], (strains) => {
+          var firstTime = {first: true};
+          if (strains.length == 0) {
+            res.sendStatus(400);
+            return;
+          }
+          strains.forEach((str) => {
+            strainRepo.findStrain(str.name).then((err, dbStr) => {
+              if (err || dbStr == null) {
+                makeReq(url + "/strains/data/effects/" + str.id, (eff) => { 
+                  return ((eff, firstTime) => {
+                    makeReq(url + "/strains/data/flavors/" + str.id, (fla) => { 
+                      return ((fla, firstTime) => {
+                        var first = false;
+                        if (firstTime.first == true) {
+                          firstTime.first = false;
+                          first = true;
+                        }
+                        var obj = {};
+                        obj._id = str.name;
+                        obj.eb_id = str.id;
+                        obj.race = str.race.toUpperCase();
+                        obj.desc = str.desc;
+                        obj.effects = eff.positive.concat(
+                                      eff.negative.concat(
+                                      eff.medical)).map((eff) => {
+                          return eff.toString();
+                        });
+                        obj.flavors = fla.map((fla) => {
+                          return fla.toString();
+                        });
+                        strainRepo.upsertStrain(obj).then((dbObj) => {
+                          if (first) {
+                            res.json(dbObj);
+                          }
+                        });
+                      })(fla, firstTime)
+                    });
+                  })(eff, firstTime)
+                });
+              }
+            });
+          });
+          //res.json(strain);
+        });
+        return;
+      }
+      res.json(strain);
+    });
+  });
+}