backend is now on heroku postgres

Author: merhoo

web/temp/assets/Craig's Jobs.txt assets/Craig's Jobs.txtweb/temp/assets/Craig's Jobs.txt renamed to assets/Craig's Jobs.txt

@@ -24,6 +24,16 @@
       <artifactId>gson</artifactId>
       <version>2.8.1</version>
     </dependency>
+    <dependency>
+      <groupId>com.heroku.sdk</groupId>
+      <artifactId>heroku-maven-plugin</artifactId>
+      <version>2.0.2</version>
+    </dependency>
+    <dependency>
+        <groupId>postgresql</groupId>
+        <artifactId>postgresql</artifactId>
+        <version>9.1-901-1.jdbc4</version>
+    </dependency>
   </dependencies>
   <build>
     <plugins>
@@ -44,6 +54,39 @@
           <mainClass>merhoo.backend.App</mainClass>
         </configuration>
       </plugin>
+      <plugin>
+        <groupId>com.heroku.sdk</groupId>
+        <artifactId>heroku-maven-plugin</artifactId>
+        <version>2.0.2</version>
+        <configuration>
+          <jdkVersion>1.8</jdkVersion>
+          <appName>merhoo</appName>
+          <processTypes>
+            <web>java -jar ./target/backend-1.0-SNAPSHOT-jar-with-dependencies.jar</web>
+          </processTypes>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>single</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <descriptorRefs>
+            <descriptorRef>jar-with-dependencies</descriptorRef>
+          </descriptorRefs>
+          <archive>
+            <manifest>
+              <mainClass>merhoo.backend.App</mainClass>
+            </manifest>
+          </archive>
+        </configuration>
+      </plugin>
     </plugins>
   </build>
 </project>

web/temp/assets/Resume.pdf assets/Resume.pdfweb/temp/assets/Resume.pdf renamed to assets/Resume.pdf

@@ -11,6 +11,24 @@
  * For now, our app creates an HTTP server that can only get and add data.
  */
 public class App {
+
+  /**
+    * Get an integer environment varible if it exists, and otherwise return the
+    * default value.
+    *
+    * @envar      The name of the environment variable to get.
+    * @defaultVal The integer value to use as the default if envar isn't found
+    *
+    * @returns The best answer we could come up with for a value for envar
+    */
+    static int getIntFromEnv(String envar, int defaultVal) {
+      ProcessBuilder processBuilder = new ProcessBuilder();
+      if (processBuilder.environment().get(envar) != null) {
+          return Integer.parseInt(processBuilder.environment().get(envar));
+      }
+      return defaultVal;
+    }
+
     public static void main(String[] args) {
 
         // gson provides us with a way to turn JSON into objects, and objects
@@ -21,14 +39,13 @@ public static void main(String[] args) {
         // NB: Gson is thread-safe.  See
         // https://stackoverflow.com/questions/10380835/is-it-ok-to-use-gson-instance-as-a-static-field-in-a-model-bean-reuse
         final Gson gson = new Gson();
+        final Database db = Database.getDatabase();
+        if (db == null) {
+          return;
+        }
 
-        // dataStore holds all of the data that has been provided via HTTP
-        // requests
-        //
-        // NB: every time we shut down the server, we will lose all data, and
-        //     every time we start the server, we'll have an empty dataStore,
-        //     with IDs starting over from 0.
-        final DataStore dataStore = new DataStore();
+        // Get the port on which to listen for requests
+        Spark.port(getIntFromEnv("PORT", 4567));
 
         // Set up the location for serving static files
         Spark.staticFileLocation("/web");
@@ -47,10 +64,10 @@ public static void main(String[] args) {
             // ensure status 200 OK, with a MIME type of JSON
             response.status(200);
             response.type("application/json");
-            return gson.toJson(new StructuredResponse("ok", null, dataStore.readAll()));
+            return gson.toJson(new StructuredResponse("ok", null, db.readAll()));
         });
 
-        // GET route that returns everything for a single row in the DataStore.
+        // GET route that returns everything for a single row in the db.
         // The ":id" suffix in the first parameter to get() becomes
         // request.params("id"), so that we can get the requested row ID.  If
         // ":id" isn't a number, Spark will reply with a status 500 Internal
@@ -61,15 +78,15 @@ public static void main(String[] args) {
             // ensure status 200 OK, with a MIME type of JSON
             response.status(200);
             response.type("application/json");
-            DataRow data = dataStore.readOne(idx);
+            DataRow data = db.readOne(idx);
             if (data == null) {
                 return gson.toJson(new StructuredResponse("error", idx + " not found", null));
             } else {
                 return gson.toJson(new StructuredResponse("ok", null, data));
             }
         });
 
-        // POST route for adding a new element to the DataStore.  This will read
+        // POST route for adding a new element to the db.  This will read
         // JSON from the body of the request, turn it into a SimpleRequest
         // object, extract the title and message, insert them, and return the
         // ID of the newly created row.
@@ -83,15 +100,15 @@ public static void main(String[] args) {
             response.status(200);
             response.type("application/json");
             // NB: createEntry checks for null title and message
-            int newId = dataStore.createEntry(req.mTitle, req.mMessage);
+            int newId = db.createEntry(req.mTitle, req.mMessage);
             if (newId == -1) {
                 return gson.toJson(new StructuredResponse("error", "error performing insertion", null));
             } else {
                 return gson.toJson(new StructuredResponse("ok", "" + newId, null));
             }
         });
 
-        // PUT route for updating a row in the DataStore.  This is almost
+        // PUT route for updating a row in the db.  This is almost
         // exactly the same as POST
         Spark.put("/messages/:id", (request, response) -> {
             // If we can't get an ID or can't parse the JSON, Spark will send
@@ -101,15 +118,15 @@ public static void main(String[] args) {
             // ensure status 200 OK, with a MIME type of JSON
             response.status(200);
             response.type("application/json");
-            DataRow result = dataStore.updateOne(idx, req.mTitle, req.mMessage);
+            DataRow result = db.updateOne(idx, req.mTitle, req.mMessage);
             if (result == null) {
                 return gson.toJson(new StructuredResponse("error", "unable to update row " + idx, null));
             } else {
                 return gson.toJson(new StructuredResponse("ok", null, result));
             }
         });
 
-        // DELETE route for removing a row from the DataStore
+        // DELETE route for removing a row from the db
         Spark.delete("/messages/:id", (request, response) -> {
             // If we can't get an ID, Spark will send a status 500
             int idx = Integer.parseInt(request.params("id"));
@@ -118,7 +135,7 @@ public static void main(String[] args) {
             response.type("application/json");
             // NB: we won't concern ourselves too much with the quality of the
             //     message sent on a successful delete
-            boolean result = dataStore.deleteOne(idx);
+            boolean result = db.deleteOne(idx);
             if (!result) {
                 return gson.toJson(new StructuredResponse("error", "unable to delete row " + idx, null));
             } else {