private static final Logger logger = LoggerFactory.getLogger(EventMgmtEJB.class);
    
    //@PersistenceContext(unitName="jpatickets-labex")
    private EntityManager em;
    
    private EventMgmtDAO edao;
    private EventMgmt eventMgmt;
    
    @PostConstruct
    public void init() {
        logger.debug("*** EventMgmtEJB:init({}) ***", super.hashCode());
        
        edao = new EventMgmtDAOImpl();
        ((EventMgmtDAOImpl)edao).setEntityManager(em);
        VenueDAOImpl vdao = new VenueDAOImpl();
            vdao.setEntityManager(em);
        eventMgmt = new EventMgmtImpl();
        ((EventMgmtImpl)eventMgmt).setEventDAO(edao);
        ((EventMgmtImpl)eventMgmt).setVenueDAO(vdao);
    }
    
    @PreDestroy
    public void destroy() {
        logger.debug("*** EventMgmtEJB:destroy({}) ***", super.hashCode()); 
    }
    

    @Override
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public Event createEvent(Event event, Venue venue) throws UnavailableException {
        return eventMgmt.createEvent(event, venue);
    }
    
    @Override
    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    public Event getEvent(int id) {
        logger.debug("getEvent({})", id);
        return eventMgmt.getEvent(id);
    }
    
    @Override
    public Event getEventCleansed(int id) {
        logger.debug("getCleansedEvent({})", id);
        Event event = getEvent(id);
        return toCleansed(event);
    }
    
    private Event toCleansed(Event bo) {
        Event pojo = new Event(bo.getId());
        pojo.setName(bo.getName());
        pojo.setStartTime(bo.getStartTime());
        List<Ticket> tickets = new ArrayList<Ticket>(bo.getTickets().size());
        for (Ticket t: bo.getTickets()) {
            toCleansed(t, pojo);
        }
        pojo.setTickets(tickets);
        return pojo;
    }
    
    private Ticket toCleansed(Ticket bo, Event event) {
        //example cleansing is stopping here for the example
        Ticket pojo = new Ticket(event, bo.getSeat());
        pojo.setPrice(bo.getPrice());
        pojo.setSold(bo.isSold());
        return pojo;
    }
    
    @Override
    public Event getEventTouchedSome(int id) {
        logger.debug("getEventTouchedSome({})", id);
        Event event = getEvent(id);
        //touch the ticket collection to load tickets prior to marshaling back
        event.getTickets().size();
        return event;
    }
    
    @Override
    public Event getEventTouchedMore(int id) {
        logger.debug("getEventTouchedMore({})", id);
        Event event = getEvent(id);
        //touch ticket collection and all seats to load both prior to marshaling back
        event.getTickets().size();
        event.getVenue().getName();
        for (Ticket t: event.getTickets()) {
            t.getSeat().getPosition();
        }
        return event;
    }
    
    @Override
    public Event getEventFetchedSome(int id) {
        logger.debug("getEventFetchedSome({})", id);
        Event event = eventMgmt.fetchEventTickets(id);
        return event;
    }
    
    @Override
    public Event getEventFetchedMore(int id) {
        logger.debug("getEventFetchedMore({})", id);
        Event event = eventMgmt.fetchEventTicketsSeats(id);
        return event;
    }
    
    @Override
    public EventDTO getEventLazyDTO(int id) {
        logger.debug("getEventLazyDTO({})", id);
        Event event = eventMgmt.getEvent(id);
        return toEventDTO(event);
    }
    
    private EventDTO toEventDTO(Event event) {
        EventDTO dto = new EventDTO();
        dto.setId(event.getId());
        dto.setEventName(event.getName());
        dto.setVenueName(event.getVenue().getName());
        dto.setStartTime(event.getStartTime());
        dto.setNumTickets(event.getTickets().size());
        return dto;
    }
    
    @Override
    public EventDTO getEventFetchedDTO(int eventId) {
        logger.debug("getEventFetchedDTO({})", eventId);
        Map<String, Object> dtoData = edao.fetchEventDTOData(eventId);
        return toEventDTO(dtoData);
    }
    
    private EventDTO toEventDTO(Map<String, Object> dtoData) {
        EventDTO dto = new EventDTO();
        Event event = (Event) dtoData.get(EventMgmtDAO.EVENT);
        String venueName = (String) dtoData.get(EventMgmtDAO.VENUE_NAME);
        int numTickets = (Integer) dtoData.get(EventMgmtDAO.NUM_TICKETS);
        dto.setId(event.getId());
        dto.setEventName(event.getName());
        dto.setStartTime(event.getStartTime());
        dto.setVenueName(venueName);
        dto.setNumTickets(numTickets);
        return dto;
    }
    
}

public class EventMgmtDAOImpl implements EventMgmtDAO {
    EntityManager em;
    
    public void setEntityManager(EntityManager em) {
        this.em = em;
    }

    @Override
    public Event createEvent(Event event) {
        em.persist(event);
        return event;
    }
    
    @Override
    public Event getEvent(int eventId) {
        return em.find(Event.class, eventId);
    }
    
    @Override
    public Event fetchEventTickets(int id) {
        List<Event> events = em.createNamedQuery("JPATicketEvent.fetchEventTickets", 
                Event.class)
                .setParameter("eventId", id)
                .getResultList();
        return events.isEmpty() ? null : events.get(0);
    }    
    
    @Override
    public Event fetchEventTicketsSeats(int id) {
        List<Event> events = em.createNamedQuery("JPATicketEvent.fetchEventTicketsSeats", 
                Event.class)
                .setParameter("eventId", id)
                .getResultList();
        return events.isEmpty() ? null : events.get(0);
    }
    
    @Override
    public Map<String, Object> fetchEventDTOData(int eventId) {
        @SuppressWarnings("unchecked")
        List<Object[]> rows = em.createNamedQuery("JPATicketEvent.fetchEventDTO")
                .setParameter("eventId", eventId)
                .getResultList();
        
        Map<String, Object> dtoData = new HashMap<String, Object>();
        if (!rows.isEmpty()) {
            Object[] row = rows.get(0);
            Event event = (Event) row[0];
            String venueName = (String) row[1];
            Number numTickets = (Number) row[2];
            dtoData.put(EVENT, event);
            dtoData.put(VENUE_NAME, venueName);
            dtoData.put(NUM_TICKETS, numTickets.intValue());
        }
        return dtoData;
    }
    
    @Override
    public List<Seat> findSeats(Event event, String section, Integer row,
            Integer position, int offset, int limit) {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<Seat> qdef = cb.createQuery(Seat.class);
        Root<Ticket> t = qdef.from(Ticket.class);
        Join<Ticket, Event> e = t.join("event");
        Join<Ticket, Seat> s = t.join("seat");
        
        Predicate pred = cb.conjunction();
        List<Expression<Boolean>> expr = pred.getExpressions();
        if (section != null) {
            expr.add(cb.equal(s.get("pk").get("section"), section));
        }
        if (row !=null) {
            expr.add(cb.equal(s.get("pk").get("row"), row));
        }
        if (position !=null) {
            expr.add(cb.equal(s.get("pk").get("position"), position));
        }
        
        qdef.select(s).where(cb.and(cb.equal(e, event), pred)).orderBy(cb.asc(t.get("price")));
        TypedQuery<Seat> query = em.createQuery(qdef);
        if (offset > 0) {
            query.setFirstResult(offset);
        }
        if (limit > 0) {
            query.setMaxResults(limit);
        }
        
        return query.getResultList();
    }
    
    @Override
    public List<Ticket> findTickets(Event event, List<Seat> seats) {
        return em.createNamedQuery("JPATicketTicket.findTickets", 
                Ticket.class)
                .setParameter("seats", seats)
                .getResultList();
    }
}

@SuppressWarnings("serial")
@Entity
@Table(name="JPATICKET_SEAT")
@NamedQueries({
    @NamedQuery(name = "JPATicketSeat.getSeatsForVenue", 
            query = "select s from Seat s where s.venue = :venue")
})
public class Seat implements Serializable {
    @EmbeddedId
    private SeatPK pk;
    
    @MapsId("venueId")
    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="VENUE_ID")
    private Venue venue;
    
    protected Seat() {}
    public Seat(Venue venue, String section, int row, int position) {
        this.venue = venue;
        this.pk = new SeatPK(venue==null ? null : venue.getId(), section, row, position);
    }

    public Venue getVenue()    { return venue; }
    public String getVenueId() { return pk==null ? null : pk.getVenueId(); }
    public String getSection() { return pk==null ? null : pk.getSection(); }
    public int getRow()        { return pk==null ? 0 : pk.getRow(); }
    public int getPosition()   { return pk==null ? 0 : pk.getPosition(); }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + getPosition();
        result = prime * result + getRow();
        result = prime * result + ((getSection() == null) ? 0 : getSection().hashCode());
        result = prime * result + ((getVenueId() == null) ? 0 : getVenueId().hashCode());
        return result;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) { return true; }
        if (obj == null) { return false; }
        if (getClass() != obj.getClass()) { return false; }
        Seat other = (Seat) obj;
        return (getPosition() == other.getPosition()) &&
           (getRow() != other.getRow()) &&
           (getSection() == null ? other.getSection()==null : getSection().equals(other.getSection())) &&
           (getVenueId() ==null ? other.getVenueId()==null : venue.getId().equals(other.getVenueId()));
    }
    
    
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Seat [venue=").append(getVenueId())
                .append(", section=").append(getSection())
                .append(", row=").append(getRow())
                .append(", position=").append(getPosition())
                .append("]");
        return builder.toString();
    }
}

    @PersistenceUnit(unitName=PU_NAME)
    private EntityManagerFactory emf;
    
    @Resource
    private UserTransaction utx;
    
    private String dropScript;
    private String createScript;

    @PostConstruct
    public void init() {
        StringWriter createScriptWriter = new StringWriter();
        StringWriter dropScriptWriter = new StringWriter();
        Map<String, Object> props = new HashMap<String, Object>();
        props.put("javax.persistence.schema-generation.scripts.create-database-schemas", "true");
        props.put("javax.persistence.schema-generation.scripts.action", "drop-and-create");
        props.put("hibernate.id.new_generator_mappings", "true"); //tell JSE schemagen to use SEQUENCE for @Id=AUTO
        props.put("javax.persistence.schema-generation.scripts.create-target", createScriptWriter);
        props.put("javax.persistence.schema-generation.scripts.drop-target", dropScriptWriter);
        Persistence.generateSchema(PU_NAME, props);
        dropScript = dropScriptWriter.toString();
        createScript = createScriptWriter.toString();
        logger.debug("createScript={}", createScript);
        logger.debug("dropScript={}", dropScript);
    }
    
    private List<String> getCommands(String script) {
        List<String> commands = new ArrayList<String>();
        for (String line : script.split("\n")) {
            commands.add(line);
        }
        return commands;
    }

    @javax.ejb.Lock(LockType.WRITE)
    public int dropDB() {
        logger.info("*** dropDB ***");
        int updates=0;
        EntityManager em = emf.createEntityManager();
        try {
            for (String nativeSQLCommand : getCommands(dropScript)) {
                try {
                    utx.begin();
                    em.joinTransaction();
                    updates += em.createNativeQuery(nativeSQLCommand).executeUpdate();
                    utx.commit();
                } catch (Exception ex) {
                    try { utx.rollback(); } catch (Exception ex2) { throw new EJBException(ex2); }
                    logger.warn("error executing SQL:" + ex + ", " + nativeSQLCommand);
                    //keep going
                }
            }
        } finally {
            em.close();
        }
        return updates;
    }
    
    @javax.ejb.Lock(LockType.WRITE)
    public int createDB() {
        logger.info("*** createDB ***");
        int updates=0;
        EntityManager em = emf.createEntityManager();
        try {
            utx.begin();
            em.joinTransaction();
            //all in one transaction
            for (String nativeSQLCommand : getCommands(createScript)) {
                updates += em.createNativeQuery(nativeSQLCommand).executeUpdate();
            }
            utx.commit();
        } catch (Exception ex) {
            logger.warn("error executing SQL:" + ex);
            try { utx.rollback(); } catch (Exception ex2) { throw new EJBException(ex2); }
        } finally {
            em.close();
        }
        return updates;
    }
}

@Embeddable
public class Address implements Serializable {
    private static final long serialVersionUID = 5678018330323499890L;
    @Column(name="STREET", length=20)
    private String street;
    @Column(name="CITY", length=20)
    private String city;
    @Column(name="STATE", length=2)
    private String state;
    @Column(name="POSTAL_CODE")
    private int zipCode;
    
    public String getStreet() { return street; }
    public void setStreet(String street) {
        this.street = street;
    }
    public Address withStreet(String street) {
        setStreet(street);
        return this;
    }
    
    public String getCity() { return city; }
    public void setCity(String city) {
        this.city = city;
    }
    public Address withCity(String city) {
        setCity(city);
        return this;
    }
    
    public String getState() { return state; }
    public void setState(String state) {
        this.state = state;
    }
    public Address withState(String state) {
        setState(state);
        return this;
    }

    public int getZipCode() { return zipCode; }
    public void setZipCode(int zipCode) {
        this.zipCode = zipCode;
    }
    public Address withZipCode(int zipCode) {
        setZipCode(zipCode);
        return this;
    }
    
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((city == null) ? 0 : city.hashCode());
        result = prime * result + ((state == null) ? 0 : state.hashCode());
        result = prime * result + ((street == null) ? 0 : street.hashCode());
        result = prime * result + zipCode;
        return result;
    }
    
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) { return true; }
        if (obj == null) { return false; }
        if (getClass() != obj.getClass()) { return false; }
        Address other = (Address) obj;
        
        return (city == null ? other.city == null : city.equals(other.city)) &&
            (state == null ? other.state == null : state.equals(other.state)) &&
            (street == null ? other.street == null : street.equals(other.street)) &&
            (zipCode == other.zipCode);
    }
    
    
}

public abstract class AuditorBase {
	private Logger log_;
	private boolean publishJMS_;
	private EntityManager em_;
	private ConnectionFactory cf_;
	private Topic topic_;

	public void setLog(Logger log) { this.log_ = log; }
	public void setEntityManager(EntityManager em) { this.em_ = em; }
	public void setConnectionFactory(ConnectionFactory cf) { this.cf_ = cf; }
	public void setTopic(Topic topic) { this.topic_ = topic; }
	public void setPublishJMS(boolean publishJMS) { 
		this.publishJMS_ = publishJMS; 
	}
	public int audit(String message) {
		AuditRecord rec = new AuditRecord(new Date(), message);
		int actions=0;
		if (persistRecord(rec) != null) {
			actions += 1;
		}
		if (publishJMS_ && cf_ != null) {
			publishRecord(rec);
			actions += 1;
		}
		return actions;
	}
	
	protected AuditRecord persistRecord(AuditRecord rec) {
		if (em_!=null) {
			em_.persist(rec);
			log_.debug("message persisted:{}", rec);
			return rec;		
		}
		return null;
	}
	
	
	protected void publishRecord(AuditRecord rec) {
		Connection connection=null;
		Session session = null;
		MessageProducer publisher = null;
		try {
			connection = cf_.createConnection();
			session = connection.createSession(
					false, Session.AUTO_ACKNOWLEDGE);
			TextMessage msg = session.createTextMessage(rec.getMessage());
			publisher = session.createProducer(topic_);
			publisher.send(msg);
			log_.debug("message sent:{}", msg);
		} catch (JMSException ex) {
			log_.error("error sending JMS message", ex);
			throw new EJBException("error sending JMS message:"+ex);
		} finally {
			close(connection, session);
		}
	}
	
	protected void close(Connection conn, Session session) {
		try { if (session != null) { session.close(); } } 
		catch (JMSException ex) {log_.info("error closing session", ex); }
		try { if (conn != null) { conn.close(); } } 
		catch (JMSException ex) {log_.info("error closing connection", ex); }
	}
	protected void close(Context jndi) {
		try { if (jndi != null) { jndi.close(); } } 
		catch (NamingException ex) {log_.info("error closing jndi", ex); }
	}

}

@Embeddable
public class SeatPK implements Serializable {
    private static final long serialVersionUID = -5824145862784177861L;
    //mapped to FK
    private String venueId;
    @Column(name="SECTION", length=6)
    private String section;
    @Column(name="ROW")
    private int row;
    @Column(name="POSTION")
    private int position;
    
    protected SeatPK() {}

    public SeatPK(String venueId, String section, int row, int position) {
        this.venueId = venueId;
        this.section = section;
        this.row = row;
        this.position = position;
    }
    
    public String getVenueId() { return venueId; }
    public String getSection() { return section; }
    public int getRow() { return row; }
    public int getPosition() { return position; }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + position;
        result = prime * result + row;
        result = prime * result + ((section == null) ? 0 : section.hashCode());
        result = prime * result + ((venueId == null) ? 0 : venueId.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) { return true; }
        if (obj == null) { return false; }
        if (getClass() != obj.getClass()) { return false; }
        SeatPK other = (SeatPK) obj;
        return (position == other.position) &&
            (row == other.row) &&
            (section==null ? other.section==null : section.equals(other.section))  &&
            (venueId==null ? other.venueId==null : venueId.equals(other.venueId));
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("SeatPK [venueId=").append(venueId)
            .append(", section=").append(section)
            .append(", row=").append(row)
            .append(", position=").append(position)
            .append("]");
        return builder.toString();
    }

    
}

public class Event /* implements Serializable */ {
    @Id @GeneratedValue
    @Column(name="EVENT_ID")
    private int id;
    
    @Column(name="EVENT_NAME", length=40, nullable=false)
    private String name;
    
    @ManyToOne(fetch=FetchType.LAZY, optional=false)
    @JoinColumn(name="VENUE_ID", nullable=false, updatable=false)
    private Venue venue;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name="START_TIME")
    private Date startTime;
    
    @OneToMany(mappedBy="event", cascade={CascadeType.PERSIST, CascadeType.REMOVE})
    private List<Ticket> tickets;
    
    protected Event() { }
    public Event(Venue venue) { 
        this.venue=venue;
    }
    public Event(int id) { this.id=id; }

    public int getId() { return id; }
    public Venue getVenue() { return venue; }

    public String getName() { return name; }
    public void setName(String name) {
        this.name = name;
    }
    public Event withName(String name) {
        setName(name);
        return this;
    }
    
    public Date getStartTime() { return startTime; }
    public void setStartTime(Date startTime) {
        this.startTime = startTime;
    }
    public Event withStartTime(Date startTime) {
        setStartTime(startTime);
        return this;
    }

    public List<Ticket> getTickets() { return tickets; }
    public void setTickets(List<Ticket> tickets) {
        this.tickets = tickets;
    }
    public Event withTicket(Ticket ticket) {
        if (tickets==null) {
            tickets = new LinkedList<Ticket>();
        }
        if (ticket!=null) {
            tickets.add(ticket);
        }
        return this;
    }
    
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Event [id=").append(id)
                .append(", name=").append(name)
                .append(", venue=").append(venue==null ? null : venue.getName())
                .append(", startTime=").append(startTime)
                .append("]");
        return builder.toString();
    }
}

public class EventMgmtImpl implements EventMgmt {
    private EventMgmtDAO edao;
    private VenueDAO vdao;
    
    public void setEventDAO(EventMgmtDAO edao) {
        this.edao = edao;
    }
    public void setVenueDAO(VenueDAO vdao) {
        this.vdao = vdao;
    }

    @Override
    public Event createEvent(Event event, Venue venue) throws UnavailableException {
        BigDecimal maxPrice = new BigDecimal(1000);
        List<Seat> seats = vdao.getSeatsForVenue(venue, 0, 0);
        for (Seat seat: seats) {
            Ticket ticket = new Ticket(event, seat);
            BigDecimal discount = new BigDecimal(seat.getRow()*.1);
            ticket.setPrice(maxPrice.subtract(maxPrice.multiply(discount)));
            event.withTicket(ticket);
        }
        return edao.createEvent(event);
    }

    @Override
    public Event getEvent(int id) {
        return edao.getEvent(id);
    }
    @Override
    public Event fetchEventTickets(int id) {
        return edao.fetchEventTickets(id);
    }
    @Override
    public Event fetchEventTicketsSeats(int id) {
        return edao.fetchEventTicketsSeats(id);
    }

    @Override
    public List<Seat> findSeats(Event event, String section, Integer row, Integer position, int offset, int limit) {
        return edao.findSeats(event, section, row, position, offset, limit);
    }
    
    @Override
    public List<Ticket> getTickets(Event event, List<Seat> seats) {
        return edao.findTickets(event, seats);
    }

    @Override
    public List<Ticket> reserveSeats(Event event, List<Seat> seats) throws UnavailableException {
        if (event==null) { throw new IllegalArgumentException("no event provided"); }
        if (seats==null) { throw new IllegalArgumentException("no seat selected"); }

        List<Ticket> tickets = getTickets(event, seats);
        for (Ticket ticket: tickets) {
            if (ticket.isSold()) {
                throw new UnavailableException(String.format("seat %s already sold", ticket.getSeat()));
            } else {
                ticket.setSold(true);
            }
        }
        return tickets;
    }
}

@SuppressWarnings("serial")
@Entity
@Table(name="JPATICKETS_VENUE")
public class Venue implements Serializable {
    @Id
    @Column(name="VENUE_ID", length=3)
    private String id;
    
    @Column(name="NAME", length=20, unique=true)
    private String name;
    
    @Embedded
    private Address address;

    public Venue() {}
    public Venue(String id) { this.id = id; }    
    public String getId() { return id; }

    public String getName() { return name; }
    public void setName(String name) {
        this.name = name;
    }
    public Venue withName(String name) {
        setName(name);
        return this;
    }

    public Address getAddress() { return address; }
    public void setAddress(Address address) {
        this.address = address;
    }
    public Venue withAddress(Address address) {
        setAddress(address);
        return this;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) { return true; }
        if (obj == null) { return false; }
        if (getClass() != obj.getClass()) { return false; }
        Venue other = (Venue) obj;
        
        return (id == null ? other.id == null : id.equals(other.id)) &&
           (name == null ? other.name == null : name.equals(other.name));
    }
    
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Venue [id=").append(id)
                .append(", name=").append(name)
                .append(", address=").append(address)
                .append("]");
        return builder.toString();
    }
}

@SuppressWarnings("serial")
@Entity
@Table(name="JPATICKETS_TICKET")
@NamedQueries({
    @NamedQuery(name="JPATicketTicket.findTickets", 
        query="select t from Ticket t where t.seat in :seats")
})
@IdClass(TicketPK.class)
public class Ticket implements Serializable {
    @Id
    @ManyToOne(fetch=FetchType.EAGER, optional=false)
    @JoinColumn(name="EVENT_ID")
    private Event event;
    
    @Id
    @OneToOne(
            //fetch=FetchType.EAGER,
            fetch=FetchType.LAZY,
            optional=false)
    @JoinColumns({
        @JoinColumn(name="VENUE_ID"),
        @JoinColumn(name="SECTION"),
        @JoinColumn(name="ROW"),
        @JoinColumn(name="POSITION"),
    })
    private Seat seat;
    
    @Column(name="PRICE", precision=7, scale=2)
    private BigDecimal price;
    
    @Column(name="SOLD", nullable=false)
    private boolean sold;

    protected Ticket() {}    
    public Ticket(Event event, Seat seat) {
        this.event = event;
        this.seat = seat;
    }

    public Event getEvent()   { return event; }
    public Seat getSeat()     { return seat; }
    
    public BigDecimal getPrice() { return price; }
    public void setPrice(BigDecimal price) {
        this.price = price;
    }
    
    public boolean isSold() { return sold; }
    public void setSold(boolean sold) {
        this.sold = sold;
    }
    
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Ticket [event=").append(event)
                .append(", seat=").append(seat)
                .append(", price=").append(price)
                .append(", sold=").append(sold)
                .append("]");
        return builder.toString();
    }
    
    
}

	private static final Logger log = LoggerFactory.getLogger(EDmvIngestCommand.class);
	private static final String jdbcDriver = 
		System.getProperty("jdbc.driver");
	private static final String jdbcURL = 
		System.getProperty("jdbc.url");
	private static final String jdbcUser = 
		System.getProperty("jdbc.user");
	private static final String jdbcPassword = 
		System.getProperty("jdbc.password");
	private static final String inputFile = 
		System.getProperty("inputFile");
	
	@SuppressWarnings("resource")
	private static InputStream getInputStream() throws Exception {
		InputStream is = null;

		if (inputFile == null) {
			throw new Exception("inputFile not supplied");
		}
		
		File file = new File(inputFile);
		if (file.exists()) {
			is = new FileInputStream(file);
		}
		if (is == null) {
            is = Thread.currentThread()
                       .getContextClassLoader()
                       .getResourceAsStream(inputFile);
		}
		if (is == null) {
			throw new Exception("unable to locate inputFile:" + inputFile);
		}
		return is;
	}
	
	private static void loadDriver() throws Exception {
		if (jdbcDriver == null) {
			throw new Exception("jdbc.driver not supplied");
		}
		Thread.currentThread()
		      .getContextClassLoader()
		      .loadClass(jdbcDriver)
		      .newInstance();
	}
	
	private static Connection getConnection() throws Exception {
		if (jdbcURL == null) {
			throw new Exception("jdbc.url not supplied");
		}
		if (jdbcUser == null) {
			throw new Exception("jdbc.user not supplied");
		}
		if (jdbcPassword == null) {
			throw new Exception("jdbc.password not supplied");
		}
		return DriverManager.getConnection(jdbcURL, jdbcUser, jdbcPassword);
	}
	
	public static void main(String args[]) {
	    try {
			Connection connection = null;
			InputStream is = null;
		    try {
		    	is = getInputStream();
		    	loadDriver();
		    	connection = getConnection();

                buyer = jndi.getBuyer();
            }        
            if (userMgmt == null) {
                userMgmt = jndi.getUserMgmt();
            }        
        }
        catch (Exception ex) {
            log.error("error initializing handler", ex);
            throw new ServletException("error initializing handler", ex);
        }
        finally {
        	if (jndi != null) { jndi.close(); }
        }
    }

    protected void doGet(HttpServletRequest request, 
                         HttpServletResponse response) 
        throws ServletException, IOException {
        log.debug("doGet() called");
        String command = request.getParameter(COMMAND_PARAM);
        log.debug("command=" + command);
        try {            
            if (command != null) {
                Handler handler = handlers.get(command);
                if (handler != null) {
                    log.debug("handler=" + handler);
                    handler.handle(request, response);
                }
                else {
                    request.setAttribute("handlers", handlers);
                    RequestDispatcher rd = 
                        getServletContext().getRequestDispatcher(
                            UNKNOWN_COMMAND_URL);
                            rd.forward(request, response);
                }
            }
            else {
                throw new Exception("no " + COMMAND_PARAM + " supplied"); 
            }
        }
        catch (Exception ex) {
            request.setAttribute(EXCEPTION_PARAM, ex);
            RequestDispatcher rd = getServletContext().getRequestDispatcher(
                    UNKNOWN_COMMAND_URL);
                    rd.forward(request, response);
        }
    }

    protected void doPost(HttpServletRequest request, 
                          HttpServletResponse response) 
        throws ServletException, IOException {
        log.debug("doPost() called, calling doGet()");
        doGet(request, response);
    }

    public void destroy() {
        log.debug("destroy() called");
    }
    
    private abstract class Handler {
        protected static final String RESULT_PARAM = "result";
        protected static final String MAINMENU_URL = 
            "/index.jsp";
        protected static final String DISPLAYUSER_URL = 
            "/WEB-INF/content/DisplayUser.jsp";
        protected static final String DISPLAYITEM_URL = 
            "/WEB-INF/content/DisplayItem.jsp";
        protected static final String DISPLAYITEMS_URL = 

public class Address1 {
	@Id @GeneratedValue
	private int id;
		
	@Column(name="STREET", length=32, nullable=false)
	@NotNull(message="street not supplied")
	@Size(max=32, message="street name too large", groups=DBChecks.class)
	@Pattern(regexp="^[0-9A-Za-z\\ ]+$", groups=DataChecks.class, 
	         message="street must be numbers and letters")
	private String street;
	
	@Column(name="CITY", length=20, nullable=false)
	@NotNull(message="city not supplied")
	@Size(max=20, message="city name too large", groups=DBChecks.class)
	@Pattern(regexp="^[a-zA-Z\\ ]+$", groups=DataChecks.class, 
	         message="city must be upper and lower case characters")
	private String city;
	
	@Column(name="STATE", length=2, nullable=false)
	@NotNull(message="state not supplied")
	@Size(min=2, max=2, message="state wrong size", groups=DBChecks.class)
	@Pattern(regexp="^[A-Z][A-Z]$", groups=DataChecks.class, 
	         message="state must be upper case letters")
	private String state;
	
	@Column(name="ZIP", length=5, nullable=false)
	@NotNull(message="zipcode not supplied")
	@Size(min=5, max=5, message="zipcode wrong size", groups=DBChecks.class)
	@Pattern(regexp="^[0-9][0-9][0-9][0-9][0-9]$", groups=DataChecks.class, 
	         message="zipcode must be numeric digits")
	private String zip;

	
	public int getId() { return id; }

	public String getStreet() { return street; }
	public Address1 setStreet(String street) {

public class TicketPK implements Serializable {
    private static final long serialVersionUID = -10715122509795953L;
    private int event;
    private SeatPK seat;
    
    protected TicketPK() {}    
    public TicketPK(int event, SeatPK seat) {
        this.event = event;
        this.seat = seat;
    }

    public int getEventId() { return event; }
    public SeatPK getSeatId() { return seat; }
    
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + event;
        result = prime * result + ((seat == null) ? 0 : seat.hashCode());
        return result;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) { return true; }
        if (obj == null) { return false; }        
        if (getClass() != obj.getClass()) { return false; }
        TicketPK other = (TicketPK) obj;
        
        return (event != other.event) &&
            (seat == null ? other.seat == null : seat.equals(other.seat));
    }
    
    
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("TicketPK [event=").append(event)
            .append(", seat=").append(seat).append("]");
        return builder.toString();
    }
}

                  getServletContext().getRequestDispatcher(ADMINMENU_URL);
                rd.forward(request, response);                
            }
            catch (Exception ex) {
                request.setAttribute(EXCEPTION_PARAM, ex);
                RequestDispatcher rd = getServletContext().getRequestDispatcher(
                    DISPLAY_EXCEPTION_URL);
                rd.forward(request, response);
            }
        }
    }

    private class Logout extends Handler {
        public void handle(HttpServletRequest request, 
                HttpServletResponse response) 
                throws ServletException, IOException {
            try {
                request.getSession().invalidate();
                
                RequestDispatcher rd = 
                  getServletContext().getRequestDispatcher(MAINMENU_URL);
                rd.forward(request, response);                
            }
            catch (Exception ex) {
                request.setAttribute(EXCEPTION_PARAM, ex);
                RequestDispatcher rd = getServletContext().getRequestDispatcher(
                    DISPLAY_EXCEPTION_URL);
                rd.forward(request, response);
            }
        }
    }
}

    public void setMedia(List<Media> media) {
        this.media = media;
    }

    public String getName() { return name; }
    public void setName(String name) {
        this.name = name;
    }
    
    private String myInstance() {
        String s=super.toString();
        s = s.substring(s.lastIndexOf('.')+1);
        return s;
    }
    
    public String toString() {
        StringBuilder text = new StringBuilder(myInstance());
        text.append(", id=" + id);
        text.append(", name=" + name);
        text.append(", media(" + media.size() + ")={");
        for (Media m: media) {
            text.append(m.getId() + ", ");

@Entity
@Table(name="ORMCORE_PEN")
public class Pen {
    @EmbeddedId
    @AttributeOverrides({
        @AttributeOverride(name="make", column=@Column(name="PEN_MAKE")),
        @AttributeOverride(name="model", column=@Column(name="PEN_MODEL"))             
        })
    private MakeModelPK pk;
    private int size;
    
    public Pen() {}
    public Pen(String make, String model) {
        this.pk = new MakeModelPK(make, model);
    }
    
    public MakeModelPK getPk() { return pk; }
    
    public int getSize() { return size; }
    public void setSize(int size) {
        this.size = size;
    }
    
    public String toString() {
        return new StringBuilder()

				minutes +
				(rating==null? 0 : rating.hashCode()) +
				(releaseDate==null? 0 : releaseDate.hashCode()) +
				(title==null ? 0 : title.hashCode());
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj) { return true; }
		if (obj == null) { return false; }
		Movie rhs = (Movie)obj;
		
		if (title==null) {
			if (rhs.title != null) { return false; }
		} else if (!title.equals(rhs.title)) {
			return false;
		}
		
		if (director==null) {
			if (rhs.getDirector() != null) { return false; }

	private static final Logger log = LoggerFactory.getLogger(ENCAuditorEJB.class);
	//TODO: enc-config 12: define a resource value ENC injection
	//@Resource(name="val/publishJMS")
	private Boolean publishJMS;
	
	//TODO: enc-config 13: define a persistence context ENC injection
	//@PersistenceContext(name="jpa/em")
	private EntityManager em;
	
	//TODO: enc-config 14: define a resource-env ENC injection
	//@Resource(name="jms/topic")
	private Topic topic;

	//TODO: enc-config 15: define a resource ENC injection
	//@Resource(name="jms/cf")
	private ConnectionFactory cf;
	
	//TODO: enc-config 16: activate this method after injection
	//@PostConstruct
	public void init() {
		super.setLog(log);
		super.setConnectionFactory(cf);
		super.setEntityManager(em);
		super.setTopic(topic);
		super.setPublishJMS(isPublishJMS());
	}	
	
	@Override
	public boolean isPublishJMS() {
		return publishJMS!=null && publishJMS;
	}
	@Override
	public boolean havePersistenceContext() {
		return em!=null;
	}
	@Override
	public boolean haveTopic() {
		return topic!=null;
	}
	@Override
	public boolean haveConnectionFactory() {
		return cf!=null;
	}
	
	@Override
	public int audit(String message) {
		return super.audit(message);
	}
}

    private BigDecimal cost;
    
    public Car() {}
    public Car(long id) { this.id = id; }
    
    public long getId() { return id; }
    
    public String getMake() { return make; }
    public void setMake(String make) {
        this.make = make;
    }
    
    public String getModel() { return model; }
    public void setModel(String model) {
        this.model = model;
    }

    public int getYear() { return year; }
    public void setYear(int year) {
        this.year = year;
    }
    
    public BigDecimal getCost() { return cost; }
    public void setCost(BigDecimal cost) {
        this.cost = cost;
    }

        count = 0;
    }
    public void stop() {
        this.stop = true;
    }
    public boolean isStopped() {
        return stopped;
    }
    public boolean isStarted() {
        return started;
    }
    public void setUsername(String username) {
		this.username = username;
	}
    public void setPassword(String password) {
		this.password = password;
	}
    
    private JMSContext createContext(Integer sessionMode) {
        if (sessionMode!=null) {
            return username==null ?
                    connFactory.createContext(sessionMode) :
                    connFactory.createContext(username, password, sessionMode);            
        } else {
            return username==null ?
                    connFactory.createContext() :
                    connFactory.createContext(username, password);
        }
    }

                    RequestDispatcher rd = 
                        getServletContext().getRequestDispatcher(
                            UNKNOWN_COMMAND_URL);
                            rd.forward(request, response);
                }
            }
            else {
                throw new Exception("no " + COMMAND_PARAM + " supplied"); 
            }
        }
        catch (Exception ex) {
            request.setAttribute(EXCEPTION_PARAM, ex);
            RequestDispatcher rd = getServletContext().getRequestDispatcher(
                    UNKNOWN_COMMAND_URL);
                    rd.forward(request, response);
        }
    }

    protected void doPost(HttpServletRequest request, 
                          HttpServletResponse response) 
        throws ServletException, IOException {
        logger.debug("doPost() called, calling doGet()");
        doGet(request, response);
    }

    public void destroy() {
        logger.debug("destroy() called");
    }
    
    private abstract class Handler {
        protected static final String RESULT_PARAM = "result";

    private String name;
    private String address;
    private String phone;
    
    public Manufacturer() {}
    public Manufacturer(String name, String address, String phone) {
        this.name = name;
        this.address = address;
        this.phone=phone;
    }
    
    public String getAddress() { return address; }
    public void setAddress(String address) {
        this.address = address;
    }

    public String getName() { return name; }
    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() { return phone; }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    
    public String toString() {
        return new StringBuilder()

	public Animal2(String name, Date dob, double weight) {
		this.name = name;
		this.dob = dob;
		this.weight = weight;
	}
	
	public int getId() { return id; }
	public void setId(int id) {
		this.id = id;
	}
	
	public String getName() { return name; }
	public void setName(String name) {
		this.name = name;
	}
	
	public Date getDob() { return dob; }
	public void setDob(Date dob) {
		this.dob = dob;
	}
	
	public double getWeight() { return weight; }
	public void setWeight(double weight) {
		this.weight = weight;
	}

	@Resource(name="jms/topic")
	private Topic topic;

	@PostConstruct
	public void init() {
		super.setLog(log);
		super.setConnectionFactory(cf);
		super.setEntityManager(em);
		super.setTopic(topic);
		super.setPublishJMS(isPublishJMS());
	}	
	
	@Override
	public boolean isPublishJMS() {
		return publishJMS!=null && publishJMS;
	}
	@Override
	public boolean havePersistenceContext() {
		return em!=null;
	}
	@Override
	public boolean haveTopic() {
		return topic!=null;
	}
	@Override
	public boolean haveConnectionFactory() {
		return cf!=null;
	}
	
	@Override
	public int audit(String message) {
		return super.audit(message);
	}
}

@Stateless
public class ParserTestEJB implements ParserTestRemote {
	private static final Logger log = LoggerFactory.getLogger(ParserTestEJB.class);
	
	@Resource(name="vals/xmlFile")
	private String xmlFile;
	
	@PostConstruct
	public void init() {
		log.debug("*** ParserTestEJB ***");
		log.debug("xmlFile=" + xmlFile);		
	}

	public void ingest() throws Exception {
		log.info("ingest");
		
		InputStream is = null;
		
		try {
			log.trace("getting input file:" + xmlFile);
			is = this.getClass().getResourceAsStream(xmlFile);
			if (is == null) {
				throw new Exception(xmlFile + " was not found");
			}
			
			log.trace("creating parser");

	public void init() {
		super.setLog(log);
		super.setConnectionFactory(cf);
		super.setEntityManager(em);
		super.setTopic(topic);
		super.setPublishJMS(isPublishJMS());
	}	
	
	@Override
	public boolean isPublishJMS() {
		return publishJMS!=null && publishJMS;
	}
	@Override
	public boolean havePersistenceContext() {
		return em!=null;
	}
	@Override
	public boolean haveTopic() {
		return topic!=null;
	}
	@Override
	public boolean haveConnectionFactory() {
		return cf!=null;
	}
	
	@Override
	public int audit(String message) {
		return super.audit(message);
	}
}

        logger.debug("*** VenueMgmtEJB:destroy({}) ***", super.hashCode()); 
    }

    @Override
    public Venue createVenue(Venue venue, int sections, int positions, int rows) {
        try {
            return venueMgmt.createVenue(venue, sections, positions, rows);
        } catch (Exception ex) {
            logger.error("error creating venue", ex);
            throw new EJBException("error creating venue:" + ex);
        }
    }

    @Override
    public Venue getVenue(String venueId) {
        try {
            return venueMgmt.getVenue(venueId);
        } catch (Exception ex) {
            logger.error("error getting venue", ex);
            throw new EJBException("error getting venue:" + ex);
        }
    }
}

    }
    protected JMSContext createContext(Integer sessionMode) throws Exception {
        if (sessionMode==null) {
            return username==null ? 
            		connFactory.createContext() :
            		connFactory.createContext(username, password);
        } else {
            return username==null ? 
                    connFactory.createContext(sessionMode) :
                    connFactory.createContext(username, password, sessionMode);            
        }
    }
    public void setUsername(String username) {
		this.username = username;
	}
    public void setPassword(String password) {
		this.password = password;
	}
    public void execute() throws Exception {
        try (JMSContext context=createContext(Session.AUTO_ACKNOWLEDGE)) {

    private long id;
    private String make;
    private String model;
    private int size;
    
    public Bike() {} //required non-private default ctor
    public Bike(long id) { this.id = id; }

    public long getId() { return id; }

    public String getMake() { return make; }
    public void setMake(String make) {
        this.make = make;
    }
    
    public String getModel() { return model; }
    public void setModel(String model) {
        this.model = model;
    }
    
    public int getSize() { return size; }
    public void setSize(int size) {
        this.size = size;
    }

        logger.info("*** GreeterEJB:destroy({}) ***", super.hashCode());
    }
    
    /**
     * This method is an example of a business method that can be invoked by
     * users of this object (if a POJO) or bean (if deployed as an EJB).
     */
    @Override
    public String sayHello(String name) throws BadRequestException {
        logger.debug("sayHello({})", name);

        if (name == null || name.isEmpty()) {
            throw new BadRequestException(
                    "you must have a name for me to say hello");
        }
        return "hello " + name;
    }

    /**
     * This method is an example of a business method that
     */
    @Override
    public Greeting sayHello(Name name) throws BadRequestException {
        logger.debug("sayHello({})", name);

        if (name == null) {
            throw new BadRequestException(
                    "you must have a name for me to say hello");
        }
        return new Greeting(new Date(), 
                "hello " + name.getFirstName() + " " + name.getLastName());
    }
}

@Entity
@Table(name="ORMCORE_MOWER")
@IdClass(MowerPK.class)
public class Mower {
    @Id
    private String make;
    @Id
    private String model;    
    private int size;
    
    public Mower() {}
    public Mower(String make, String model) {
        this.make = make;
        this.model = model;
    }
    
    public String getMake() { return make; }    
    public String getModel() { return model; }

    public int getSize() { return size; }
    public void setSize(int size) {
        this.size = size;
    }
    
    public String toString() {
        return new StringBuilder()

		super.setLog(log);
		super.setConnectionFactory(cf);
		super.setEntityManager(em);
		super.setTopic(topic);
		super.setPublishJMS(isPublishJMS());
	}	
	
	@Override
	public boolean isPublishJMS() {
		return publishJMS!=null && publishJMS;
	}
	@Override
	public boolean havePersistenceContext() {
		return em!=null;
	}
	@Override
	public boolean haveTopic() {
		return topic!=null;
	}
	@Override
	public boolean haveConnectionFactory() {
		return cf!=null;
	}
	
	@Override
	public int audit(String message) {
		return super.audit(message);
	}
}

    private void setId(long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String toString() {
        StringBuilder text = new StringBuilder();
        text.append("id=" + id);
        text.append(", firstName=" + firstName);
        text.append(", lastName=" + lastName);
        return text.toString();
    }
}

        message.setJMSType("saleUpdate");
        message.setLong("id", item.getId());
        message.setString("name", item.getName());
        message.setString("seller", item.getOwner().getUserId());
        message.setLong("startDate", item.getStartDate().getTime());
        message.setLong("endDate", item.getEndDate().getTime());
        message.setDouble("minBid", item.getMinBid());
        message.setDouble("bids", item.getBids().size());
        message.setDouble("highestBid",