E.4 The com.mediamania.store package
This package contains classes that model information that is specific
to an individual store. It includes objects representing the media to
be sold or rented, and information about the customers and the media
items they have bought or rented.
E.4.1 com.mediamania.store.Address
1 package com.mediamania.store;
2
3
4 public class Address {
5 private String street;
6 private String city;
7 private String state;
8 private String zipcode;
9
10 private Address( )
11 { }
12
13 public Address(String street, String city, String state, String zipcode) {
14 this.street = street;
15 this.city = city;
16 this.state = state;
17 this.zipcode = zipcode;
18 }
19 public String getStreet( ) {
20 return street;
21 }
22 public String getCity( ) {
23 return city;
24 }
25 public String getState( ) {
26 return state;
27 }
28 public String getZipcode( ) {
29 return zipcode;
30 }
31 }
E.4.2 com.mediamania.store.Customer
1 package com.mediamania.store;
2
3 import java.util.Set;
4 import java.util.HashSet;
5 import java.util.List;
6 import java.util.ArrayList;
7 import java.util.Collections;
8
9 public class Customer {
10 private String firstName;
11 private String lastName;
12 private Address address;
13 private String phone;
14 private String email;
15 private Set currentRentals; // Rental
16 private List transactionHistory; // Transaction
17
18 private Customer( )
19 { }
20 public Customer(String firstName, String lastName, Address addr,
21 String phone, String email) {
22 this.firstName = firstName;
23 this.lastName = lastName;
24 address = addr;
25 this.phone = phone;
26 this.email = email;
27 currentRentals = new HashSet( );
28 transactionHistory = new ArrayList( );
29 }
30 public String getFirstName( ) {
31 return firstName;
32 }
33 public String getLastName( ) {
34 return lastName;
35 }
36 public Address getAddress( ) {
37 return address;
38 }
39 public String getPhone( ) {
40 return phone;
41 }
42 public String getEmail( ) {
43 return email;
44 }
45 public void addRental(Rental rental){
46 currentRentals.add(rental);
47 }
48 public Set getRentals( ) {
49 return Collections.unmodifiableSet(currentRentals);
50 }
51 public void addTransaction(Transaction trans) {
52 transactionHistory.add(trans);
53 }
54 public List getTransactionHistory( ) {
55 return Collections.unmodifiableList(transactionHistory);
56 }
57 }
E.4.3 com.mediamania.store.MediaItem
1 package com.mediamania.store;
2
3 import java.util.Set;
4 import java.util.HashSet;
5 import java.util.Collections;
6 import java.math.BigDecimal;
7 import com.mediamania.content.MediaContent;
8
9 public class MediaItem {
10 private MediaContent content;
11 private String format;
12 private BigDecimal purchasePrice;
13 private RentalCode rentalCode;
14 private Set rentalItems; // RentalItem
15 private int quantityInStockForPurchase;
16 private int soldYTD;
17 private int rentedYTD;
18
19 private MediaItem( )
20 { }
21
22 public MediaItem(MediaContent content, String format, BigDecimal price,
23 RentalCode rentalCode, int number4sale) {
24 this.content = content;
25 content.addMediaItem(this);
26 this.format = format;
27 purchasePrice = price;
28 this.rentalCode = rentalCode;
29 rentalItems = new HashSet( );
30 quantityInStockForPurchase = number4sale;
31 soldYTD = 0;
32 rentedYTD = 0;
33 }
34 public MediaContent getMediaContent( ) {
35 return content;
36 }
37 public BigDecimal getPurchasePrice( ) {
38 return purchasePrice;
39 }
40 public String getFormat( ) {
41 return format;
42 }
43 public RentalCode getRentalCode( ) {
44 return rentalCode;
45 }
46 public void setRentalCode(RentalCode code) {
47 rentalCode = code;
48 }
49 public void addRentalItem(RentalItem rentalItem) {
50 rentalItems.add(rentalItem);
51 }
52 public Set getRentalItems( ) {
53 return Collections.unmodifiableSet(rentalItems);
54 }
55 public void sold(int qty) {
56 if (qty > quantityInStockForPurchase) {
57 // report error
58 }
59 quantityInStockForPurchase -= qty;
60 soldYTD += qty;
61 }
62 }
E.4.4 com.mediamania.store.Purchase
1 package com.mediamania.store;
2
3 import java.math.BigDecimal;
4 import java.util.Date;
5
6 public class Purchase extends Transaction {
7 private MediaItem mediaItem;
8
9 private Purchase( )
10 { }
11 public Purchase(Customer cust, Date date, BigDecimal price, MediaItem item){
12 super(cust, date);
13 setPrice(price);
14 mediaItem = item;
15 price = item.getPurchasePrice( );
16 }
17 public MediaItem getMediaItem( ) {
18 return mediaItem;
19 }
20 }
E.4.5 com.mediamania.store.Rental
1 package com.mediamania.store;
2
3 import java.util.Date;
4 import java.util.Calendar;
5 import java.util.GregorianCalendar;
6
7 public class Rental extends Transaction {
8 private RentalItem rentalItem;
9 private RentalCode rentalCode;
10 private Date returnDate;
11 private Date actualReturnDate;
12
13 private Rental( )
14 { }
15
16 public Rental(Customer cust, Date date, RentalItem item) {
17 super(cust, date);
18 rentalItem = item;
19 item.setCurrentRental(this);
20 rentalCode = item.getMediaItem().getRentalCode( );
21 setPrice(rentalCode.getCost( ));
22 GregorianCalendar cal = new GregorianCalendar( );
23 cal.setTime(date);
24 cal.add(Calendar.DATE, rentalCode.getNumberOfDays( ));
25 returnDate = cal.getTime( );
26 actualReturnDate = null;
27 }
28 public RentalItem getRentalItem( ) {
29 return rentalItem;
30 }
31 public MediaItem getMediaItem( ) {
32 return rentalItem.getMediaItem( );
33 }
34 public void setDateReturned(Date d) {
35 actualReturnDate = d;
36 }
37 }
E.4.6 com.mediamania.store.RentalCode
1 package com.mediamania.store;
2
3 import java.math.BigDecimal;
4
5 public class RentalCode
6 {
7 private String code;
8 private int numberOfDays;
9 private BigDecimal cost;
10 private BigDecimal lateFeePerDay;
11
12 private RentalCode( )
13 { }
14
15 public RentalCode(String code, int days,
16 BigDecimal cost, BigDecimal lateFee) {
17 this.code = code;
18 numberOfDays = days;
19 this.cost = cost;
20 lateFeePerDay = lateFee;
21 }
22 public String getCode( ) {
23 return code;
24 }
25 public int getNumberOfDays( ) {
26 return numberOfDays;
27 }
28 public BigDecimal getCost( ) {
29 return cost;
30 }
31 public BigDecimal getLateFeePerDay( ) {
32 return lateFeePerDay;
33 }
34 }
E.4.7 com.mediamania.store.RentalItem
1 package com.mediamania.store;
2
3 public class RentalItem
4 {
5 private MediaItem mediaItem;
6 private String serialNumber;
7 private Rental currentRental;
8
9 private RentalItem( )
10 { }
11 public RentalItem(MediaItem item, String serialNum) {
12 mediaItem = item;
13 item.addRentalItem(this);
14 serialNumber = serialNum;
15 currentRental = null;
16 }
17 public MediaItem getMediaItem( ) {
18 return mediaItem;
19 }
20 public Rental getCurrentRental( ) {
21 return currentRental;
22 }
23 public void setCurrentRental(Rental rental) {
24 currentRental = rental;
25 }
26 }
E.4.8 com.mediamania.store.StoreQueries
1 package com.mediamania.store;
2
3 import java.util.Iterator;
4 import java.util.Collection;
5 import java.util.HashMap;
6 import java.util.Date;
7 import java.util.Properties;
8 import java.io.InputStream;
9 import java.io.IOException;
10 import java.math.BigDecimal;
11 import javax.jdo.*;
12 import com.mediamania.content.*;
13 import com.mediamania.store.*;
14
15 public class StoreQueries {
16
17 public static RentalCode getRentalCode(PersistenceManager pm,
18 String codeName) {
19 Extent codeExtent = pm.getExtent(RentalCode.class, false);
20 Query query = pm.newQuery(codeExtent, "code == codeName");
21 query.declareParameters("String codeName");
22 Collection result = (Collection) query.execute(codeName);
23 Iterator iter = result.iterator( );
24 RentalCode rentalCode =
25 (RentalCode) (iter.hasNext() ? iter.next( ) : null);
26 query.close(result);
27 return rentalCode;
28 }
29
30 public static Movie getMovieByTitle(PersistenceManager pm,
31 String movieTitle) {
32 Extent movieExtent = pm.getExtent(Movie.class, true);
33 Query query = pm.newQuery(movieExtent, "title == movieTitle");
34 query.declareParameters("String movieTitle");
35 Collection result = (Collection) query.execute(movieTitle);
36 Iterator iter = result.iterator( );
37 Movie movie = (Movie) (iter.hasNext() ? iter.next( ) : null);
38 query.close(result);
39 return movie;
40 }
41
42 public static Customer getCustomer(PersistenceManager pm,
43 String fname, String lname) {
44 Extent customerExtent = pm.getExtent(Customer.class, true);
45 String filter = "fname == firstName && lname == lastName";
46 Query query = pm.newQuery(customerExtent, filter);
47 query.declareParameters("String fname, String lname");
48 Collection result = (Collection) query.execute(fname, lname);
49 Iterator iter = result.iterator( );
50 Customer customer = (Customer) (iter.hasNext() ? iter.next( ) : null);
51 query.close(result);
52 return customer;
53 }
54
55 public static void queryCustomers(PersistenceManager pm,
56 String city, String state) {
57 Extent customerExtent = pm.getExtent(Customer.class, true);
58 String filter = "address.city == city && address.state == state";
59 Query query = pm.newQuery(customerExtent, filter);
60 query.declareParameters("String city, String state");
61 query.setOrdering(
62 "address.zipcode ascending, lastName ascending, firstName ascending");
63 Collection result = (Collection) query.execute(city, state);
64 Iterator iter = result.iterator( );
65 while (iter.hasNext( )) {
66 Customer customer = (Customer) iter.next( );
67 Address address = customer.getAddress( );
68 System.out.print(address.getZipcode( )); System.out.print(" ");
69 System.out.print(customer.getFirstName( )); System.out.print(" ");
70 System.out.print(customer.getLastName( )); System.out.print(" ");
71 System.out.println(address.getStreet( ));
72 }
73 query.close(result);
74 }
75
76 public static void queryMovie1(PersistenceManager pm,
77 String rating, int runtime, MediaPerson dir) {
78 Extent movieExtent = pm.getExtent(Movie.class, true);
79 String filter =
80 "rating == movieRating && runningTime <= runTime && director == dir";
81 Query query = pm.newQuery(movieExtent, filter);
82 query.declareParameters(
83 "String movieRating, int runTime, MediaPerson dir");
84 Collection result = (Collection)
85 query.execute(rating, new Integer(runtime), dir);
86 Iterator iter = result.iterator( );
87 while (iter.hasNext( )) {
88 Movie movie = (Movie) iter.next( );
89 System.out.println(movie.getTitle( ));
90 }
91 query.close(result);
92 }
93
94 public static void queryMovie2(PersistenceManager pm,
95 String rating, int runtime, MediaPerson dir,
96 Date date) {
97 Extent movieExtent = pm.getExtent(Movie.class, true);
98 String filter = "rating == movieRating && runningTime <= runTime && " +
99 "director == dir && releaseDate >= date";
100 Query query = pm.newQuery(movieExtent, filter);
101 query.declareImports("import java.util.Date");
102 query.declareParameters(
103 "String movieRating, int runTime, MediaPerson dir, Date date");
104 HashMap parameters = new HashMap( );
105 parameters.put("movieRating", rating);
106 parameters.put("runTime", new Integer(runtime));
107 parameters.put("dir", dir);
108 parameters.put("date", date);
109 Collection result = (Collection) query.executeWithMap(parameters);
110 Iterator iter = result.iterator( );
111 while (iter.hasNext( )) {
112 Movie movie = (Movie) iter.next( );
113 System.out.println(movie.getTitle( ));
114 }
115 query.close(result);
116 }
117
118 public static void queryMovie3(PersistenceManager pm,
119 String rating, int runtime, MediaPerson dir,
120 Date date) {
121 Extent movieExtent = pm.getExtent(Movie.class, true);
122 String filter = "rating == movieRating && runningTime <= runTime && " +
123 "director == dir && releaseDate >= date";
124 Query query = pm.newQuery(movieExtent, filter);
125 query.declareImports("import java.util.Date");
126 query.declareParameters(
127 "String movieRating, int runTime, MediaPerson dir, Date date");
128 Object[] parameters = { rating, new Integer(runtime), dir, date };
129 Collection result = (Collection) query.executeWithArray(parameters);
130 Iterator iter = result.iterator( );
131 while (iter.hasNext( )) {
132 Movie movie = (Movie) iter.next( );
133 System.out.println(movie.getTitle( ));
134 }
135 query.close(result);
136 }
137
138 public static void queryMovie4(PersistenceManager pm) {
139 Extent movieExtent = pm.getExtent(Movie.class, true);
140 String filter = "!(rating == \"G\" || rating == \"PG\") && " +
141 "(runningTime >= 60 && runningTime <= 105)";
142 Query query = pm.newQuery(movieExtent, filter);
143 Collection result = (Collection) query.execute( );
144 Iterator iter = result.iterator( );
145 while (iter.hasNext( )) {
146 Movie movie = (Movie) iter.next( );
147 System.out.println(movie.getTitle( ));
148 }
149 query.close(result);
150 }
151
152 public static void getDirectorAlsoActor(PersistenceManager pm) {
153 Extent movieExtent = pm.getExtent(Movie.class, true);
154 String filter = "cast.contains(role) && role.actor == director";
155 Query query = pm.newQuery(movieExtent, filter);
156 query.declareVariables("Role role");
157 Collection result = (Collection) query.execute( );
158 Iterator iter = result.iterator( );
159 while (iter.hasNext( )) {
160 Movie movie = (Movie) iter.next( );
161 System.out.print(movie.getTitle( ));
162 System.out.print(", ");
163 System.out.println(movie.getDirector().getName( ));
164 }
165 }
166
167 public static void queryTransactions(PersistenceManager pm, Customer cust) {
168 Query query = pm.newQuery(com.mediamania.store.Transaction.class,
169 cust.getTransactionHistory( ));
170 String filter =
171 "((Movie)(((Rental)this).rentalItem.mediaItem.content)).director." +
172 "mediaName == \"James Cameron\"";
173 query.declareImports("import com.mediamania.content.Movie");
174 query.setFilter(filter);
175 Collection result = (Collection) query.execute( );
176 Iterator iter = result.iterator( );
177 while (iter.hasNext( ) ){
178 Rental rental = (Rental) iter.next( );
179 MediaContent content =
180 rental.getRentalItem().getMediaItem().getMediaContent( );
181 System.out.println(content.getTitle( ));
182 }
183 query.close(result);
184 }
185
186 public static void queryMoviesSeenInCity(PersistenceManager pm,
187 String city) {
188 String filter = "mediaItems.contains(item) &&" +
189 "(item.rentalItems.contains(rentItem) && " +
190 "(rentItem.currentRental.customer.address.city == city))";
191 Extent movieExtent = pm.getExtent(Movie.class, true);
192 Query query = pm.newQuery(movieExtent, filter);
193 query.declareImports("import com.mediamania.store.MediaItem; " +
194 "import com.mediamania.store.RentalItem");
195 query.declareVariables("MediaItem item; RentalItem rentItem");
196 query.declareParameters("String city");
197 Collection result = (Collection) query.execute(city);
198 Iterator iter = result.iterator( );
199 while (iter.hasNext( )) {
200 Movie movie = (Movie) iter.next( );
201 System.out.println(movie.getTitle( ));
202 }
203 query.close(result);
204 }
205
206 public static void queryTransactionsInCity(PersistenceManager pm,
207 String city, String state, Date acquired) {
208 Extent transactionExtent =
209 pm.getExtent(com.mediamania.store.Transaction.class, true);
210 Query query = pm.newQuery(transactionExtent);
211 query.declareParameters("String thecity, String thestate, Date date");
212 query.declareImports("import java.util.Date");
213 String filter = "customer.address.city == thecity && " +
214 "customer.address.state == thestate && acquisitionDate >= date";
215 query.setFilter(filter);
216 String order = "customer.address.zipcode descending, " +
217 "customer.lastName ascending, " +
218 "customer.firstName ascending, acquisitionDate ascending";
219 query.setOrdering(order);
220 Collection result = (Collection) query.execute(city, state, acquired);
221 Iterator iter = result.iterator( );
222 while (iter.hasNext( )) {
223 com.mediamania.store.Transaction tx =
224 (com.mediamania.store.Transaction) iter.next( );
225 Customer cust = tx.getCustomer( );
226 Address addr = cust.getAddress( );
227 System.out.print(addr.getZipcode( ));
228 System.out.print(cust.getLastName( )); System.out.print(" ");
229 System.out.print(cust.getFirstName( )); System.out.print(" ");
230 System.out.println(tx.getAcquisitionDate( ));
231 }
232 query.close(result);
233 }
234
235 public static void queryProfits(PersistenceManager pm, BigDecimal value,
236 BigDecimal sellCost, BigDecimal rentCost) {
237 Query query = pm.newQuery(MediaItem.class);
238 query.declareImports("import java.math.BigDecimal");
239 query.declareParameters(
240 "BigDecimal value, BigDecimal sellCost, BigDecimal rentCost");
241 query.setFilter("soldYTD * (purchasePrice - sellCost) + " +
242 "rentedYTD * (rentalCode.cost - rentCost) > value");
243 Collection result = (Collection)query.execute(value, sellCost,rentCost);
244 Iterator iter = result.iterator( );
245 while (iter.hasNext( )) {
246 MediaItem item = (MediaItem) iter.next( );
247 // process MediaItem
248 }
249 query.close(result);
250 }
251
252 public static RentalItem getRentalItem(
253 PersistenceManager pm, String serialNumber) {
254 Query query = pm.newQuery(RentalItem.class);
255 query.declareParameters("String serialNumber");
256 query.setFilter("this.serialNumber == serialNumber");
257 Collection result = (Collection)query.execute(serialNumber);
258 Iterator iter = result.iterator( );
259 RentalItem item = (RentalItem) (iter.hasNext() ? iter.next( ) : null);
260 query.close(result);
261 return item;
262 }
263
264 public static MediaItem getMediaItem(
265 PersistenceManager pm, String title, String format) {
266 Query query = pm.newQuery(MediaItem.class);
267 query.declareParameters("String title, String format");
268 query.setFilter("this.format == format && content.title == title");
269 Collection result = (Collection)query.execute(title, format);
270 Iterator iter = result.iterator( );
271 MediaItem item = (MediaItem) (iter.hasNext() ? iter.next( ) : null);
272 query.close(result);
273 return item;
274 }
275
276 public static Query newQuery(PersistenceManager pm, Class cl,InputStream is)
277 throws IOException {
278 Properties props = new Properties( );
279 props.load(is);
280 Query q = pm.newQuery(cl);
281 q.setFilter((String)props.get("filter"));
282 q.declareParameters((String)props.get("parameters"));
283 q.declareVariables((String)props.get("variables"));
284 q.setOrdering((String)props.get("ordering"));
285 q.declareImports((String)props.get("imports"));
286 q.setIgnoreCache(Boolean.getBoolean((String)props.get("ignoreCache")));
287 return q;
288 }
289 }
E.4.9 com.mediamania.store.Transaction
1 package com.mediamania.store;
2
3 import java.util.Date;
4 import java.math.BigDecimal;
5
6 public abstract class Transaction
7 {
8 protected Customer customer;
9 protected Date acquisitionDate;
10 protected BigDecimal price;
11
12 protected Transaction( )
13 { }
14 protected Transaction(Customer cust, Date date) {
15 customer = cust;
16 acquisitionDate = date;
17 }
18 public abstract MediaItem getMediaItem( );
19
20 public Customer getCustomer( ) {
21 return customer;
22 }
23 public Date getAcquisitionDate( ) {
24 return acquisitionDate;
25 }
26 public BigDecimal getPrice( ) {
27 return price;
28 }
29 public void setPrice(BigDecimal price) {
30 this.price = price;
31 }
32 }
 |
