OrderServiceTest.java

package service;

import api.v1.*;
import mapper.*;
import models.*;
import models.OrderStatus;
import org.joda.time.DateTime;
import org.junit.Test;
import models.CleanableOrderModel;
import quba.models.QubaStation;
import quba.models.QubaStationProfile;
import util.InMemoryDbTest;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

public class OrderServiceTest extends InMemoryDbTest {


  @Test
  public void testListAll() {
    OrderService service = new OrderService(fakeUser);
    List<OrderModel> orders = service.findAll();
    assertNotNull("orders null", orders);
    assertEquals("orderlist", 13, orders.size());
  }



  @Test
  public void testCreateOrder() {

    OrderService orderService = new OrderService(fakeUser);
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    try {
      orderService.setNow(new DateTime(sdf.parse("2015-11-07"),PoseidonService.getTimeZone()));
    } catch (ParseException e) { }


    Order aOrder = createOrder();


    OrderModel order = orderService.createOrUpdate(aOrder);

    assertNotNull("order", order);
    assertEquals("met_ref", aOrder.met_ref, order.met_ref);
    assertEquals("custref_contractnum", aOrder.custref_contractnum, order.custref_contractnum);
    assertEquals("custref_po_calloff", aOrder.custref_po_calloff, order.custref_po_calloff);
    assertEquals("custref_email", aOrder.custref_email, order.custref_email);
    assertEquals("customer_name", aOrder.customer_name, order.customer_name);
    assertEquals("customer_email",aOrder.customer_email,order.customer_email);
    assertEquals("customer_phone",aOrder.customer_phone,order.customer_phone);
    assertEquals("start_date1",aOrder.start_date1,order.start_date1);
    assertEquals("start_termin",aOrder.start_termin1,order.start_termin1);
    assertEquals("end_date1",aOrder.end_date1,order.end_date1);
    assertEquals("end_termin",aOrder.end_termin1,order.end_termin1);
    Termin[] actualTermins = OrderMapper.mapTerminsToApi(order.termins1);
    assertEquals("info_for_meteorologist", aOrder.info_for_meteorologist, order.info_for_meteorologist);
    assertEquals("termins length",aOrder.termins1.length, actualTermins.length);
    assertEquals("termins 0 hour",aOrder.termins1[0].hour, actualTermins[0].hour);
    assertEquals("termins 0 selected",aOrder.termins1[0].selected, actualTermins[0].selected);
    assertEquals("termins 3 hour",aOrder.termins1[3].hour, actualTermins[3].hour);
    assertEquals("termins 3 selected",aOrder.termins1[3].selected, actualTermins[3].selected);

    assertEquals("other_info",aOrder.other_info, order.other_info);
    assertEquals("info_for_meteorologist",aOrder.info_for_meteorologist, order.info_for_meteorologist);
    assertEquals("position_name",aOrder.position_name,order.position_name);
    assertNotNull("positon null", order.position);
    assertEquals("position.name", aOrder.position.name, order.position.name);
    assertEquals("position.latitude", aOrder.position.dec.getLatitude(), order.position.latitude,0.0001);
    assertEquals("position.longitude",aOrder.position.dec.getLongitude(),order.position.longitude,0.0001);

    assertNotNull("customer", order.customer);
    assertTrue("customer.id > 0", order.customer.id > 0);

    assertNotNull("recipients list null",order.recipients);
    assertEquals("recipients size", 2,order.recipients.size());

 }

  @Test
  public void testCreateOrderStartingSameDay() {

    OrderService orderService = new OrderService(fakeUser);
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    try {
      orderService.setNow(new DateTime(sdf.parse("2015-11-07"),PoseidonService.getTimeZone()).withHourOfDay(12));
    } catch (ParseException e) { }


    Order aOrder = new Order();
    aOrder.customer_email = "test@example.com";
    aOrder.customer_name = "Test";
    aOrder.customer_phone = "123";

    CustomerModel customerModel = new CustomerService(fakeUser).getById(1L);
    Customer customer = new CustomerMapper().mapToApi(customerModel);
    aOrder.customer = customer;

    aOrder.custref_po_calloff = "32123";
    aOrder.met_ref = "111222";

    aOrder.start_date1 = orderService.getNow().toDate();
    aOrder.start_termin1= 3;

    aOrder.end_date1 = orderService.getNow().plusDays(7).toDate();
    aOrder.end_termin1=21;

    aOrder.termins1 = new Termin[8];
    for (int i = 0; i < aOrder.termins1.length; i++) {
      aOrder.termins1[i] = new Termin(i * 3, false);
    }
    aOrder.termins1[3].selected = true; // kl 9
    aOrder.termins1[4].selected = true; // kl 12
    aOrder.termins1[6].selected = true; // kl 18

    aOrder.info_for_meteorologist = "Bla bla";
    aOrder.other_info = "More bla bla";

    PositionModel positionModel = new PositionService(fakeUser).getById(2L); // Gullfaks
    Position position = new PositionMapper().mapToApi(positionModel);

    aOrder.position = position;

    aOrder.recipients = new ArrayList<>();

    RecipientModel recipient1 = RecipientModel.find.byId(1L);
    RecipientMapper recipientMapper = new RecipientMapper();

    aOrder.recipients.add(recipientMapper.mapToApi(recipient1));

    OrderModel order = orderService.createOrUpdate(aOrder);

    assertNotNull("order", order);
    assertEquals("met_ref", aOrder.met_ref, order.met_ref);

    QubaStation station = QubaStation.findStationByName(order.position.name);
    assertNotNull("Fant ikke station i quba", station);

    List<QubaStationProfile> profiles = QubaStationProfile.findAllProfilesForStation(station.stationid);
    assertNotNull("Fant ikke stationprofiles i quba", profiles);

    assertEquals("Uventet antall stasjonsprofiler", 5,profiles.size());

  }

  @Test
  public void testSearch(){
    OrderService service = new OrderService(fakeUser);
    OrderSearch params = new OrderSearch();

    params.met_ref = "123";
    List<OrderModel> searchResult = service.search(params);

    assertNotNull("search result", searchResult);
    assertEquals("result size",2,searchResult.size());
  }

  @Test
  public void testSearchNotCaseSensitive(){
    OrderService service = new OrderService(fakeUser);
    OrderSearch params = new OrderSearch();

    params.position_name = "gull";
    List<OrderModel> searchResult = service.search(params);

    assertNotNull("null søkeresultat", searchResult);
    assertEquals("Uventet antall ordre på posisjonen", 2, searchResult.size());
    assertEquals("Gullfaks","Gullfaks",searchResult.get(0).position.name);

  }

  @Test
  public void testSearchStatusNew(){
    OrderService service = new OrderService(fakeUser);
    OrderSearch params = new OrderSearch();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    try {
      service.setNow(new DateTime(sdf.parse("2015-09-01"),PoseidonService.getTimeZone()));
    } catch (ParseException e) { }

    params.status = "new";
    List<OrderModel> searchResult = service.search(params);

    assertNotNull("search result", searchResult);
    assertEquals("Uventet antall nye bestillinger", 7, searchResult.size());
    assertEquals("Uventet status på bestilling med index 0", OrderStatus.NEW,searchResult.get(0).orderStatus);
    assertEquals("Uventet status på bestilling med index 1", OrderStatus.NEW,searchResult.get(1).orderStatus);
    assertEquals("Uventet status på bestilling med index 2", OrderStatus.NEW,searchResult.get(2).orderStatus);

  }

  @Test
  public void testSearchStatusActive(){
    OrderService service = new OrderService(fakeUser);
    OrderSearch params = new OrderSearch();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    try {
      service.setNow(new DateTime(sdf.parse("2015-11-02"),PoseidonService.getTimeZone()));
    } catch (ParseException e) { }

    params.status = "active";
    List<OrderModel> searchResult = service.search(params);

    assertNotNull("search result", searchResult);
    assertEquals("Two results", 2, searchResult.size());
    assertEquals("Status active", OrderStatus.ACTIVE,searchResult.get(0).orderStatus);

  }

  @Test
  public void testSearchStatusExpired(){
    OrderService service = new OrderService(fakeUser);
    OrderSearch params = new OrderSearch();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    try {
      service.setNow(new DateTime(sdf.parse("2015-11-02"),PoseidonService.getTimeZone()));
    } catch (ParseException e) { }

    params.status = "expired";
    List<OrderModel> searchResult = service.search(params);

    assertNotNull("search result", searchResult);
    assertEquals("", 4, searchResult.size());
    assertEquals("Status expired", OrderStatus.EXPIRED,searchResult.get(0).orderStatus);
    assertEquals("Status expired", OrderStatus.EXPIRED,searchResult.get(1).orderStatus);

  }

  @Test
  public void testSearchActiveTodayOnly(){
    OrderService service = new OrderService(fakeUser);
    OrderSearch params = new OrderSearch();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    try {
      service.setNow(new DateTime(sdf.parse("2015-10-14"),PoseidonService.getTimeZone()));
    } catch (ParseException e) { }

    params.status = "active";
    List<OrderModel> searchResult = service.search(params);

    assertNotNull("search result", searchResult);
    assertEquals("", 2, searchResult.size());
    assertEquals("Status active", OrderStatus.ACTIVE,searchResult.get(0).orderStatus);

  }

  @Test
  public void testSearchRecipients(){
    OrderService service = new OrderService(fakeUser);
    OrderSearch params = new OrderSearch();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    try {
      service.setNow(new DateTime(sdf.parse("2015-10-14"),PoseidonService.getTimeZone()));
    } catch (ParseException e) { }

    params.recipient_email = "leifj";
    List<OrderModel> searchResult = service.search(params);

    assertNotNull("search result", searchResult);
    assertEquals("", 7, searchResult.size());

  }

  @Test
  public void testSearchNoPosition(){
    OrderService service = new OrderService(fakeUser);
    OrderSearch params = new OrderSearch();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    try {
      service.setNow(new DateTime(sdf.parse("2015-10-14"),PoseidonService.getTimeZone()));
    } catch (ParseException e) { }

    params.met_ref = "no_pos";
    List<OrderModel> searchResult = service.search(params);

    assertNotNull("search result", searchResult);
    assertEquals("", 1, searchResult.size());
    assertNull("Posisjon er uventet ikke null",  searchResult.get(0).position);

  }

  @Test
  public void testGetByDateTermin() {
    OrderService service = new OrderService(fakeUser);

    DateTime date = new DateTime(2013,12,16,0,0, PoseidonService.getTimeZone());

    List<OrderModel> orders = service.getByDateTermin(date, 3);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 3)", 0, orders.size());

    orders = service.getByDateTermin(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 9)", 1, orders.size());

    orders = service.getByDateTermin(date, 12);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 12)", 0, orders.size());


    date = new DateTime(2013,12,17,0,0, PoseidonService.getTimeZone());
    orders = service.getByDateTermin(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 6)", 1, orders.size());

    orders = service.getByDateTermin(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 9)", 1, orders.size());

    orders = service.getByDateTermin(date, 18);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 18)", 1, orders.size());

    date = new DateTime(2013,12,18,0,0, PoseidonService.getTimeZone());
    orders = service.getByDateTermin(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 6)", 1, orders.size());

    orders = service.getByDateTermin(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 9)", 1, orders.size());

    orders = service.getByDateTermin(date, 18);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 18)", 0, orders.size());

    date = new DateTime(2013,12,19,0,0, PoseidonService.getTimeZone());
    orders = service.getByDateTermin(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size (after period 3, termin 6)", 0, orders.size());

    orders = service.getByDateTermin(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size (period 1, termin 9)", 1, orders.size());

    date = new DateTime(2013,12,20,0,0, PoseidonService.getTimeZone());
    orders = service.getByDateTermin(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size (period 1, termin 9)", 1, orders.size());

  }

  @Test
  public void testGetOrdersForStartDatePeriod1() {
    DateTime date = new DateTime(2013,12,01,0,0, PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);

    List<OrderModel> orders = service.getOrdersForStartDate(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size", 0, orders.size());

    orders = service.getOrdersForStartDate(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size", 1, orders.size());

    orders = service.getOrdersForStartDate(date, 12);
    assertNotNull("orders", orders);
    assertEquals("result size", 0, orders.size());

    orders = service.getOrdersForStartDate(date, 18);
    assertNotNull("orders", orders);
    assertEquals("result size", 1, orders.size());
  }

  @Test
  public void testGetOrdersForStartDatePeriod2() {
    DateTime date = new DateTime(2013,12,07,0,0, PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);

    List<OrderModel> orders = service.getOrdersForStartDate(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size", 0, orders.size());

    orders = service.getOrdersForStartDate(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size", 1, orders.size());

    orders = service.getOrdersForStartDate(date, 12);
    assertNotNull("orders", orders);
    assertEquals("result size", 0, orders.size());

    orders = service.getOrdersForStartDate(date, 18);
    assertNotNull("orders", orders);
    assertEquals("result size", 1, orders.size());
  }

  @Test
  public void testGetOrdersForStartDatePeriod3() {
    DateTime date = new DateTime(2013,12,16,0,0, PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);

    List<OrderModel> orders = service.getOrdersForStartDate(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size", 0, orders.size());

    orders = service.getOrdersForStartDate(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size", 1, orders.size());

    orders = service.getOrdersForStartDate(date, 12);
    assertNotNull("orders", orders);
    assertEquals("result size", 0, orders.size());

    orders = service.getOrdersForStartDate(date, 18);
    assertNotNull("orders", orders);
    assertEquals("result size", 1, orders.size());
  }

  @Test
  public void testGetOrdersForEndDatePeriod1() {
    DateTime date = new DateTime(2013,12,3,0,0, PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);

    List<OrderModel> orders = service.getOrdersForEndDate(date, 3);
    assertNotNull("orders", orders);
    assertEquals("result size (period 1, termin 3)", 0, orders.size());

    orders = service.getOrdersForEndDate(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size (period 1, termin 6)", 1, orders.size());

    orders = service.getOrdersForEndDate(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size (period 1, termin 9)", 1, orders.size());

    orders = service.getOrdersForEndDate(date, 12);
    assertNotNull("orders", orders);
    assertEquals("result size (period 1, termin 12)", 0, orders.size());

    orders = service.getOrdersForEndDate(date, 18);
    assertNotNull("orders", orders);
    assertEquals("result size (period 1, termin 18)", 0, orders.size());
  }

  @Test
  public void testGetOrdersForEndDatePeriod2() {
    DateTime date = new DateTime(2013,12,9,0,0, PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);

    List<OrderModel> orders = service.getOrdersForEndDate(date, 3);
    assertNotNull("orders", orders);
    assertEquals("result size (period 2, termin 3)", 0, orders.size());

    orders = service.getOrdersForEndDate(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size (period 2, termin 6) ", 1, orders.size());

    orders = service.getOrdersForEndDate(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size (period 2, termin 9)", 1, orders.size());

    orders = service.getOrdersForEndDate(date, 12);
    assertNotNull("orders", orders);
    assertEquals("result size (period 2, termin 12)", 0, orders.size());

    orders = service.getOrdersForEndDate(date, 18);
    assertNotNull("orders", orders);
    assertEquals("result size (period 2, termin 18)", 0, orders.size());
  }

  @Test
  public void testGetOrdersForEndDatePeriod3() {
    DateTime date = new DateTime(2013,12,18,0,0, PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);

    List<OrderModel> orders = service.getOrdersForEndDate(date, 3);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 3)", 0, orders.size());

    orders = service.getOrdersForEndDate(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 6) ", 1, orders.size());

    orders = service.getOrdersForEndDate(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 9)", 1, orders.size());

    orders = service.getOrdersForEndDate(date, 12);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 12)", 0, orders.size());

    orders = service.getOrdersForEndDate(date, 18);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3, termin 18)", 0, orders.size());
  }

  @Test
  public void testGetOrdersForDate() {
    DateTime date = new DateTime(2013,12,11,0,0, PoseidonService.getTimeZone());
    DateTime now = new DateTime(PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);
    List<OrderModel> orders = service.getOrdersForDate(now);
    System.out.println("orders: "+orders.size());
    assertNotNull("orders", orders);
  }

  @Test
  public void testGetOrdersForPeriod() {
    DateTime date = new DateTime(2013,12,11,0,0, PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);

    List<OrderModel> orders = service.getOrdersForPeriod(date, 0);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3-1, termin 0)", 0, orders.size());

    orders = service.getOrdersForPeriod(date, 3);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3-1, termin 3)", 0, orders.size());

    orders = service.getOrdersForPeriod(date, 6);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3-1, termin 6)", 1, orders.size());

    orders = service.getOrdersForPeriod(date, 9);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3-1, termin 9)", 1, orders.size());

    orders = service.getOrdersForPeriod(date, 12);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3-1, termin 12)", 0, orders.size());

    orders = service.getOrdersForPeriod(date, 15);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3-1, termin 15)", 0, orders.size());

    orders = service.getOrdersForPeriod(date, 18);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3-1, termin 18)", 1, orders.size());

    orders = service.getOrdersForPeriod(date, 21);
    assertNotNull("orders", orders);
    assertEquals("result size (period 3-1, termin 21)", 0, orders.size());
  }

  @Test
  public void testGetDeletableQubaOrders(){
    DateTime date = new DateTime(2015,12,7,0,0,PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);

    List<CleanableOrderModel> orders = service.getCleanableQubaOrders(date);

    assertNotNull("no orders", orders);
    assertTrue("cleanable orders empty",!orders.isEmpty());
    assertEquals("One cleanable order",1,orders.size());
    assertEquals("Posisjonsnavn","Oseberg Sør",orders.get(0).getPositionName());

  }

  @Test
  public void testGetActiveOrdersTomorrowForQba() throws Exception {
    DateTime now = new DateTime(2015,12,7,0,0,PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);
    service.setNow(now);

    DateTime date = new DateTime(2015,12,7,12,0,PoseidonService.getTimeZone());
    List<OrderModel> orders = service.getActiveOrdersTomorrowForQba(date);

    assertNotNull("no active orders", orders);
    assertTrue("active orders empty",!orders.isEmpty());
    assertEquals("One active order",3,orders.size());
    assertEquals("Posisjonsnavn","Oseberg",orders.get(0).position.name);

  }

  @Test
  public void testSaveOrderBeforeAfterQubaSyncForNextDay(){
    DateTime now = new DateTime(2016,2,26,15,2,PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);
    service.setNow(now);

    int start_termin = 9;
    DateTime start = new DateTime(2016,2,27, start_termin,0,PoseidonService.getTimeZone());
    DateTime end = new DateTime(2016,3,27, 21 ,0,PoseidonService.getTimeZone());
    String posisjon = "Gullfaks";

    Order order = createOrder(start,end, posisjon);
    order.start_termin1 = start_termin;
    ProductModel offshoreByMetNo= ProductModel.findByName(PoseidonPropertyService.getProperty("order.default_productname"));
    order.start_termin1 = start_termin;
    order.product = new ProductMapper().mapToApi(offshoreByMetNo);

    service.createOrUpdate(order);

    QubaStation station = QubaStation.findStationByName(posisjon);

    assertNotNull("Posisjon finnes ikke i Quba", station);

    // sjekk at alle terminer for morgendagen finnes i stationprofile
    for (Termin termin : order.termins1) {
      if ( termin.selected) {
        QubaStationProfile sp = QubaStationProfile.findStProfileByStationAndSession(station.stationid, termin.hour);
        assertNotNull("StationProfile finnes ikke i Quba", sp);
      }
    }

  }

  @Test
  public void testSaveOrderWithNoPositionBeforeAfterQubaSyncForNextDay(){
    DateTime now = new DateTime(2016,2,26,15,2,PoseidonService.getTimeZone());
    OrderService service = new OrderService(fakeUser);
    service.setNow(now);

    int start_termin = 9;
    DateTime start = new DateTime(2016,2,27, start_termin,0,PoseidonService.getTimeZone());
    DateTime end = new DateTime(2016,3,27, 21 ,0,PoseidonService.getTimeZone());

    ProductModel africaProduct = ProductModel.findByName("Africa");

    Order order = createOrder(start,end, null);
    order.start_termin1 = start_termin;
    order.product = new ProductMapper().mapToApi(africaProduct);

    service.createOrUpdate(order);

    assertTrue(true);
  }


  private Order createOrder() {
    DateTime start_date1 = DateTime.now();
    DateTime end_date1 = DateTime.now();
    String posisjon = "Ekofisk";
    return createOrder(start_date1,end_date1,posisjon);
  }

  private Order createOrder(DateTime start_date1, DateTime end_date1, String posisjon) {

    Order aOrder = new Order();

    aOrder.customer_email = "test@example.com";
    aOrder.customer_name = "Test";
    aOrder.customer_phone = "123";


    CustomerModel customerModel = new CustomerService(fakeUser).getById(1L);
    Customer customer = new CustomerMapper().mapToApi(customerModel);
    aOrder.customer = customer;

    aOrder.custref_po_calloff = "32123";
    aOrder.met_ref = "111222";

    aOrder.start_date1 = start_date1.toDate();
    aOrder.start_termin1= 3;

    aOrder.end_date1 = end_date1.toDate();
    aOrder.end_termin1=21;

    aOrder.info_for_meteorologist = "Bla bla";
    aOrder.other_info = "More bla bla";

    for(int i=0;i<aOrder.termins1.length;i++){
      aOrder.termins1[i] = new Termin(i*3,i%3==0);
    }

    if ( posisjon != null ) {
      PositionModel positionModel = new PositionService(fakeUser).findByName(posisjon);
      Position position = new PositionMapper().mapToApi(positionModel);

      aOrder.position = position;
    }

    aOrder.recipients = new ArrayList<>();

    RecipientModel recipient1 = RecipientModel.find.byId(1L);
    RecipientModel recipient2 = RecipientModel.find.byId(2L);
    RecipientMapper recipientMapper = new RecipientMapper();

    aOrder.recipients.add(recipientMapper.mapToApi(recipient1));
    aOrder.recipients.add(recipientMapper.mapToApi(recipient2));
    return aOrder;
  }

}