CustomerService.java

package service;

import api.v1.Customer;
import com.avaje.ebean.Expr;
import exceptions.PoseidonException;
import kundedb.models.Kunde;
import kundedb.service.KundedbService;
import mapper.CustomerMapper;
import models.CustomerModel;
import models.OrderModel;
import org.joda.time.DateTime;
import play.mvc.Http;
import validators.CustomerValidator;
import validators.ValidationResult;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class CustomerService extends PoseidonService {

  public CustomerService(String username) {
    super(username);
  }

  public List<CustomerModel> findAll() {
    return CustomerModel.find.all();
  }

  public CustomerModel getById(long id) {
    return CustomerModel.find.byId(id);
  }

  public CustomerModel findByName(String name) {
    return CustomerModel.find.where().ieq("name", name).findUnique();
  }

  public CustomerModel createOrUpdate(Customer apiCustomer) {
    CustomerModel mCustomer = null;
    if ((apiCustomer.id != null) && (apiCustomer.id > 0)) {
      mCustomer = getById(apiCustomer.id);
      mCustomer.updated = PoseidonService.getNow().toDate();
      mCustomer.updatedBy = getUser();
    } else {
      mCustomer = new CustomerModel();
      mCustomer.created = PoseidonService.getNow().toDate();
      mCustomer.createdBy = getUser();
    }
    mCustomer = new CustomerMapper().mapToModel(apiCustomer, mCustomer);

    ValidationResult validationResult = new CustomerValidator().validateModel(mCustomer);
    if (!validationResult.ok) {
      throw new PoseidonException(Http.Status.BAD_REQUEST, "Validering av kunde feilet: " + validationResult.getMessage());
    }

    mCustomer.save();

    syncCustomerToKundeDb(mCustomer);

    return mCustomer;
  }

  private void syncCustomerToKundeDb(CustomerModel mCustomer) {
    DateTime now = new DateTime(PoseidonService.getTimeZone());
    String startHourProp = PoseidonPropertyService.getProperty("kundedbsync.start_hour");
    int startHour = Integer.valueOf(startHourProp);
    if ( now.getHourOfDay() >= startHour){
      KundedbService service = new KundedbService(getUser());
      service.syncKundeImmediately(mCustomer);
    }
  }


  public List<OrderModel> getOrdersForCustomer(Long id) {
    List<OrderModel> orders = OrderModel.find.fetch("customer").fetch("position").where().eq("customer_id", id).findList();
    if (orders != null) {
      List<OrderModel> nonDeletedOrders = new ArrayList<>();

      for (OrderModel model : orders) {
        model.assignStatus(getNow());
        if (!model.isDeleted()) {
          nonDeletedOrders.add(model);
        }
      }
      return nonDeletedOrders;
    }
    return orders;
  }

  public List<CustomerModel> findNewOrUpdatedCustomersSince(DateTime yesterday) {
    List<CustomerModel> result = CustomerModel.find.where().or(
         Expr.gt("created",yesterday),
         Expr.gt("updated",yesterday)
    ).findList();
    return result;
  }

  public CustomerModel checkCustomerExists(Customer apiCustomer) {
    CustomerModel customermodel=null;
    Kunde kunde = null;

    if ( apiCustomer.name != null && !apiCustomer.name.isEmpty()) {
      customermodel = CustomerModel.findByName(apiCustomer.name);
    }
    if ( customermodel != null) {
      throw new PoseidonException(Http.Status.BAD_REQUEST,"Navn " + apiCustomer.name + " finnes allerede");
    }

    if ( apiCustomer.username != null && !apiCustomer.username.isEmpty()) {
      customermodel = CustomerModel.findByUserName(apiCustomer.username);
    }

    if ( customermodel != null) {
      throw new PoseidonException(Http.Status.BAD_REQUEST,"Brukernavn " + apiCustomer.username + " finnes allerede");
    }

    if ( apiCustomer.name != null && !apiCustomer.name.isEmpty()){
      kunde = Kunde.findKundeByName(apiCustomer.name);
    }
    if ( kunde != null) {
      throw new PoseidonException(Http.Status.BAD_REQUEST,"Kundedb: Navn " + apiCustomer.name + " finnes allerede");
    }

    if ( apiCustomer.username != null && !apiCustomer.username.isEmpty()){
      kunde = Kunde.findKundeByBrukernavn(apiCustomer.username);
    }

    if ( kunde != null) {
      throw new PoseidonException(Http.Status.BAD_REQUEST,"Kundedb: Brukernavn " + apiCustomer.username + " finnes allerede");
    }
    return null;
  }
}