OrderControllerV1.java

package controllers;

import api.v1.DPOrder;
import api.v1.Forecast;
import api.v1.Order;
import api.v1.OrderSearch;
import auth.modules.TokenAuthorize;
import auth.types.PermissionType;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import compositions.*;
import exceptions.PoseidonException;
import mapper.DPOrderMapper;
import mapper.ForecastMapper;
import mapper.OrderMapper;
import models.ForecastModel;
import models.OrderModel;
import models.RecipientModel;
import org.joda.time.DateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import play.libs.Json;
import play.mvc.Http;
import play.mvc.Result;
import quba.models.QubaStation;
import service.OrderService;
import service.PoseidonService;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@ResponseTimeLoggingComposition.ResponseTimeLogging
@RequestLoggingComposition.RequestLogging
@NoCacheComposition.NoCache
@ErrorHandlingComposition.ErrorHandling
@CorsComposition.Cors
public class OrderControllerV1 extends PoseidonController {

  private static Logger logger = LoggerFactory.getLogger(OrderControllerV1.class);

  @TokenAuthorize(requiredPermission = PermissionType.READ)
  public Result getAll() {
    OrderService service = new OrderService(currentApiUser().username);
    List<OrderModel> orderModels = service.findAll();
    List<Order> orders = new OrderMapper().mapToApi(orderModels);
    return ok(Json.toJson(orders));
  }

  @TokenAuthorize(requiredPermission = PermissionType.READ)
  public Result get(Long id) {
    OrderService service = new OrderService(currentApiUser().username);
    OrderModel orderModel = service.getById(id);
    if (orderModel == null) return notFound();
    Order order = new OrderMapper().mapToApi(orderModel);
    return ok(Json.toJson(order));
  }

  @TokenAuthorize(requiredPermission = PermissionType.READ)
  public Result getByMetref(String metref) {
    OrderService service = new OrderService(currentApiUser().username);
    OrderModel orderModel = service.getByMetref(metref);
    if ( orderModel == null) return notFound();
    Order order = new OrderMapper().mapToApi(orderModel);
    return ok(Json.toJson(order));
  }

  @TokenAuthorize(requiredPermission = PermissionType.WRITE)
  public Result createOrUpdate(String callback) {
    JsonNode body = request().body().asJson();
    ObjectMapper mapper = new ObjectMapper();
    Order apiOrder;
    try {
      apiOrder = mapper.readValue(body.toString(), Order.class);
    } catch (IOException e) {
      return badRequest("json post parameter parsing failure: " + e.getMessage());
    }
    OrderModel model = new OrderService(currentApiUser().username).createOrUpdate(apiOrder);
    Order newOrder = new OrderMapper().mapToApi(model);
    JsonNode jsonOut = Json.toJson(newOrder);
    return ok(callback, jsonOut);
  }

  @TokenAuthorize(requiredPermission = PermissionType.READ)
  public Result search(String callback) {
    JsonNode body = request().body().asJson();
    ObjectMapper mapper = new ObjectMapper();
    OrderSearch apiSearch;
    try {
      apiSearch = mapper.readValue(body.toString(), OrderSearch.class);
    } catch (IOException e) {
      return badRequest("json post parameter parsing failure: " + e.getMessage());
    }
    List<OrderModel> orderModels = new OrderService(currentApiUser().username).search(apiSearch);
    List<Order> searchResults = new OrderMapper().mapToApi(orderModels);
    JsonNode jsonOut = Json.toJson(searchResults);
    return ok(callback, jsonOut);

  }

  @TokenAuthorize(requiredPermission = PermissionType.WRITE)
  public Result deleteOrder(Long id) {
    OrderModel orderModel = new OrderService(currentApiUser().username).deleteOrder(id);
    Order order = new OrderMapper().mapToApi(orderModel);
    return ok(Json.toJson(order));
  }

  //@TokenAuthorize(requiredPermission = PermissionType.READ)
  public Result getOffshoreOrdersDate() {


    OrderService service = new OrderService(currentApiUser().username);
    DateTime tomorrow = new DateTime(PoseidonService.getTimeZone());
    tomorrow.plusDays(1);

    List<OrderModel> orderModels = service.getOrdersForDate(tomorrow);
    if (orderModels == null) throw new PoseidonException(Http.Status.INTERNAL_SERVER_ERROR, "Fann ingen ordrer");

    List<DPOrder> dpOrders = new DPOrderMapper().mapToApi(orderModels);

    return ok(Json.toJson(dpOrders));
  }

  //@TokenAuthorize(requiredPermission = PermissionType.READ)
  public Result getOffshoreOrders(Long date) {
    OrderService service = new OrderService(currentApiUser().username);
    DateTime tomorrow = new DateTime(date, PoseidonService.getTimeZone());

    List<OrderModel> orderModels = service.getOrdersForDate(tomorrow);
    if (orderModels == null) throw new PoseidonException(Http.Status.INTERNAL_SERVER_ERROR, "Fann ingen ordrer");

    List<DPOrder> dpOrders = new DPOrderMapper().mapToApi(orderModels);

    return ok(Json.toJson(dpOrders));
  }

  //@TokenAuthorize(requiredPermission = PermissionType.READ)
  public Result getActiveOrders() {
    List<ForecastModel> forecasts = new OrderService(currentApiUser().username).getActiveForecastsForSms();
    List<Forecast> activeForecasts = new ForecastMapper().mapToApi(forecasts);

    if ( activeForecasts != null && activeForecasts.size() >0) {
      for (Forecast activeForecast : activeForecasts) {
        OrderModel order = OrderModel.findByMetref(activeForecast.metref);

        if (order == null) throw new PoseidonException(Http.Status.INTERNAL_SERVER_ERROR, "Fant ikke bestilling");

        if (order.position == null)
          throw new PoseidonException(Http.Status.INTERNAL_SERVER_ERROR, "Bestilling uten posisjon: " + order.id);

        if (order.position.name == null || order.position.name.isEmpty())
          throw new PoseidonException(Http.Status.INTERNAL_SERVER_ERROR, "Bestilling med posisjon uten navn");

        QubaStation station = QubaStation.findStationByName(order.position.name);
        if (station == null) throw new PoseidonException(Http.Status.INTERNAL_SERVER_ERROR, "Fant ikke stasjon i Quba med navn " + order.position.name);

        activeForecast.stationid = station.stationid;


        activeForecast.latitude = order.position.latitude;
        activeForecast.longitude = order.position.longitude;

        activeForecast.posisjon = order.position_name != null && !order.position_name.isEmpty()?
            order.position_name:order.position.name;

        activeForecast.customer_name = order.customer.name;

        activeForecast.recipients = new ArrayList<>();
        for (RecipientModel recipient : order.recipients) {
          activeForecast.recipients.add(recipient.email);
        }
      }
    }

    JsonNode jsonOut = Json.toJson(activeForecasts);
    return ok(jsonOut);

  }

  public Result forecast(String callback) {
    JsonNode body = request().body().asJson();
    ObjectMapper mapper = new ObjectMapper();
    Forecast apiForecast;
    ForecastModel forecast =  null;
    try {
      apiForecast = mapper.readValue(body.toString(), Forecast.class);
    } catch (IOException e) {
      return badRequest("json post parameter parsing failure: " + e.getMessage());
    }

    if ( apiForecast.id > 0){
      forecast = ForecastModel.find.byId(apiForecast.id);
      if ( forecast != null ) {
          boolean modified = false;
          if ( apiForecast.failedAt != null ){
            forecast.failedAt = apiForecast.failedAt;
            forecast.failureReason = apiForecast.failureReason;
            modified = true;
          } else{
           if ( forecast.producedAt == null ) {
             forecast.producedAt = apiForecast.producedAt;
             forecast.failedAt = null;
             modified=true;
           }
          }
          if ( modified) {
            forecast.update();
          }
      }
    }

    JsonNode jsonOut = Json.toJson(new ForecastMapper().mapToApi(forecast));
    return ok(callback,jsonOut);
  }

}