QubaService.java

package quba.service;

import models.CleanableOrderModel;
import models.OrderModel;
import models.PositionModel;
import org.joda.time.DateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import service.OrderService;
import service.PoseidonService;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class QubaService extends PoseidonService {

  private final OrderService orderService = new OrderService("akka");
  private final static Logger logger = LoggerFactory.getLogger(QubaService.class);

  public QubaService(String user) {
    super(user);
  }

  public QubaSyncSummary copyPositions() {

    logger.info("Starter QubaService.copyPositions");
    QubaSyncSummary result = new QubaSyncSummary();

    DateTime now = getNow();
    List<OrderModel> orders = orderService.getActiveOrdersTomorrowForQba(now);

    Map<PositionModel, Set<Integer>> positionTerminMap = new HashMap<>();

    if (orders != null && orders.size() > 0) {

      result.activeOrders = orders.size();
      result.orders = orders;

      logger.info("Fant {} aktive ordre", result.activeOrders);

      DateTime tomorrow = now.plusDays(1);
      for (OrderModel o : orders) {

        Set<Integer> termins = o.getActiveTerminsForDayContainingTimestamp(tomorrow);
        logger.info("Order {} har følgende aktive terminer: {} ", o.id, termins);

        if (!positionTerminMap.containsKey(o.position)) {
          positionTerminMap.put(o.position, termins);
        } else {
          Set<Integer> positiontermins = positionTerminMap.get(o.position);
          positiontermins.addAll(termins);
          positionTerminMap.put(o.position, positiontermins);
        }
      }


      syncPositions(positionTerminMap, result);

      result.positions = positionTerminMap.keySet();
      result.positionsSynced = positionTerminMap.keySet().size();

    } else {
      logger.info("Fant ingen aktive ordre");
    }
    logger.info("QubaService.copyPositions ferdig");
    return result;
  }

  private void syncPositions(Map<PositionModel, Set<Integer>> positionTermins, QubaSyncSummary result) {
    logger.info("Synker {} posisjoner", positionTermins.keySet().size());
    QubaPositionSyncer syncer = new QubaPositionSyncer(result);
    for (PositionModel p : positionTermins.keySet()) {
      Set<Integer> termins = positionTermins.get(p);
      syncer.syncPosition(p, termins);
    }

  }

  public int cleanupPositions() {
    logger.info("Starter QubaService.cleanupPositions");
    int result = 0;
    DateTime now = new DateTime(PoseidonService.getTimeZone()).withTimeAtStartOfDay();

    List<CleanableOrderModel> orders = orderService.getCleanableQubaOrders(now);

    if (orders != null && orders.size() > 0) {
      QubaPositionCleaner cleaner = new QubaPositionCleaner();

      logger.info("Sjekker om {} ordre skal fjernes fra Quba", orders.size());
      for (CleanableOrderModel order : orders) {
        cleaner.cleanPosition(order, now);
      }
      result = orders.size();
    }
    logger.info("QubaService.cleanupPositions ferdig");
    return result;
  }


  public static boolean qubaHasDataForPositionAndTermin(String name, DateTime dateOfProduction, Integer termin) {
    QubaSubjectiveFetcher fetcher = new QubaSubjectiveFetcher();
    return fetcher.fetchSubjective(name, dateOfProduction, termin);
  }

  public static boolean fetchStrongWindWarning(String position_name, DateTime date, Integer termin) {
    return new QubaWindWarningFetcher().fetchWarning(position_name, date, termin);
  }

  public String terminsList(Set<Integer>termins){
    if ( termins == null || termins.size() == 0) return "";

    StringBuffer sb = new StringBuffer();

    for (Integer termin : termins) {

      if ( termin != null) {
        sb.append(termin).append(",");
      }
    }

    String list = sb.toString();

    if ( list != null && !list.isEmpty()) {
      return list.substring(0, list.length() - 1); // remove last comma
    } else return "";

  }
}