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();
    }
    
    
}

                buyer = jndi.getBuyer();
            }        
            if (userMgmt == null) {
                userMgmt = jndi.getUserMgmt();
            }        
        }
        catch (Exception ex) {
            log.fatal("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) {

            throw new MarketException("error removing auction items" + ex);
        }
    }
    
    private List<AuctionItem> makeDTO(List<AuctionItem> items) {
        List<AuctionItem> dto = new ArrayList<AuctionItem>();
        for (AuctionItem item : items) {
            dto.add(makeDTO(item));
        }
        return dto;
    }

    private AuctionItem makeDTO(AuctionItem item) {
        AuctionItem dto = new AuctionItem(item.getId());
        dto.setVersion(item.getVersion());
        dto.setName(item.getName());
        dto.setStartDate(item.getStartDate());
        dto.setEndDate(item.getEndDate());
        dto.setMinBid(item.getMinBid());
        dto.setBids(makeDTO(item.getBids(), dto));
        dto.setWinningBid(null);
        dto.setClosed(item.isClosed());
        return dto;
    }

    private List<Bid> makeDTO(List<Bid> bids, AuctionItem item) {
        List<Bid> dtos = new ArrayList<Bid>();
        for (Bid bid : bids) {
            Bid dto = new Bid(bid.getId());
            dto.setAmount(bid.getAmount());
            dto.setItem(item);
            item.getBids().add(dto);
            dto.setBidder(makeDTO(bid.getBidder(),dto));
            dtos.add(dto);
        }
        return dtos;
    }

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();
    }
}

                    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 ADMINMENU_URL = 

@SuppressWarnings("serial")
@Entity
@Table(name="JPATICKETS_EVENT")
@NamedQueries({
    @NamedQuery(name="JPATicketEvent.fetchEventTickets", 
        query="select e from Event e "
                + "join fetch e.tickets "
                + "where e.id=:eventId"),
    @NamedQuery(name="JPATicketEvent.fetchEventTicketsSeats", 
        query="select e from Event e "
                + "join fetch e.venue "
                + "join fetch e.tickets t "
                + "join fetch t.seat "
                + "where e.id=:eventId")
})
@NamedNativeQueries({
    @NamedNativeQuery(name="JPATicketEvent.fetchEventDTO",
            query="select event.EVENT_ID, event.EVENT_NAME, event.START_TIME, event.VENUE_ID, "
                    + "venue.NAME venueName, count(ticket.*) numTickets "
                    + "from JPATICKETS_EVENT event "
                    + "join JPATICKETS_VENUE venue on venue.VENUE_ID = event.VENUE_ID "
                    + "join JPATICKETS_TICKET ticket on ticket.EVENT_ID = event.EVENT_ID "
                    + "where event.EVENT_ID = :eventId "
                    + "group by event.EVENT_ID, event.EVENT_NAME, event.START_TIME, event.VENUE_ID, venue.NAME",
            resultSetMapping="JPATicketEvent.EventDTOMapping")
})
@SqlResultSetMappings({
    @SqlResultSetMapping(name="JPATicketEvent.EventDTOMapping",
            entities={
                @EntityResult(entityClass=Event.class)
                },
            columns={
                @ColumnResult(name="venueName", type=String.class),
                @ColumnResult(name="numTickets", type=Long.class)
                }
    )
})
public class Event /* implements Serializable */ {

public class XMLInjectAuditorEJB extends AuditorBase 
	implements AuditorRemote {
	private static final Logger log = LoggerFactory.getLogger(XMLInjectAuditorEJB.class);
	
	private Boolean publishJMS;
	private EntityManager em;
	private ConnectionFactory cf;
	private Topic topic;
	
	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);
	}
}

@Embeddable
public class MakeModelPK implements Serializable {
    private static final long serialVersionUID = 1L;
    private String make;
    private String model;
    
    public MakeModelPK() {}
    public MakeModelPK(String make, String model) {
        this.make = make;
        this.model = model;
    }
    
    public String getMake() { return make; }
    public String getModel() { return model; }

    public int hashCode() { return make.hashCode() + model.hashCode(); }
    public boolean equals(Object obj) {
        try {
            if (this == obj) return true;
            return make.equals(((MakeModelPK)obj).getMake()) &&
                   model.equals(((MakeModelPK)obj).getModel());
            
        } catch (Throwable ignored) { //catch NP & Cast Exceptions 
            return false;
        }
    }

    private ColorType colorName;

    public Vase() {}
    public Vase(long id) { this.id = id; }

    public long getId() { return id; }
    
    public Date getADate() { return aDate; }
    public void setADate(Date date) {
        aDate = date;
    }
    
    public Date getATime() { return aTime; }
    public void setATime(Date time) {
        aTime = time;
    }
    
    public Date getATimestamp() { return aTimestamp; }
    public void setATimestamp(Date timestamp) {
        aTimestamp = timestamp;
    }
    
    public ColorType getColorId() { return colorId; }
    public void setColorId(ColorType colorId) {
        this.colorId = colorId;
    }

    public ColorType getColorName() { return colorName; }
    public void setColorName(ColorType colorName) {
        this.colorName = colorName;
    }

		return this;
	}
	

	public Director getDirector() { return director; }
	public Movie setDirector(Director director) {
		this.director = director;
		return this;
	}

	public Set<MovieRole> getCast() {
		if (cast==null) {
			cast=new HashSet<MovieRole>();
		}
		return cast; 
	}
	protected void setCast(Set<MovieRole> cast) {
		this.cast = cast;
	}
	public Movie addRole(MovieRole...role) {
		if (role!=null) { 
			for (MovieRole r : role) {
				r.setMovie(this);
				getCast().add(r);
			}
		}
		return this;
	}
	@Override
	public int hashCode() {
		return (director== null ? 0 : director.hashCode()) +

@Table(name="QUERYEX_DIRECTOR")
public class Director {
	@Id
	private String id;
	
	@OneToOne(optional=false, fetch=FetchType.EAGER,
			cascade={CascadeType.PERSIST, CascadeType.DETACH})
	@JoinColumn(name="PERSON_ID")
	@MapsId
	private Person person;

	@OneToMany(mappedBy="director", 
			cascade={CascadeType.PERSIST, CascadeType.DETACH})	
	private Set<Movie> movies;

	protected Director() {}	
	public Director(Person person) {
		this.person = person;
	}

	public Person getPerson() { return person; }
	public String getFirstName() { return person==null?null : person.getFirstName(); }
	public String getLastName() { return person==null?null : person.getLastName(); }
	public Date getBirthDate() { return person==null?null : person.getBirthDate(); }

			jndi=new InitialContext();
			//TODO enc-config 19: lookup resource value in ENC 
			//publishJMS = (Boolean) ctx.lookup("val/publishJMS");
			//TODO enc-config 20: lookup persistence context in ENC 
			//em = (EntityManager) ctx.lookup("jpa/em");
			//TODO enc-config 21: lookup resource in ENC using JNDI java:comp/env 
			//topic = (Topic) jndi.lookup("java:comp/env/jms/topic");
			//TODO enc-config 22: lookup resource in ENC using JNDI java:comp/env
			//cf = (ConnectionFactory) jndi.lookup("java:comp/env/jms/cf");
		} catch (NamingException ex) {
			log.error("error looking up resources", ex);
			throw new EJBException("error looking up resources:" + ex);
		} finally {
			close(jndi);
		}
		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);
	}
}

                auctionMgmt = jndi.getAuctionMgmt();
            }        
            if (userMgmt == null) {
                userMgmt = jndi.getUserMgmt();
            }        
        }
        catch (Exception ex) {
            log.fatal("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) {

    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);
	}
}

	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);
        }
    }
}

    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()

            log.info("subscriber " + name + " stopping");
            connection.stop();
        }
        finally {
            stopped = true;
            started = false;
            if (consumer != null)   { consumer.close(); }
            if (session!=null){ session.close();}
            if (connection != null) { connection.close(); }
        }
    }
    
    public void run() {
        try {
            execute();
        }
        catch (Exception ex) {
            log.fatal("error running " + name, ex);
        }
    }    

    public static void main(String args[]) {
    	boolean noExit=false;
        try {

		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();
    }
}