Order

package ordertracker;

import com.google.common.base.MoreObjects;
import com.google.common.base.Optional;
import java.io.Serializable;
import java.lang.Class;
import java.lang.IllegalAccessException;
import java.lang.IllegalArgumentException;
import java.lang.InstantiationException;
import java.lang.Integer;
import java.lang.NullPointerException;
import java.lang.Override;
import java.lang.SecurityException;
import java.lang.String;
import java.lang.SuppressWarnings;
import java.lang.System;
import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.ManyToOne;
import javax.persistence.PrePersist;
import javax.persistence.PreUpdate;
import javax.persistence.Table;
import javax.persistence.Transient;
import ordertracker.Depot;
import scala.concurrent.duration.Duration;
import xuml.tools.model.compiler.runtime.BehaviourFactoryNotSetException;
import xuml.tools.model.compiler.runtime.CreationEvent;
import xuml.tools.model.compiler.runtime.EntityHelper;
import xuml.tools.model.compiler.runtime.Event;
import xuml.tools.model.compiler.runtime.Signaller;
import xuml.tools.model.compiler.runtime.ValidationException;
import xuml.tools.model.compiler.runtime.query.BooleanExpression;
import xuml.tools.model.compiler.runtime.query.NumericExpressionField;
import xuml.tools.model.compiler.runtime.query.SelectBuilder;
import xuml.tools.model.compiler.runtime.query.StringExpressionField;

/**
 *
 */
@Entity
@Table(schema="ordertracker", name="order_1")
public class Order implements xuml.tools.model.compiler.runtime.Entity<Order> {

    /**
     * No argument constructor required by JPA.
     */
    public Order(){
        //JPA requires no-arg constructor
        if (_behaviourFactory == null) {
            throw new BehaviourFactoryNotSetException("Order does not have a BehaviourFactory set. Use Order.setBehaviourFactory in your App class (one-time setup).");
        }
        _behaviour = _behaviourFactory.create(this);
    }

    /**
     * If behaviour is not explicitly specified then the
     * behaviour factory is used to create behaviour.
     */
    private static volatile BehaviourFactory _behaviourFactory;

    /**
     * All actions like onEntry actions and defined
     * operations are performed by this Behaviour class.
     */
    @Transient
    private Behaviour _behaviour;

    /**
     * Sets the BehaviourFactory for all instances of
     * this class. It will only be used when Behaviour
     * is not explicitly provided in the constructor.
     */
    public static void setBehaviourFactory(BehaviourFactory factory){
        _behaviourFactory = factory;
    }

    /**
     * Sets the BehaviourFactory for all instances of
     * this class using the given Behaviour class as the base. It will only be used when Behaviour
     * is not explicitly provided in the constructor.
     */
    public static void setBehaviourFactory(Class<? extends Behaviour> cls){
        _behaviourFactory = createBehaviourFactory(cls);
    }

    /**
     * Returns the singleton BehaviourFactory for this.
     */
    public static BehaviourFactory getBehaviourFactory(){
        return _behaviourFactory;
    }

    /**
     * Constructor using id.
     */
    public Order(String id) {
        this.id = id;
    }

    /**
     * Static creator method using id.
     */
    public static Order create(String id) {
        return new Order(id);
    }

    /**
     * Static creator method using CreationEvent.
     */
    public static Order create(CreationEvent<Order> creationEvent) {
        return Context.create(Order.class, creationEvent);
    }

    /**
     * The signaller used by the current Context. It will
     * get injected into the EntityHelper.
     */
    private static Signaller signaller;

    /**
     * Sets the Signaller to be used by the EntityHelper.
     */
    static void setSignaller_(Signaller sig) {
        signaller = sig;
    }

    /**
     * Helper for this class.
     */
    @Transient
    private EntityHelper _helper;

    /**
     * Returns the Helper for this instance.
     */
    public synchronized EntityHelper helper() {
        if (_helper==null)
            _helper = new EntityHelper(signaller,this);
        return _helper;
    }

    /**
     * Primary identifier
     */
    @Id
    @Column(name="order_id", nullable=false,length=2048)
    private String id = new String("");

    /**
     * Returns a unique id for this instance as a String.
     * Used for synchronizing access to entities.
     */
    @Override
    public String uniqueId(){
        return Order.class.getName() + ":" + getId();
    }

    @Column(name="description", nullable=false,length=4096)
    private String description = new String("");

    /**
     * Validates description against type constraints.
     */
    private void validateDescription() {
        if (description == null || description.length() < 1)
            throw new ValidationException("min length constraint not met");
         if (description == null || !description.startsWith(""))
            throw new ValidationException("prefix constraint not met");
        if (description == null || !description.endsWith(""))
            throw new ValidationException("suffix constraint not met");
        if (description == null || !Pattern.matches(".*", description))
            throw new ValidationException("validation pattern constraint not met");
    }

    @Column(name="from_address", nullable=false,length=4096)
    private String fromAddress = new String("");

    /**
     * Validates fromAddress against type constraints.
     */
    private void validateFromAddress() {
        if (fromAddress == null || fromAddress.length() < 1)
            throw new ValidationException("min length constraint not met");
         if (fromAddress == null || !fromAddress.startsWith(""))
            throw new ValidationException("prefix constraint not met");
        if (fromAddress == null || !fromAddress.endsWith(""))
            throw new ValidationException("suffix constraint not met");
        if (fromAddress == null || !Pattern.matches(".*", fromAddress))
            throw new ValidationException("validation pattern constraint not met");
    }

    @Column(name="to_address", nullable=false,length=4096)
    private String toAddress = new String("");

    /**
     * Validates toAddress against type constraints.
     */
    private void validateToAddress() {
        if (toAddress == null || toAddress.length() < 1)
            throw new ValidationException("min length constraint not met");
         if (toAddress == null || !toAddress.startsWith(""))
            throw new ValidationException("prefix constraint not met");
        if (toAddress == null || !toAddress.endsWith(""))
            throw new ValidationException("suffix constraint not met");
        if (toAddress == null || !Pattern.matches(".*", toAddress))
            throw new ValidationException("validation pattern constraint not met");
    }

    @Column(name="destination_email", nullable=false,length=512)
    private String destinationEmail = new String("");

    /**
     * Validates destinationEmail against type constraints.
     */
    private void validateDestinationEmail() {
        if (destinationEmail == null || destinationEmail.length() < 1)
            throw new ValidationException("min length constraint not met");
         if (destinationEmail == null || !destinationEmail.startsWith(""))
            throw new ValidationException("prefix constraint not met");
        if (destinationEmail == null || !destinationEmail.endsWith(""))
            throw new ValidationException("suffix constraint not met");
        if (destinationEmail == null || !Pattern.matches(".*", destinationEmail))
            throw new ValidationException("validation pattern constraint not met");
    }

    @Column(name="sender_email", nullable=false,length=512)
    private String senderEmail = new String("");

    /**
     * Validates senderEmail against type constraints.
     */
    private void validateSenderEmail() {
        if (senderEmail == null || senderEmail.length() < 1)
            throw new ValidationException("min length constraint not met");
         if (senderEmail == null || !senderEmail.startsWith(""))
            throw new ValidationException("prefix constraint not met");
        if (senderEmail == null || !senderEmail.endsWith(""))
            throw new ValidationException("suffix constraint not met");
        if (senderEmail == null || !Pattern.matches(".*", senderEmail))
            throw new ValidationException("validation pattern constraint not met");
    }

    @Column(name="max_attempts", nullable=false)
    private Integer maxAttempts = new Integer("0");

    private static final BigDecimal MAXATTEMPTS_UPPER_LIMIT=new BigDecimal("1000");
    private static final BigDecimal MAXATTEMPTS_LOWER_LIMIT=new BigDecimal("0");

    /**
     * Validates maxAttempts against type constraints.
     */
    private void validateMaxAttempts() {
        if (MAXATTEMPTS_UPPER_LIMIT.doubleValue() < maxAttempts)
            throw new ValidationException("upper limit of 1000 failed");
        if (MAXATTEMPTS_LOWER_LIMIT.doubleValue() > maxAttempts)
             throw new ValidationException("lower limit of 0 failed");
    }

    @Column(name="attempts", nullable=false)
    private Integer attempts = new Integer("0");

    private static final BigDecimal ATTEMPTS_UPPER_LIMIT=new BigDecimal("1000");
    private static final BigDecimal ATTEMPTS_LOWER_LIMIT=new BigDecimal("0");

    /**
     * Validates attempts against type constraints.
     */
    private void validateAttempts() {
        if (ATTEMPTS_UPPER_LIMIT.doubleValue() < attempts)
            throw new ValidationException("upper limit of 1000 failed");
        if (ATTEMPTS_LOWER_LIMIT.doubleValue() > attempts)
             throw new ValidationException("lower limit of 0 failed");
    }

    @Column(name="comment_1", nullable=false,length=4096)
    private String comment = new String("");

    /**
     * Validates comment against type constraints.
     */
    private void validateComment() {
        if (comment == null || comment.length() < 1)
            throw new ValidationException("min length constraint not met");
         if (comment == null || !comment.startsWith(""))
            throw new ValidationException("prefix constraint not met");
        if (comment == null || !comment.endsWith(""))
            throw new ValidationException("suffix constraint not met");
        if (comment == null || !Pattern.matches(".*", comment))
            throw new ValidationException("validation pattern constraint not met");
    }

    @Column(name="status_1", nullable=false,length=4096)
    private String status = new String("Preparing");

    /**
     * Validates status against type constraints.
     */
    private void validateStatus() {
        if (status == null || status.length() < 1)
            throw new ValidationException("min length constraint not met");
         if (status == null || !status.startsWith(""))
            throw new ValidationException("prefix constraint not met");
        if (status == null || !status.endsWith(""))
            throw new ValidationException("suffix constraint not met");
        if (status == null || !Pattern.matches(".*", status))
            throw new ValidationException("validation pattern constraint not met");
    }

    /**
     * For internal use only by the state machine but is persisted by the jpa provider.
     */
    @Column(name="state",nullable=false)
    private String state;

    /**
     * MANY Order was last at ZERO_ONE Depot
     */
    @ManyToOne(targetEntity=Depot.class, fetch=FetchType.LAZY)
    @JoinColumns(value={
        @JoinColumn(name="last_depot", referencedColumnName="depot_id", nullable=true, insertable=true, updatable=true)})
    private Depot depot_R1;

    /**
     * Getter. MANY Order was last at ZERO_ONE Depot
     */
    public Depot getDepot_R1(){
        return depot_R1;
    }

    /**
     * Setter. MANY Order was last at ZERO_ONE Depot
     */
    public void setDepot_R1(Depot depot_R1){
        this.depot_R1=depot_R1;
    }

    /**
     * MANY Order was last at ZERO_ONE Depot
     */
    public Order relateAcrossR1(Depot depot_R1) {
        setDepot_R1(depot_R1);
        return this;
    }

    /**
     * MANY Order was last at ZERO_ONE Depot
     */
    public Order unrelateAcrossR1(Depot depot_R1) {
        setDepot_R1(null);
        depot_R1.getOrder_R1().remove(this);
        return this;
    }

    /**
     * Calls all validation methods just before updating database.
     */
    @PreUpdate
    void validateBeforeUpdate(){
        validateAttempts();
        validateComment();
        validateDescription();
        validateDestinationEmail();
        validateFromAddress();
        validateMaxAttempts();
        validateSenderEmail();
        validateStatus();
        validateToAddress();
    }

    /**
     * Calls all validation methods just before first persist of this entity.
     */
    @PrePersist
    void validateBeforePersist(){
        validateAttempts();
        validateComment();
        validateDescription();
        validateDestinationEmail();
        validateFromAddress();
        validateMaxAttempts();
        validateSenderEmail();
        validateStatus();
        validateToAddress();
    }

    /**
     * Returns the identifier for this entity.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Order setId_(String id) {
        this.id = id;
        return this;
    }

    /**
     * Returns description.
     */
    public String getDescription(){
        return description;
    }

    /**
     * Sets description to the given value.
     */
    public void setDescription(String description){
        this.description = description;
    }

    /**
     * Sets the attribute to the given value and returns this
     * (enables method chaining).
     */
    public Order setDescription_(String description){
        setDescription(description);
        return this;
    }

    /**
     * Returns fromAddress.
     */
    public String getFromAddress(){
        return fromAddress;
    }

    /**
     * Sets fromAddress to the given value.
     */
    public void setFromAddress(String fromAddress){
        this.fromAddress = fromAddress;
    }

    /**
     * Sets the attribute to the given value and returns this
     * (enables method chaining).
     */
    public Order setFromAddress_(String fromAddress){
        setFromAddress(fromAddress);
        return this;
    }

    /**
     * Returns toAddress.
     */
    public String getToAddress(){
        return toAddress;
    }

    /**
     * Sets toAddress to the given value.
     */
    public void setToAddress(String toAddress){
        this.toAddress = toAddress;
    }

    /**
     * Sets the attribute to the given value and returns this
     * (enables method chaining).
     */
    public Order setToAddress_(String toAddress){
        setToAddress(toAddress);
        return this;
    }

    /**
     * Returns destinationEmail.
     */
    public String getDestinationEmail(){
        return destinationEmail;
    }

    /**
     * Sets destinationEmail to the given value.
     */
    public void setDestinationEmail(String destinationEmail){
        this.destinationEmail = destinationEmail;
    }

    /**
     * Sets the attribute to the given value and returns this
     * (enables method chaining).
     */
    public Order setDestinationEmail_(String destinationEmail){
        setDestinationEmail(destinationEmail);
        return this;
    }

    /**
     * Returns senderEmail.
     */
    public String getSenderEmail(){
        return senderEmail;
    }

    /**
     * Sets senderEmail to the given value.
     */
    public void setSenderEmail(String senderEmail){
        this.senderEmail = senderEmail;
    }

    /**
     * Sets the attribute to the given value and returns this
     * (enables method chaining).
     */
    public Order setSenderEmail_(String senderEmail){
        setSenderEmail(senderEmail);
        return this;
    }

    /**
     * Returns maxAttempts.
     */
    public Integer getMaxAttempts(){
        return maxAttempts;
    }

    /**
     * Sets maxAttempts to the given value.
     */
    public void setMaxAttempts(Integer maxAttempts){
        this.maxAttempts = maxAttempts;
    }

    /**
     * Sets the attribute to the given value and returns this
     * (enables method chaining).
     */
    public Order setMaxAttempts_(Integer maxAttempts){
        setMaxAttempts(maxAttempts);
        return this;
    }

    /**
     * Returns attempts.
     */
    public Integer getAttempts(){
        return attempts;
    }

    /**
     * Sets attempts to the given value.
     */
    public void setAttempts(Integer attempts){
        this.attempts = attempts;
    }

    /**
     * Sets the attribute to the given value and returns this
     * (enables method chaining).
     */
    public Order setAttempts_(Integer attempts){
        setAttempts(attempts);
        return this;
    }

    /**
     * Returns comment.
     */
    public String getComment(){
        return comment;
    }

    /**
     * Sets comment to the given value.
     */
    public void setComment(String comment){
        this.comment = comment;
    }

    /**
     * Sets the attribute to the given value and returns this
     * (enables method chaining).
     */
    public Order setComment_(String comment){
        setComment(comment);
        return this;
    }

    /**
     * Returns status.
     */
    public String getStatus(){
        return status;
    }

    /**
     * Sets status to the given value.
     */
    public void setStatus(String status){
        this.status = status;
    }

    /**
     * Sets the attribute to the given value and returns this
     * (enables method chaining).
     */
    public Order setStatus_(String status){
        setStatus(status);
        return this;
    }

    /**
     * For internal use only by the state machine but is persisted by the jpa provider.
     */
    public String getState(){
        return state;
    }

    /**
     * For internal use only by the state machine but is persisted by the jpa provider.
     */
    public void setState(String state){
        this.state = state;
    }

    /**
     * Sets the current state. This should only be used when creating an instance without using the state machine.
     */
    public void setState(State state){
        this.state = state.toString();
    }

    /**
     * The list of all states from the state machine for this entity.
     */
    public static enum State {
        AWAITING_NEXT_DELIVERY_ATTEMPT,COULD_NOT_DELIVER,COURIER_ASSIGNED,DELIVERED,DELIVERING,DELIVERY_FAILED,HELD_FOR_PICKUP,IN_TRANSIT,PREPARING,READY_FOR_DELIVERY,READY_FOR_DISPATCH,RETURN_TO_SENDER;
    }

    /**
     * Event declarations.
     */
    public static class Events {

        /**
         * Event implementation for event 'Create'
         */
        @SuppressWarnings("serial")
        public static class Create implements Event<Order>, Serializable, CreationEvent<Order> {

            public static final String signatureKey = "java.lang.String;java.lang.String;java.lang.String;java.lang.String;java.lang.String;java.lang.String;java.lang.Integer;java.lang.String;";

            public String signatureKey() {
                return signatureKey;
            }
            private final String orderID;
            private final String description;
            private final String fromAddress;
            private final String toAddress;
            private final String destinationEmail;
            private final String senderEmail;
            private final Integer maxAttempts;
            private final String comment;

            /**
             * Constructor.
             */
            public Create(String orderID, String description, String fromAddress, String toAddress, String destinationEmail, String senderEmail, Integer maxAttempts, String comment){
                if (orderID == null) throw new NullPointerException("orderID cannot be null");
                this.orderID = orderID;
                if (description == null) throw new NullPointerException("description cannot be null");
                this.description = description;
                if (fromAddress == null) throw new NullPointerException("fromAddress cannot be null");
                this.fromAddress = fromAddress;
                if (toAddress == null) throw new NullPointerException("toAddress cannot be null");
                this.toAddress = toAddress;
                if (destinationEmail == null) throw new NullPointerException("destinationEmail cannot be null");
                this.destinationEmail = destinationEmail;
                if (senderEmail == null) throw new NullPointerException("senderEmail cannot be null");
                this.senderEmail = senderEmail;
                if (maxAttempts == null) throw new NullPointerException("maxAttempts cannot be null");
                this.maxAttempts = maxAttempts;
                if (comment == null) throw new NullPointerException("comment cannot be null");
                this.comment = comment;
            }

            public String getOrderID(){
                return orderID;
            }

            public String getDescription(){
                return description;
            }

            public String getFromAddress(){
                return fromAddress;
            }

            public String getToAddress(){
                return toAddress;
            }

            public String getDestinationEmail(){
                return destinationEmail;
            }

            public String getSenderEmail(){
                return senderEmail;
            }

            public Integer getMaxAttempts(){
                return maxAttempts;
            }

            public String getComment(){
                return comment;
            }

            private Create(Builder builder) {
                if (builder.orderID == null) throw new NullPointerException("orderID cannot be null");
                this.orderID = builder.orderID;
                if (builder.description == null) throw new NullPointerException("description cannot be null");
                this.description = builder.description;
                if (builder.fromAddress == null) throw new NullPointerException("fromAddress cannot be null");
                this.fromAddress = builder.fromAddress;
                if (builder.toAddress == null) throw new NullPointerException("toAddress cannot be null");
                this.toAddress = builder.toAddress;
                if (builder.destinationEmail == null) throw new NullPointerException("destinationEmail cannot be null");
                this.destinationEmail = builder.destinationEmail;
                if (builder.senderEmail == null) throw new NullPointerException("senderEmail cannot be null");
                this.senderEmail = builder.senderEmail;
                if (builder.maxAttempts == null) throw new NullPointerException("maxAttempts cannot be null");
                this.maxAttempts = builder.maxAttempts;
                if (builder.comment == null) throw new NullPointerException("comment cannot be null");
                this.comment = builder.comment;
            }

            public static Builder builder() {
                return new Builder();
            }

            public static class Builder {

                private String orderID;
                private String description;
                private String fromAddress;
                private String toAddress;
                private String destinationEmail;
                private String senderEmail;
                private Integer maxAttempts;
                private String comment;

                public Builder orderID(String orderID) {
                    this.orderID = orderID;
                    return this;
                }

                public Builder description(String description) {
                    this.description = description;
                    return this;
                }

                public Builder fromAddress(String fromAddress) {
                    this.fromAddress = fromAddress;
                    return this;
                }

                public Builder toAddress(String toAddress) {
                    this.toAddress = toAddress;
                    return this;
                }

                public Builder destinationEmail(String destinationEmail) {
                    this.destinationEmail = destinationEmail;
                    return this;
                }

                public Builder senderEmail(String senderEmail) {
                    this.senderEmail = senderEmail;
                    return this;
                }

                public Builder maxAttempts(Integer maxAttempts) {
                    this.maxAttempts = maxAttempts;
                    return this;
                }

                public Builder comment(String comment) {
                    this.comment = comment;
                    return this;
                }

                public Create build() {
                    return new Create(this);
                }
            }

            @Override
            public String toString() {
                return MoreObjects.toStringHelper(this.getClass())
                    .add("orderID", orderID)
                    .add("description", description)
                    .add("fromAddress", fromAddress)
                    .add("toAddress", toAddress)
                    .add("destinationEmail", destinationEmail)
                    .add("senderEmail", senderEmail)
                    .add("maxAttempts", maxAttempts)
                    .add("comment", comment)
                    .toString();
            }
        }


        /**
         * Event implementation for event 'Send'
         */
        @SuppressWarnings("serial")
        public static class Send implements Event<Order>, Serializable {

            public static final String signatureKey = "";

            public String signatureKey() {
                return signatureKey;
            }

            /**
             * Constructor.
             */
            public Send(){
            }

            private Send(Builder builder) {
            }

            public static Builder builder() {
                return new Builder();
            }

            public static class Builder {


                public Send build() {
                    return new Send(this);
                }
            }
        }


        /**
         * Event implementation for event 'Assign'
         */
        @SuppressWarnings("serial")
        public static class Assign implements Event<Order>, Serializable {

            public static final String signatureKey = "";

            public String signatureKey() {
                return signatureKey;
            }

            /**
             * Constructor.
             */
            public Assign(){
            }

            private Assign(Builder builder) {
            }

            public static Builder builder() {
                return new Builder();
            }

            public static class Builder {


                public Assign build() {
                    return new Assign(this);
                }
            }
        }


        /**
         * Event implementation for event 'Picked up'
         */
        @SuppressWarnings("serial")
        public static class PickedUp implements Event<Order>, Serializable {

            public static final String signatureKey = "";

            public String signatureKey() {
                return signatureKey;
            }

            /**
             * Constructor.
             */
            public PickedUp(){
            }

            private PickedUp(Builder builder) {
            }

            public static Builder builder() {
                return new Builder();
            }

            public static class Builder {


                public PickedUp build() {
                    return new PickedUp(this);
                }
            }
        }


        /**
         * Event implementation for event 'Arrived depot'
         */
        @SuppressWarnings("serial")
        public static class ArrivedDepot implements Event<Order>, Serializable {

            public static final String signatureKey = "java.lang.String;";

            public String signatureKey() {
                return signatureKey;
            }
            private final String depotID;

            /**
             * Constructor.
             */
            public ArrivedDepot(String depotID){
                if (depotID == null) throw new NullPointerException("depotID cannot be null");
                this.depotID = depotID;
            }

            public String getDepotID(){
                return depotID;
            }

            private ArrivedDepot(Builder builder) {
                if (builder.depotID == null) throw new NullPointerException("depotID cannot be null");
                this.depotID = builder.depotID;
            }

            public static Builder builder() {
                return new Builder();
            }

            public static class Builder {

                private String depotID;

                public Builder depotID(String depotID) {
                    this.depotID = depotID;
                    return this;
                }

                public ArrivedDepot build() {
                    return new ArrivedDepot(this);
                }
            }

            @Override
            public String toString() {
                return MoreObjects.toStringHelper(this.getClass())
                    .add("depotID", depotID)
                    .toString();
            }
        }


        /**
         * Event implementation for event 'Arrived final depot'
         */
        @SuppressWarnings("serial")
        public static class ArrivedFinalDepot implements Event<Order>, Serializable {

            public static final String signatureKey = "java.lang.String;";

            public String signatureKey() {
                return signatureKey;
            }
            private final String depotID;

            /**
             * Constructor.
             */
            public ArrivedFinalDepot(String depotID){
                if (depotID == null) throw new NullPointerException("depotID cannot be null");
                 this.depotID = depotID;
             }

             public String getDepotID(){
                 return depotID;
             }

             private ArrivedFinalDepot(Builder builder) {
                 if (builder.depotID == null) throw new NullPointerException("depotID cannot be null");
                 this.depotID = builder.depotID;
             }

             public static Builder builder() {
                 return new Builder();
             }

             public static class Builder {

                 private String depotID;

                 public Builder depotID(String depotID) {
                     this.depotID = depotID;
                     return this;
                 }

                 public ArrivedFinalDepot build() {
                     return new ArrivedFinalDepot(this);
                 }
             }

             @Override
             public String toString() {
                 return MoreObjects.toStringHelper(this.getClass())
                     .add("depotID", depotID)
                     .toString();
             }
         }


         /**
          * Event implementation for event 'Delivering'
          */
         @SuppressWarnings("serial")
         public static class Delivering implements Event<Order>, Serializable {

             public static final String signatureKey = "";

             public String signatureKey() {
                 return signatureKey;
             }

             /**
              * Constructor.
              */
             public Delivering(){
             }

             private Delivering(Builder builder) {
             }

             public static Builder builder() {
                 return new Builder();
             }

             public static class Builder {


                 public Delivering build() {
                     return new Delivering(this);
                 }
             }
         }


         /**
          * Event implementation for event 'Delivered'
          */
         @SuppressWarnings("serial")
         public static class Delivered implements Event<Order>, Serializable {

             public static final String signatureKey = "";

             public String signatureKey() {
                 return signatureKey;
             }

             /**
              * Constructor.
              */
             public Delivered(){
             }

             private Delivered(Builder builder) {
             }

             public static Builder builder() {
                 return new Builder();
             }

             public static class Builder {


                 public Delivered build() {
                     return new Delivered(this);
                 }
             }
         }


         /**
          * Event implementation for event 'Delivery failed'
          */
         @SuppressWarnings("serial")
         public static class DeliveryFailed implements Event<Order>, Serializable {

             public static final String signatureKey = "";

             public String signatureKey() {
                 return signatureKey;
             }

             /**
              * Constructor.
              */
             public DeliveryFailed(){
             }

             private DeliveryFailed(Builder builder) {
             }

             public static Builder builder() {
                 return new Builder();
             }

             public static class Builder {


                 public DeliveryFailed build() {
                     return new DeliveryFailed(this);
                 }
             }
         }


         /**
          * Event implementation for event 'Deliver again'
          */
         @SuppressWarnings("serial")
         public static class DeliverAgain implements Event<Order>, Serializable {

             public static final String signatureKey = "";

             public String signatureKey() {
                 return signatureKey;
             }

             /**
              * Constructor.
              */
             public DeliverAgain(){
             }

             private DeliverAgain(Builder builder) {
             }

             public static Builder builder() {
                 return new Builder();
             }

             public static class Builder {


                 public DeliverAgain build() {
                     return new DeliverAgain(this);
                 }
             }
         }


         /**
          * Event implementation for event 'No more attempts'
          */
         @SuppressWarnings("serial")
         public static class NoMoreAttempts implements Event<Order>, Serializable {

             public static final String signatureKey = "";

             public String signatureKey() {
                 return signatureKey;
             }

             /**
              * Constructor.
              */
             public NoMoreAttempts(){
             }

             private NoMoreAttempts(Builder builder) {
             }

             public static Builder builder() {
                 return new Builder();
             }

             public static class Builder {


                 public NoMoreAttempts build() {
                     return new NoMoreAttempts(this);
                 }
             }
         }


         /**
          * Event implementation for event 'Could not deliver'
          */
         @SuppressWarnings("serial")
         public static class CouldNotDeliver implements Event<Order>, Serializable {

             public static final String signatureKey = "";

             public String signatureKey() {
                 return signatureKey;
             }

             /**
              * Constructor.
              */
             public CouldNotDeliver(){
             }

             private CouldNotDeliver(Builder builder) {
             }

             public static Builder builder() {
                 return new Builder();
             }

             public static class Builder {


                 public CouldNotDeliver build() {
                     return new CouldNotDeliver(this);
                 }
             }
         }


         /**
          * Event implementation for event 'Return to sender'
          */
         @SuppressWarnings("serial")
         public static class ReturnToSender implements Event<Order>, Serializable {

             public static final String signatureKey = "";

             public String signatureKey() {
                 return signatureKey;
             }

             /**
              * Constructor.
              */
             public ReturnToSender(){
             }

             private ReturnToSender(Builder builder) {
             }

             public static Builder builder() {
                 return new Builder();
             }

             public static class Builder {


                 public ReturnToSender build() {
                     return new ReturnToSender(this);
                 }
             }
         }


         /**
          * Event implementation for event 'Delivered by pickup'
          */
         @SuppressWarnings("serial")
         public static class DeliveredByPickup implements Event<Order>, Serializable {

             public static final String signatureKey = "";

             public String signatureKey() {
                 return signatureKey;
             }

             /**
              * Constructor.
              */
             public DeliveredByPickup(){
             }

             private DeliveredByPickup(Builder builder) {
             }

             public static Builder builder() {
                 return new Builder();
             }

             public static class Builder {


                 public DeliveredByPickup build() {
                     return new DeliveredByPickup(this);
                 }
             }
         }

     }

     /**
      * Asychronously queues the given signal against this entity for processing.
      */
     @Override
     public Order signal(Event<Order> event) {
         helper().signal(event);
         return this;
     }

     /**
      * Asychronously queues the given signal against this entity for processing
      * after the delay specified. Delay cannot be null.
      */
     @Override
     public Order signal(Event<Order> event, Duration delay) {
         helper().signal(event, Optional.of(delay));
         return this;
     }

     /**
      * Asychronously queues the given signal against this entity for processing
      * at the epoch time in ms specified. Delay cannot be null.
      */
     @Override
     public Order signal(Event<Order> event, long time) {
         return signal(event, Duration.create(time-System.currentTimeMillis(),TimeUnit.MILLISECONDS));
     }

     public Order cancelSignal(String eventSignatureKey) {
          return this;
     }

     public Order cancelSignal(Event<Order> event) {
          return cancelSignal(event.signatureKey());
     }

     /**
      * Synchronously runs the on entry procedure associated
      * with this event and also any signals to self that are
      * made during the procedure. This method should not
      * be called directly except in a unit testing scenario
      * perhaps. Call signal method instead.
      */
     @Override
     public Order event(Event<Order> event){

         helper().beforeEvent();

         // process the event
         if (event instanceof Events.Create){
             processEvent((Events.Create) event);
         }
         else if (event instanceof Events.Send){
             processEvent((Events.Send) event);
         }
         else if (event instanceof Events.Assign){
             processEvent((Events.Assign) event);
         }
         else if (event instanceof Events.PickedUp){
             processEvent((Events.PickedUp) event);
         }
         else if (event instanceof Events.ArrivedDepot){
             processEvent((Events.ArrivedDepot) event);
         }
         else if (event instanceof Events.ArrivedFinalDepot){
             processEvent((Events.ArrivedFinalDepot) event);
         }
         else if (event instanceof Events.Delivering){
             processEvent((Events.Delivering) event);
         }
         else if (event instanceof Events.Delivered){
             processEvent((Events.Delivered) event);
         }
         else if (event instanceof Events.DeliveryFailed){
             processEvent((Events.DeliveryFailed) event);
         }
         else if (event instanceof Events.DeliverAgain){
             processEvent((Events.DeliverAgain) event);
         }
         else if (event instanceof Events.NoMoreAttempts){
             processEvent((Events.NoMoreAttempts) event);
         }
         else if (event instanceof Events.CouldNotDeliver){
             processEvent((Events.CouldNotDeliver) event);
         }
         else if (event instanceof Events.ReturnToSender){
             processEvent((Events.ReturnToSender) event);
         }
         else if (event instanceof Events.DeliveredByPickup){
             processEvent((Events.DeliveredByPickup) event);
         }

         helper().afterEvent();
         return this;
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.Create event){
         if (state==null){
             state=State.PREPARING.toString();
             synchronized(this) {
                 _behaviour.onEntryPreparing(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.Send event){
         if (state.equals(State.PREPARING.toString())){
             state=State.READY_FOR_DISPATCH.toString();
             synchronized(this) {
                 _behaviour.onEntryReadyForDispatch(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.Assign event){
         if (state.equals(State.READY_FOR_DISPATCH.toString())){
             state=State.COURIER_ASSIGNED.toString();
             synchronized(this) {
                 _behaviour.onEntryCourierAssigned(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.PickedUp event){
         if (state.equals(State.COURIER_ASSIGNED.toString())){
             state=State.IN_TRANSIT.toString();
             synchronized(this) {
                 _behaviour.onEntryInTransit(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.ArrivedDepot event){
         if (state.equals(State.IN_TRANSIT.toString())){
             state=State.IN_TRANSIT.toString();
             synchronized(this) {
                 _behaviour.onEntryInTransit(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.ArrivedFinalDepot event){
         if (state.equals(State.IN_TRANSIT.toString())){
             state=State.READY_FOR_DELIVERY.toString();
             synchronized(this) {
                 _behaviour.onEntryReadyForDelivery(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.Delivering event){
         if (state.equals(State.READY_FOR_DELIVERY.toString())){
             state=State.DELIVERING.toString();
             synchronized(this) {
                 _behaviour.onEntryDelivering(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.Delivered event){
         if (state.equals(State.DELIVERING.toString())){
             state=State.DELIVERED.toString();
             synchronized(this) {
                 _behaviour.onEntryDelivered(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.DeliveryFailed event){
         if (state.equals(State.DELIVERING.toString())){
             state=State.DELIVERY_FAILED.toString();
             synchronized(this) {
                 _behaviour.onEntryDeliveryFailed(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.DeliverAgain event){
         if (state.equals(State.DELIVERY_FAILED.toString())){
             state=State.AWAITING_NEXT_DELIVERY_ATTEMPT.toString();
             synchronized(this) {
                 _behaviour.onEntryAwaitingNextDeliveryAttempt(event);
             }
         }
         else if (state.equals(State.AWAITING_NEXT_DELIVERY_ATTEMPT.toString())){
             state=State.READY_FOR_DELIVERY.toString();
             synchronized(this) {
                 _behaviour.onEntryReadyForDelivery(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.NoMoreAttempts event){
         if (state.equals(State.DELIVERY_FAILED.toString())){
             state=State.HELD_FOR_PICKUP.toString();
             synchronized(this) {
                 _behaviour.onEntryHeldForPickup(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.CouldNotDeliver event){
         if (state.equals(State.DELIVERING.toString())){
             state=State.HELD_FOR_PICKUP.toString();
             synchronized(this) {
                 _behaviour.onEntryHeldForPickup(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.ReturnToSender event){
         if (state.equals(State.HELD_FOR_PICKUP.toString())){
             state=State.RETURN_TO_SENDER.toString();
             synchronized(this) {
                 _behaviour.onEntryReturnToSender(event);
             }
         }
     }

     /**
      * Synchronously perform the change.
      */
     private void processEvent(Events.DeliveredByPickup event){
         if (state.equals(State.HELD_FOR_PICKUP.toString())){
             state=State.DELIVERED.toString();
             synchronized(this) {
                 _behaviour.onEntryDelivered(event);
             }
         }
     }

     /**
      * Static creator method associated with the creation transition to 'Preparing' via event 'Create'.
      */
     public static Order create(EntityManager em, CreationEvent<Order> event) {
         Order entity = new Order();
         entity.event(event);
         em.persist(entity);
         return entity;
     }

     /**
      * Same as EntityManager.merge() except allows method chaining.
      * Returns a new merged instance.
      */
     public Order merge(EntityManager em) {
         return em.merge(this);
     }

     /**
      * Same as EntityManager.persist() except allows method chaining. Returns this.
      */
     public Order persist(EntityManager em) {
         em.persist(this);
         return this;
     }


     /**
      * Same as {@code persist(Context.em())}. Returns this.
      */
     public Order persist() {
         Context.em().persist(this);
         return this;
     }

     /**
      * Same as EntityManager.remove() except inverted to facilitate method chaining. Returns this.
      */
     public Order remove(EntityManager em) {
         em.remove(this);
         return this;
     }

     /**
      * Same as EntityManager.remove() except inverted to facilitate method chaining. Returns this.
      */
     public Order remove() {
         Context.remove(this);
         return this;
     }

     /**
      * Same as this.remove()
      */
     public Order delete() {
         return remove();
     }

     /**
      * Same as EntityManager.refresh() except inverted to facilitate method chaining. Returns this.
      */
     public Order refresh(EntityManager em) {
         em.refresh(this);
         return this;
     }

     /**
      * Does a merge then a refresh and returns a new updated merged instance.
      */
     public Order load(EntityManager em) {
         return merge(em).refresh(em);
     }

     public Order load() {
         return Context.load(this);
     }

     /**
      * On entry procedures for this entity.
      */
     public static interface Behaviour {

         void onEntryReadyForDelivery(Events.ArrivedFinalDepot event);

         void onEntryDelivered(Events.Delivered event);

         void onEntryReadyForDelivery(Events.DeliverAgain event);

         void onEntryReadyForDispatch(Events.Send event);

         void onEntryHeldForPickup(Events.NoMoreAttempts event);

         void onEntryReturnToSender(Events.ReturnToSender event);

         void onEntryAwaitingNextDeliveryAttempt(Events.DeliverAgain event);

         void onEntryHeldForPickup(Events.CouldNotDeliver event);

         void onEntryPreparing(Events.Create event);

         void onEntryCourierAssigned(Events.Assign event);

         void onEntryDelivering(Events.Delivering event);

         void onEntryDeliveryFailed(Events.DeliveryFailed event);

         void onEntryInTransit(Events.ArrivedDepot event);

         void onEntryDelivered(Events.DeliveredByPickup event);

         void onEntryInTransit(Events.PickedUp event);

     }

     /**
      * A factory that creates behaviour for a given entity.
      */
     public static interface BehaviourFactory {

         Behaviour create(Order entity);

     }

     /**
      * Returns a BehaviourFactory on the assumption that the given class
      * has a single constructor with one parameter of type Order.
      */
     public static BehaviourFactory createBehaviourFactory(final Class<? extends Behaviour> cls) {
         return new BehaviourFactory() {
             @Override
             public Behaviour create(Order entity) {
                 if (cls.getConstructors().length != 1)
                      throw new RuntimeException(
                               "expected only one constructor in the Behaviour implementation");
                 try {
                     return (Behaviour) cls.getConstructors()[0].newInstance(entity);
                 } catch (InstantiationException e) {
                     throw new RuntimeException(e);
                 } catch (IllegalAccessException e) {
                     throw new RuntimeException(e);
                 } catch (IllegalArgumentException e) {
                     throw new RuntimeException(e);
                 } catch (InvocationTargetException e) {
                     throw new RuntimeException(e);
                 } catch (SecurityException e) {
                     throw new RuntimeException(e);
                 }
             }
         };
     }

     public static Optional<Order> find(String id) {
         if (Context.em()!=null) {
             return Optional.fromNullable(Context.em().find(Order.class,id));
         } else {
             EntityManager em = Context.createEntityManager();
             try {
                 Order result = em.find(Order.class,id);
                 return Optional.fromNullable(result);
             } finally {
                 em.close();
             }
         }
     }

     public static class Attribute {
         public static final StringExpressionField<Order> description = new StringExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("description"));
         public static final StringExpressionField<Order> fromAddress = new StringExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("fromAddress"));
         public static final StringExpressionField<Order> toAddress = new StringExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("toAddress"));
         public static final StringExpressionField<Order> destinationEmail = new StringExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("destinationEmail"));
         public static final StringExpressionField<Order> senderEmail = new StringExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("senderEmail"));
         public static final NumericExpressionField<Order> maxAttempts = new NumericExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("maxAttempts"));
         public static final NumericExpressionField<Order> attempts = new NumericExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("attempts"));
         public static final StringExpressionField<Order> comment = new StringExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("comment"));
         public static final StringExpressionField<Order> status = new StringExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("status"));
         public static final StringExpressionField<Order> id = new StringExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("id"));
         public static final StringExpressionField<Order> depot_R1_id = new StringExpressionField<Order>(
             new xuml.tools.model.compiler.runtime.query.Field("depot_R1.id"));
     }

     public static SelectBuilder<Order> select(BooleanExpression<Order> where) {
         return new SelectBuilder<Order>(where).entityClass(Order.class).info(signaller.getInfo());
     }

     public static SelectBuilder<Order> select() {
         return select(null);
     }

 }