Implemented storage of cargo details and handlings in reporting context

dddsample/external/reporting/src/main/java/com/reporting/ReportingService.java

 package com.reporting;
 
-import static com.reporting.Constants.US_DATETIME;
 import com.reporting.db.ReportDAO;
 import com.reporting.reports.CargoReport;
 import com.reporting.reports.VoyageReport;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.transaction.annotation.Transactional;
 import se.citerus.dddsample.reporting.api.CargoDetails;
 import se.citerus.dddsample.reporting.api.Handling;
 
 import javax.ws.rs.*;
 import javax.ws.rs.core.Response;
+import java.text.ParseException;
+
+import static com.reporting.Constants.US_DATETIME;
 import static javax.ws.rs.core.Response.ok;
 import static javax.ws.rs.core.Response.status;
-import java.text.ParseException;
 
 @Produces({"application/json", "application/pdf"})
-@Consumes("application/json")
+@Consumes({"application/json", "application/xml"})
 @Path("/")
 public class ReportingService {
 
   private ReportDAO reportDAO;
+  private static final Log LOG = LogFactory.getLog(ReportingService.class);
 
   public ReportingService(ReportDAO reportDAO) {
     this.reportDAO = reportDAO;
 
   @PUT
   @Path("/cargo")
-  public void reportCargoDetails(CargoDetails cargoDetails) {
-    // TODO
-    System.out.println("Received " + cargoDetails);
+  @Transactional
+  public void reportCargo(CargoDetails cargoDetails) {
+    reportDAO.storeCargoDetals(cargoDetails);
+    LOG.info("Stored cargo: " + cargoDetails);
   }
 
-  @PUT
+  @POST
   @Path("/cargo/{trackingId}/handled")
+  @Transactional
   public void reportHandling(@PathParam("trackingId") String trackingId, Handling handling) {
-    // TODO
-    System.out.println("Received " + trackingId + " : " + handling);
+    reportDAO.storeHandling(trackingId, handling);
+    LOG.info("Stored handling of cargo " + trackingId + ": " + handling);
   }
 
+  @SuppressWarnings({"UnusedDeclaration"})
   ReportingService() {
     // Needed by CGLIB
   }

dddsample/external/reporting/src/main/java/com/reporting/db/ReportDAO.java

 import com.reporting.reports.CargoReport;
 import com.reporting.reports.VoyageReport;
 import org.springframework.dao.EmptyResultDataAccessException;
-import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.RowCallbackHandler;
-import org.springframework.transaction.annotation.Transactional;
+import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
+import se.citerus.dddsample.reporting.api.CargoDetails;
 import se.citerus.dddsample.reporting.api.Handling;
 import se.citerus.dddsample.reporting.api.OnboardCargo;
 
 
 public class ReportDAO {
   
-  private JdbcTemplate jdbc;
+  private SimpleJdbcTemplate jdbc;
   private HandlingRowMapper handlingRowMapper;
   private CargoReportRowMapper cargoReportRowMapper;
   private VoyageReportRowMapper rowMapper;
   private VoyageCargoRowMapper voyageCargoRowMapper;
 
   public ReportDAO(DataSource dataSource) {
-    this.jdbc = new JdbcTemplate(dataSource);
+    this.jdbc = new SimpleJdbcTemplate(dataSource);
     this.handlingRowMapper = new HandlingRowMapper();
     this.cargoReportRowMapper = new CargoReportRowMapper();
     this.rowMapper = new VoyageReportRowMapper();
     this.voyageCargoRowMapper = new VoyageCargoRowMapper();
   }
 
-  @Transactional(readOnly = true)
   public CargoReport loadCargoReport(String trackingId) {
     try {
       String[] args = {trackingId};
       String sql = "select * from cargo where cargo_tracking_id = ?";
-      CargoReport cargoReport = (CargoReport) jdbc.queryForObject(sql, args, cargoReportRowMapper);
+      CargoReport cargoReport = (CargoReport) jdbc.getJdbcOperations().queryForObject(sql, args, cargoReportRowMapper);
       cargoReport.setHandlings(loadHandlings(trackingId));
       return cargoReport;
     } catch (EmptyResultDataAccessException e) {
     }
   }
 
-  @Transactional(readOnly = true)
   public VoyageReport loadVoyageReport(String voyageNumber) {
     String[] args = {voyageNumber};
     String sql = "select * from voyage where voyage_number = ?";
     try {
-      VoyageReport voyageReport = (VoyageReport) jdbc.queryForObject(sql, args, rowMapper);
+      VoyageReport voyageReport = (VoyageReport) jdbc.getJdbcOperations().queryForObject(sql, args, rowMapper);
       voyageReport.setOnboardCargos(loadOnboardCargos(voyageNumber));
       return voyageReport;
     } catch (EmptyResultDataAccessException e) {
     }
   }
 
+  public void storeCargoDetals(CargoDetails cargoDetails) {
+    int count = jdbc.queryForInt("select count(*) from cargo where cargo_tracking_id = ?", cargoDetails.getTrackingId());
+
+    String sql;
+    Object[] params;
+    if (count > 0) {
+      sql =
+        "update cargo set " +
+          "received_in = ?," +
+          "destination = ?," +
+          "arrival_deadline = ?," +
+          "eta = ?," +
+          "current_status = ?," +
+          "current_voyage_number = ?," +
+          "current_location = ?," +
+          "last_updated_on = ? " +
+        "where cargo_tracking_id = ?";
+      params = new Object[] {
+        cargoDetails.getReceivedIn(),
+        cargoDetails.getFinalDestination(),
+        cargoDetails.getArrivalDeadline(),
+        cargoDetails.getEta(),
+        cargoDetails.getCurrentStatus(),
+        cargoDetails.getCurrentVoyage(),
+        cargoDetails.getCurrentLocation(),
+        cargoDetails.getLastUpdatedOn(),
+        cargoDetails.getTrackingId()
+      };
+    } else {
+      sql =
+        "insert into cargo (" +
+          "cargo_tracking_id," +
+          "received_in," +
+          "destination," +
+          "arrival_deadline," +
+          "eta," +
+          "current_status," +
+          "current_voyage_number," +
+          "current_location," +
+          "last_updated_on) " +
+        "values (?,?,?,?,?,?,?,?,?)";
+      params = new Object[] {
+        cargoDetails.getTrackingId(),
+        cargoDetails.getReceivedIn(),
+        cargoDetails.getFinalDestination(),
+        cargoDetails.getArrivalDeadline(),
+        cargoDetails.getEta(),
+        cargoDetails.getCurrentStatus(),
+        cargoDetails.getCurrentVoyage(),
+        cargoDetails.getCurrentLocation(),
+        cargoDetails.getLastUpdatedOn()
+      };
+    }
+
+    jdbc.update(sql, params);
+  }
+
+  public void storeHandling(String trackingId, Handling handling) {
+    String sql = "insert into handling (cargo_tracking_id,type,location,voyage_number,completed_on) values (?,?,?,?,?)";
+    jdbc.update(sql, trackingId, handling.getType(), handling.getLocation(), handling.getVoyage(), handling.getCompletedOn());  
+  }
+
   private List<Handling> loadHandlings(String trackingId) {
     final List<Handling> handlings = new ArrayList<Handling>();
     RowCallbackHandler handler = new RowCallbackHandler() {
     };
     String[] args = {trackingId};
     String sql = "select * from handling where cargo_tracking_id = ?";
-    jdbc.query(sql, args, handler);
+    jdbc.getJdbcOperations().query(sql, args, handler);
     return handlings;
   }
 
     final List<OnboardCargo> onboardCargos = new ArrayList<OnboardCargo>();
     String[] args = {voyageNumber};
     String sql = "select cargo_tracking_id, destination from cargo where current_voyage_number = ?";
-    jdbc.query(sql, args, new RowCallbackHandler() {
+    jdbc.getJdbcOperations().query(sql, args, new RowCallbackHandler() {
       @Override
       public void processRow(ResultSet rs) throws SQLException {
         onboardCargos.add(voyageCargoRowMapper.mapRow(rs, rs.getRow()));

dddsample/external/reporting/src/main/webapp/index.jsp

             }
 
             $('#result').append('<p>Updated on: ' + cargo.lastUpdatedOn + '</p>');
+
+            for (var handling in json.cargoReport.handlings) {
+              $('#result').append('<p>' + handling['location'] + '</p>');
+            }
           },
           error: function(response) {
             if (response.status == 404) {

dddsample/external/reporting/src/test/java/com/reporting/ReportServiceTest.java

 package com.reporting;
 
+import com.reporting.db.ReportDAO;
+import com.reporting.reports.CargoReport;
 import org.apache.commons.io.IOUtils;
 import org.codehaus.jettison.json.JSONArray;
 import org.codehaus.jettison.json.JSONException;
 import org.codehaus.jettison.json.JSONObject;
-import static org.junit.Assert.*;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import se.citerus.dddsample.reporting.api.Handling;
 
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
 import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.net.HttpURLConnection;
 import java.net.URL;
 import java.net.URLConnection;
+import java.util.List;
+
+import static java.net.HttpURLConnection.HTTP_NO_CONTENT;
+import static org.junit.Assert.*;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(locations={"/context.xml", "/context-cxf.xml", "/context-test-setup.xml"})
 public class ReportServiceTest {
 
+  @Autowired
+  ReportDAO reportDAO;
+  private XMLOutputFactory xmlOutputFactory = XMLOutputFactory.newInstance();
+
   @Test
   public void cargoReport() throws Exception {
     JSONObject json = readJSON("/cargo/ABC.json");
     assertTrue(pdf.length() > 0);
   }
 
+  @Test
+  public void reportCargo() throws Exception {
+    HttpURLConnection con = openXMLPutConnection("/cargo");
+    XMLStreamWriter writer = xmlOutputFactory.createXMLStreamWriter(con.getOutputStream());
+    writer.writeStartDocument();
+    writer.writeStartElement("cargoDetails");
+
+    addElement(writer, "trackingId", "FGH456");
+    addElement(writer, "receivedIn", "HONGKONG");
+    addElement(writer, "finalDestination", "HELSINKI");
+    addElement(writer, "arrivalDeadline", "2010-05-15");
+    addElement(writer, "eta", "2010-05-04 14:30");
+    addElement(writer, "currentStatus", "ONBOARD_CARRIER");
+    addElement(writer, "currentVoyage", "S0134");
+    addElement(writer, "currentLocation", "");
+    addElement(writer, "lastUpdatedOn", "2010-05-01 12:20");
+
+    writer.writeEndElement();
+    writer.writeEndDocument();
+
+    writer.flush();
+    writer.close();
+    
+    assertEquals(HTTP_NO_CONTENT, con.getResponseCode());
+
+    CargoReport cargoReport = reportDAO.loadCargoReport("FGH456");
+    assertNotNull(cargoReport);
+  }
+
+  @Test
+  public void reportHandling() throws Exception {
+    HttpURLConnection con = openXMLPostConnection("/cargo/ABC/handled");
+    XMLStreamWriter writer = xmlOutputFactory.createXMLStreamWriter(con.getOutputStream());
+    writer.writeStartDocument();
+    writer.writeStartElement("handling");
+
+    addElement(writer, "type", "Unload");
+    addElement(writer, "location", "New York");
+    addElement(writer, "voyage", "V0200");
+    addElement(writer, "completedOn", "2009-06-09 12:10");
+
+    writer.writeEndElement();
+    writer.writeEndDocument();
+
+    writer.flush();
+    writer.close();
+
+    assertEquals(HTTP_NO_CONTENT, con.getResponseCode());
+
+    CargoReport cargoReport = reportDAO.loadCargoReport("ABC");
+    List<Handling> handlings = cargoReport.getHandlings();
+    assertEquals(5, handlings.size());
+    assertEquals("Unload", handlings.get(4).getType());
+  }
+
+  private HttpURLConnection openXMLPostConnection(String path) throws IOException {
+    return openWithMethod(path, "POST");
+  }
+
+  private HttpURLConnection openXMLPutConnection(String path) throws IOException {
+    return openWithMethod(path, "PUT");
+  }
+
+  private HttpURLConnection openWithMethod(String path, String method) throws IOException {
+    HttpURLConnection con = open(path);
+    con.setDoOutput(true);
+    con.setRequestMethod(method);
+    con.setRequestProperty("Content-type", "application/xml");
+    return con;
+  }
+
+  private void addElement(XMLStreamWriter writer, String elementName, String content) throws XMLStreamException {
+    writer.writeStartElement(elementName);
+    writer.writeCharacters(content);
+    writer.writeEndElement();
+  }
+
   private void verifyHandling(JSONObject handling, String type, String location, String voyage) throws JSONException {
     assertEquals(type, handling.get("type"));
     assertEquals(location, handling.get("location"));
   }
 
   private JSONObject readJSON(String path) throws IOException, JSONException {
-    URL url = new URL("http://localhost:14000" + path);
-    URLConnection urlConnection = url.openConnection();
+    URLConnection urlConnection = open(path);
     String jsonString = IOUtils.toString(urlConnection.getInputStream());
     return new JSONObject(jsonString);
   }
 
   private String readPDF(String path) throws IOException {
-    URL url = new URL("http://localhost:14000" + path);
-    URLConnection urlConnection = url.openConnection();
+    URLConnection urlConnection = open(path);
     return IOUtils.toString(urlConnection.getInputStream());
   }
 
+  private HttpURLConnection open(String path) throws IOException {
+    URL url = new URL("http://localhost:14000" + path);
+    return (HttpURLConnection) url.openConnection();
+  }
+
 }