forked from nus-cs2103-AY1819S1/addressbook-level4
-
Notifications
You must be signed in to change notification settings - Fork 4
/
Inventory.java
436 lines (361 loc) · 12.8 KB
/
Inventory.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
package seedu.inventory.model;
import static java.util.Objects.requireNonNull;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import javafx.collections.ObservableList;
import seedu.inventory.model.item.Item;
import seedu.inventory.model.item.UniqueItemList;
import seedu.inventory.model.purchaseorder.NonUniquePurchaseOrderList;
import seedu.inventory.model.purchaseorder.PurchaseOrder;
import seedu.inventory.model.sale.Sale;
import seedu.inventory.model.sale.UniqueSaleList;
import seedu.inventory.model.staff.Staff;
import seedu.inventory.model.staff.UniqueStaffList;
/**
* Wraps all data at the inventory-list level
* Duplicates are not allowed (by .isSameItem comparison)
*/
public class Inventory implements ReadOnlyInventory {
private final UniqueItemList items = new UniqueItemList();
private final NonUniquePurchaseOrderList purchaseOrders = new NonUniquePurchaseOrderList();
private final UniqueStaffList staffs = new UniqueStaffList();
private final UniqueSaleList sales = new UniqueSaleList();
public Inventory() {
}
/**
* Creates an Inventory using the Items in the {@code toBeCopied}
*/
public Inventory(ReadOnlyInventory toBeCopied) {
this();
resetData(toBeCopied);
}
/**
* Resets the existing item list of this {@code Inventory} with {@code newItemList}.
*/
public void resetItemList(ReadOnlyItemList newItemList) {
requireNonNull(newItemList);
setItems(newItemList.getItemList());
}
/**
* Resets the existing staff list of this {@code Inventory} with {@code newStaffList}.
*/
public void resetStaffList(ReadOnlyStaffList newStaffList) {
requireNonNull(newStaffList);
setStaffs(newStaffList.getStaffList());
}
/**
* Resets the existing purchase order list of this {@code Inventory} with {@code newPurchaseOrderList}.
*/
public void resetPurchaseOrderList(ReadOnlyPurchaseOrderList newPurchaseOrderList) {
requireNonNull(newPurchaseOrderList);
setPurchaseOrders(newPurchaseOrderList.getPurchaseOrderList());
}
/**
* Resets the existing sale list of this {@code Inventory} with {@code newSaleList}.
*/
public void resetSaleList(ReadOnlySaleList newSaleList) {
requireNonNull(newSaleList);
setSaleList(newSaleList.getSaleList());
}
/**
* Replaces the contents of the item list with {@code items}.
* {@code items} must not contain duplicate items.
*/
public void setItems(List<Item> items) {
this.items.setItems(items);
}
/**
* Replaces the contents of the purchase order list with {@code purchaseOrders}.
*/
public void setPurchaseOrders(List<PurchaseOrder> purchaseOrders) {
this.purchaseOrders.setPurchaseOrders(purchaseOrders);
}
/**
* Replaces the contents of the staff list with {@code staffs}
*
* @param staffs must not contain duplicated staffs.
*/
public void setStaffs(List<Staff> staffs) {
this.staffs.setStaffs(staffs);
}
/**
* Replaces the contents of the sale list with {@code saleLists}.
*/
public void setSaleList(List<Sale> sales) {
this.sales.setSales(sales);
}
//===================== item-level operations ==========================================
/**
* Returns true if a item with the same identity as {@code item} exists in the inventory.
*/
public boolean hasItem(Item item) {
requireNonNull(item);
return items.contains(item);
}
/**
* Adds an item to the inventory.
* The item must not already exist in the inventory.
*/
public void addItem(Item p) {
items.add(p);
}
/**
* Replaces the given item {@code target} in the list with {@code editedItem}.
* {@code target} must exist in the inventory.
* The item identity of {@code editedItem} must not be the same as another existing item in the inventory.
*/
public void updateItem(Item target, Item editedItem) {
requireNonNull(editedItem);
items.setItem(target, editedItem);
}
/**
* Removes {@code key} from this {@code Inventory}.
* {@code key} must exist in the inventory.
*/
public void removeItem(Item key) {
items.remove(key);
}
// staff-level
/**
* Returns true if a staff with the same identity as {@code staff} exists in the inventory.
*
* @return true if staff found
*/
public boolean hasStaff(Staff staff) {
requireNonNull(staff);
return staffs.contains(staff);
}
/**
* Returns true if a staff with the same username as {@code staff} exists in the inventory.
*
* @return true if staff found
*/
public boolean hasUsername(Staff staff) {
requireNonNull(staff);
return staffs.containsUsername(staff);
}
/**
* Adds a staff to the inventory management system.
*
* @param s the staff to be added
*/
public void addStaff(Staff s) {
staffs.add(s);
}
/**
* Updates the given staff {@code target} in the list with {@code editedStaff}.
* {@code target} must exist in the inventory management system.
*/
public void updateStaff(Staff target, Staff editedStaff) {
requireNonNull(editedStaff);
staffs.setStaff(target, editedStaff);
}
/**
* Removes the provided staff {@code key} from the inventory manager.
*/
public void removeStaff(Staff key) {
staffs.remove(key);
}
/**
* Retrieves the staff with provided staff which consists of username and password.
*/
public Staff retrieveStaff(Staff key) {
requireNonNull(key);
Iterator<Staff> staffList = staffs.iterator();
Staff staff = null;
while (staffList.hasNext()) {
staff = staffList.next();
if (staff.isSameStaff(key)) {
return staff;
}
}
return null;
}
//// util methods
/**
* Returns the item if Sku matches.
*/
@Override
public Item getItemBySku(String sku) {
requireNonNull(sku);
return items.getItemBySku(sku);
}
//===================== purchaseorder-level operations =================================
/**
* Returns true if a purchase order with the same identity as {@code po} exists in the inventory.
*/
public boolean hasPurchaseOrder(PurchaseOrder po) {
requireNonNull(po);
return purchaseOrders.contains(po);
}
/**
* Returns true if a purchase order with the same that has {@code item} exists in the inventory.
*/
public boolean hasPurchaseOrder(Item item) {
requireNonNull(item);
return purchaseOrders.contains(item);
}
/**
* Adds a purchase order to the purchase order list.
* Only add the purchase order if the item exist in the inventory
*/
public void addPurchaseOrder(PurchaseOrder po) {
requireNonNull(po);
Item item = items.getItemBySku(po.getSku().value);
if (item != null) {
purchaseOrders.add(po);
}
}
/**
* Replaces the given purchase order {@code target} in the list with {@code editedPurchaseOrder}.
* {@code target} must exist in the purchase order list.
*/
public void updatePurchaseOrder(int target, PurchaseOrder editedPurchaseOrder) {
requireNonNull(editedPurchaseOrder);
purchaseOrders.setPurchaseOrder(target, editedPurchaseOrder);
}
/**
* Replaces all purchase order sku in the list with {@code editedItem} sku.
*/
public void updatePurchaseOrder(Item target, Item editedItem) {
requireNonNull(editedItem);
Iterator<PurchaseOrder> poList = purchaseOrders.iterator();
while (poList.hasNext()) {
PurchaseOrder po = poList.next();
if (po.getSku().equals(target.getSku())) {
PurchaseOrder editedPo = new PurchaseOrder(
editedItem.getSku(),
po.getQuantity(),
po.getReqDate(),
po.getSupplier(),
po.getStatus());
purchaseOrders.setPurchaseOrder(po, editedPo);
}
}
}
/**
* Approves the given purchaseorder {@code target} and updates the status.
* {@code target} must exist in the purchase order list.
*/
public void approvePurchaseOrder(int target, PurchaseOrder targetPo) {
requireNonNull(target);
PurchaseOrder approvedPo = new PurchaseOrder(
targetPo.getSku(),
targetPo.getQuantity(),
targetPo.getReqDate(),
targetPo.getSupplier(),
PurchaseOrder.Status.APPROVED);
purchaseOrders.setPurchaseOrder(target, approvedPo);
}
/**
* Rejects the given purchaseorder {@code target} and updates the status.
* {@code target} must exist in the purchase order list.
*/
public void rejectPurchaseOrder(int target, PurchaseOrder targetPo) {
requireNonNull(target);
PurchaseOrder rejectedPo = new PurchaseOrder(
targetPo.getSku(),
targetPo.getQuantity(),
targetPo.getReqDate(),
targetPo.getSupplier(),
PurchaseOrder.Status.REJECTED);
purchaseOrders.setPurchaseOrder(target, rejectedPo);
}
/**
* Removes {@code key} from this {@code Inventory}.
* {@code key} must exist in the purchase order list.
*/
public void removePurchaseOrder(int key) {
purchaseOrders.remove(key);
}
/**
* Removes all {@code key} from purchase order list {@code Inventory}.
* {@code key} must exist in the purchase order list.
*/
public void removePurchaseOrder(Item key) {
purchaseOrders.remove(key);
}
//===================== sale methods =================================
/**
* Adds a sale to the inventory management system.
*
* @param sale the sale to be added
*/
public void addSale(Sale sale) {
sales.add(sale);
}
/**
* Remove a sale from the inventory management system.
*
* @param sale the sale to be removed
*/
public void removeSale(Sale sale) {
sales.remove((sale));
}
public String getNextSaleId() {
return sales.getNextSaleId();
}
public void setSales(List<Sale> sales) {
this.sales.setSales(sales);
}
public ObservableList<Sale> getSaleList() {
return this.sales.asUnmodifiableObservableList();
}
//===================== util methods =======================================================
//===================== list overwrite operations ==============================
/**
* Resets the existing data of this {@code Inventory} with {@code newData}.
*/
public void resetData(ReadOnlyInventory newData) {
requireNonNull(newData);
setItems(newData.getItemList());
setPurchaseOrders(newData.getPurchaseOrderList());
setStaffs(newData.getStaffList());
setSaleList(newData.getSaleList());
}
/**
* Resets the existing data of this {@code Inventory} with {@code newStaffData}.
*/
public void resetData(ReadOnlyStaffList newStaffData) {
requireNonNull(newStaffData);
setStaffs(newStaffData.getStaffList());
}
/**
* Resets the existing data of this {@code Inventory} with {@code newSaleData}.
*/
public void resetData(ReadOnlySaleList newSaleData) {
requireNonNull(newSaleData);
setSaleList(newSaleData.getSaleList());
}
@Override
public ObservableList<Item> getItemList() {
return items.asUnmodifiableObservableList();
}
@Override
public ObservableList<PurchaseOrder> getPurchaseOrderList() {
return purchaseOrders.asUnmodifiableObservableList();
}
public ObservableList<Staff> getStaffList() {
return staffs.asUnmodifiableObservableList();
}
@Override
public String toString() {
return items.asUnmodifiableObservableList().size() + " items\n"
+ purchaseOrders.asUnmodifiableObservableList().size() + " purchase orders\n"
+ staffs.asUnmodifiableObservableList().size() + " staffs\n"
+ sales.asUnmodifiableObservableList().size() + " sale orders";
}
@Override
public boolean equals(Object other) {
return other == this // short circuit if same object
|| (other instanceof Inventory // instanceof handles nulls
&& items.equals(((Inventory) other).items)
&& purchaseOrders.equals(((Inventory) other).purchaseOrders)
&& staffs.equals(((Inventory) other).staffs));
}
@Override
public int hashCode() {
return Objects.hash(items, purchaseOrders, staffs);
}
}