1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.kuali.kfs.module.cab.document.service.impl;
20
21 import java.util.ArrayList;
22 import java.util.Collection;
23 import java.util.HashMap;
24 import java.util.Iterator;
25 import java.util.List;
26 import java.util.Map;
27
28 import org.apache.log4j.Logger;
29 import org.kuali.kfs.integration.purap.CapitalAssetSystem;
30 import org.kuali.kfs.integration.purap.ItemCapitalAsset;
31 import org.kuali.kfs.module.cab.CabConstants;
32 import org.kuali.kfs.module.cab.CabPropertyConstants;
33 import org.kuali.kfs.module.cab.businessobject.PurchasingAccountsPayableDocument;
34 import org.kuali.kfs.module.cab.businessobject.PurchasingAccountsPayableItemAsset;
35 import org.kuali.kfs.module.cab.document.exception.PurApDocumentUnavailableException;
36 import org.kuali.kfs.module.cab.document.service.PurApInfoService;
37 import org.kuali.kfs.module.cab.document.web.struts.PurApLineForm;
38 import org.kuali.kfs.module.cam.CamsConstants;
39 import org.kuali.kfs.module.cam.CamsPropertyConstants;
40 import org.kuali.kfs.module.cam.businessobject.Asset;
41 import org.kuali.kfs.module.cam.document.service.AssetService;
42 import org.kuali.kfs.module.purap.PurapConstants;
43 import org.kuali.kfs.module.purap.PurapPropertyConstants;
44 import org.kuali.kfs.module.purap.businessobject.CreditMemoItem;
45 import org.kuali.kfs.module.purap.businessobject.PaymentRequestItem;
46 import org.kuali.kfs.module.purap.businessobject.PurApItem;
47 import org.kuali.kfs.module.purap.businessobject.PurchaseOrderItem;
48 import org.kuali.kfs.module.purap.businessobject.PurchasingCapitalAssetItem;
49 import org.kuali.kfs.module.purap.document.PurchaseOrderDocument;
50 import org.kuali.kfs.module.purap.document.VendorCreditMemoDocument;
51 import org.kuali.kfs.module.purap.document.service.PurapService;
52 import org.kuali.kfs.module.purap.document.service.PurchaseOrderService;
53 import org.kuali.kfs.module.purap.exception.PurError;
54 import org.kuali.kfs.sys.context.SpringContext;
55 import org.kuali.rice.krad.service.BusinessObjectService;
56 import org.kuali.rice.krad.util.ObjectUtils;
57
58
59
60
61
62 public class PurApInfoServiceImpl implements PurApInfoService {
63 private static final Logger LOG = Logger.getLogger(PurApInfoServiceImpl.class);
64 private BusinessObjectService businessObjectService;
65
66 protected static final String PURCHASE_ORDER_CURRENT_INDICATOR = "purchaseOrderCurrentIndicator";
67
68
69
70
71 public PurchaseOrderDocument getCurrentDocumentForPurchaseOrderIdentifier(Integer poId) {
72 Map<String, Object> fieldValues = new HashMap<String, Object>();
73
74 fieldValues.put(CabPropertyConstants.PurchasingAccountsPayableDocument.PURAP_DOCUMENT_IDENTIFIER, poId);
75 fieldValues.put(PURCHASE_ORDER_CURRENT_INDICATOR, "Y");
76 Collection<PurchaseOrderDocument> poDocs = getBusinessObjectService().findMatching(PurchaseOrderDocument.class, fieldValues);
77 if (poDocs != null && !poDocs.isEmpty()) {
78 Iterator<PurchaseOrderDocument> poIterator = poDocs.iterator();
79 if (poIterator.hasNext()) {
80 return poIterator.next();
81 }
82 }
83
84 return null;
85 }
86
87
88
89
90 public void setPurchaseOrderFromPurAp(PurApLineForm purApLineForm) {
91 PurchaseOrderDocument purchaseOrderDocument = getCurrentDocumentForPurchaseOrderIdentifier(purApLineForm.getPurchaseOrderIdentifier());
92
93 if (ObjectUtils.isNull(purchaseOrderDocument)) {
94 return;
95 }
96
97 if (purchaseOrderDocument.getInstitutionContactEmailAddress() != null) {
98 purApLineForm.setPurApContactEmailAddress(purchaseOrderDocument.getInstitutionContactEmailAddress());
99 }
100 else if (purchaseOrderDocument.getRequestorPersonEmailAddress() != null) {
101 purApLineForm.setPurApContactEmailAddress(purchaseOrderDocument.getRequestorPersonEmailAddress());
102 }
103
104
105 if (purchaseOrderDocument.getInstitutionContactPhoneNumber() != null) {
106 purApLineForm.setPurApContactPhoneNumber(purchaseOrderDocument.getInstitutionContactPhoneNumber());
107 }
108 else if (purchaseOrderDocument.getRequestorPersonPhoneNumber() != null) {
109 purApLineForm.setPurApContactPhoneNumber(purchaseOrderDocument.getRequestorPersonPhoneNumber());
110 }
111
112
113 purApLineForm.setRequisitionIdentifier(purchaseOrderDocument.getRequisitionIdentifier());
114
115 }
116
117
118
119
120
121
122
123 public void setCamsTransactionFromPurAp(List<PurchasingAccountsPayableDocument> purApDocs) {
124 if (ObjectUtils.isNull(purApDocs) || purApDocs.isEmpty()) {
125 return;
126 }
127 Integer poId = purApDocs.get(0).getPurchaseOrderIdentifier();
128 PurchaseOrderDocument purApdocument = getCurrentDocumentForPurchaseOrderIdentifier(poId);
129 if (ObjectUtils.isNull(purApdocument)) {
130 return;
131 }
132
133 String capitalAssetSystemTypeCode = purApdocument.getCapitalAssetSystemTypeCode();
134 String capitalAssetSystemStateCode = purApdocument.getCapitalAssetSystemStateCode();
135 boolean individualItemLock = false;
136
137 if (PurapConstants.CapitalAssetTabStrings.INDIVIDUAL_ASSETS.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
138
139 setIndividualAssetsFromPurAp(poId, purApDocs, capitalAssetSystemStateCode);
140 individualItemLock = true;
141 }
142 else if (PurapConstants.CapitalAssetTabStrings.ONE_SYSTEM.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
143
144 setOneSystemFromPurAp(poId, purApDocs, capitalAssetSystemStateCode);
145
146 }
147 else if (PurapConstants.CapitalAssetTabStrings.MULTIPLE_SYSTEMS.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
148
149 setMultipleSystemFromPurAp(poId, purApDocs, capitalAssetSystemStateCode);
150 }
151
152
153
154 for (PurchasingAccountsPayableDocument purApDoc : purApDocs) {
155 for (PurchasingAccountsPayableItemAsset itemAsset : purApDoc.getPurchasingAccountsPayableItemAssets()) {
156 itemAsset.setLockingInformation(individualItemLock ? itemAsset.getAccountsPayableLineItemIdentifier().toString() : CamsConstants.defaultLockingInformation);
157 }
158 }
159 }
160
161
162
163
164
165
166
167 protected void setMultipleSystemFromPurAp(Integer poId, List<PurchasingAccountsPayableDocument> purApDocs, String capitalAssetSystemStateCode) {
168 List<CapitalAssetSystem> capitalAssetSystems = this.getPurchaseOrderService().retrieveCapitalAssetSystemsForMultipleSystem(poId);
169 if (ObjectUtils.isNotNull(capitalAssetSystems) && !capitalAssetSystems.isEmpty()) {
170
171 CapitalAssetSystem capitalAssetSystem = capitalAssetSystems.get(0);
172 if (ObjectUtils.isNotNull(capitalAssetSystem)) {
173 String capitalAssetTransactionType = getCapitalAssetTransTypeForOneSystem(poId);
174
175 List<ItemCapitalAsset> purApCapitalAssets = null;
176 if (PurapConstants.CapitalAssetSystemStates.MODIFY.equalsIgnoreCase(capitalAssetSystemStateCode)) {
177 purApCapitalAssets = getAssetsFromItemCapitalAsset(capitalAssetSystem.getItemCapitalAssets());
178 }
179
180
181 for (PurchasingAccountsPayableDocument purApDoc : purApDocs) {
182 setItemAssetsCamsTransaction(capitalAssetSystem.getCapitalAssetSystemIdentifier(), capitalAssetTransactionType, purApCapitalAssets, purApDoc.getPurchasingAccountsPayableItemAssets());
183 }
184 }
185 }
186 }
187
188
189
190
191
192
193
194 protected void setOneSystemFromPurAp(Integer poId, List<PurchasingAccountsPayableDocument> purApDocs, String capitalAssetSystemStateCode) {
195 CapitalAssetSystem capitalAssetSystem = this.getPurchaseOrderService().retrieveCapitalAssetSystemForOneSystem(poId);
196 String capitalAssetTransactionTypeCode = getCapitalAssetTransTypeForOneSystem(poId);
197 List<ItemCapitalAsset> purApCapitalAssets = null;
198
199 if (PurapConstants.CapitalAssetSystemStates.MODIFY.equalsIgnoreCase(capitalAssetSystemStateCode)) {
200 purApCapitalAssets = getAssetsFromItemCapitalAsset(capitalAssetSystem.getItemCapitalAssets());
201 }
202
203 for (PurchasingAccountsPayableDocument purApDoc : purApDocs) {
204
205 setItemAssetsCamsTransaction(capitalAssetSystem.getCapitalAssetSystemIdentifier(), capitalAssetTransactionTypeCode, purApCapitalAssets, purApDoc.getPurchasingAccountsPayableItemAssets());
206 }
207 }
208
209
210
211
212
213
214
215
216
217 protected void setItemAssetsCamsTransaction(Integer capitalAssetSystemIdentifier, String capitalAssetTransactionTypeCode, List<ItemCapitalAsset> purApCapitalAssets, List<PurchasingAccountsPayableItemAsset> itemAssets) {
218 for (PurchasingAccountsPayableItemAsset item : itemAssets) {
219 item.setCapitalAssetTransactionTypeCode(capitalAssetTransactionTypeCode);
220
221 if (purApCapitalAssets != null && !purApCapitalAssets.isEmpty()) {
222 item.getPurApItemAssets().addAll(purApCapitalAssets);
223 }
224
225 item.setCapitalAssetSystemIdentifier(capitalAssetSystemIdentifier);
226 }
227 }
228
229
230
231
232
233
234
235 protected String getCapitalAssetTransTypeForOneSystem(Integer poId) {
236 PurchaseOrderDocument poDoc = getCurrentDocumentForPurchaseOrderIdentifier(poId);
237 if (ObjectUtils.isNotNull(poDoc)) {
238 List<PurchasingCapitalAssetItem> capitalAssetItems = poDoc.getPurchasingCapitalAssetItems();
239
240 if (ObjectUtils.isNotNull(capitalAssetItems) && capitalAssetItems.get(0) != null) {
241 return capitalAssetItems.get(0).getCapitalAssetTransactionTypeCode();
242 }
243 }
244 return null;
245 }
246
247
248
249
250
251
252
253 protected void setIndividualAssetsFromPurAp(Integer poId, List<PurchasingAccountsPayableDocument> purApDocs, String capitalAssetSystemStateCode) {
254 List<PurchasingCapitalAssetItem> capitalAssetItems = this.getPurchaseOrderService().retrieveCapitalAssetItemsForIndividual(poId);
255 String capitalAssetTransactionTypeCode = null;
256 List<ItemCapitalAsset> purApCapitalAssets = null;
257
258
259 for (PurchasingCapitalAssetItem purchasingCapitalAssetItem : capitalAssetItems) {
260 capitalAssetTransactionTypeCode = purchasingCapitalAssetItem.getCapitalAssetTransactionTypeCode();
261
262 List<PurchasingAccountsPayableItemAsset> matchingItems = getMatchingItems(purchasingCapitalAssetItem.getItemIdentifier(), purApDocs);
263
264 if (PurapConstants.CapitalAssetSystemStates.MODIFY.equalsIgnoreCase(capitalAssetSystemStateCode)) {
265 purApCapitalAssets = getAssetsFromItemCapitalAsset(purchasingCapitalAssetItem.getPurchasingCapitalAssetSystem().getItemCapitalAssets());
266 }
267
268
269 setItemAssetsCamsTransaction(purchasingCapitalAssetItem.getCapitalAssetSystemIdentifier(), capitalAssetTransactionTypeCode, purApCapitalAssets, matchingItems);
270 }
271 }
272
273
274
275
276
277
278
279 protected List<ItemCapitalAsset> getAssetsFromItemCapitalAsset(List<ItemCapitalAsset> itemCapitalAssets) {
280 List<ItemCapitalAsset> assetNumbers = new ArrayList<ItemCapitalAsset>();
281
282 for (ItemCapitalAsset asset : itemCapitalAssets) {
283 if (asset.getCapitalAssetNumber() != null && !isAssetNumberDuplicate(asset.getCapitalAssetNumber(), assetNumbers)) {
284 assetNumbers.add(asset);
285 }
286 }
287 return assetNumbers;
288 }
289
290
291
292
293
294
295
296
297 protected boolean isAssetNumberDuplicate(Long candidateNumber, List<ItemCapitalAsset> assetNumbers) {
298 for (ItemCapitalAsset existingNumber : assetNumbers) {
299 if (existingNumber.getCapitalAssetNumber().equals(candidateNumber)) {
300 return true;
301 }
302 }
303 return false;
304 }
305
306
307
308
309
310
311
312
313 protected List<PurchasingAccountsPayableItemAsset> getMatchingItems(Integer itemIdentifier, List<PurchasingAccountsPayableDocument> purApDocs) {
314 List<PurchasingAccountsPayableItemAsset> matchingItems = new ArrayList<PurchasingAccountsPayableItemAsset>();
315
316 if (itemIdentifier != null) {
317 for (PurchasingAccountsPayableDocument purApDoc : purApDocs) {
318 for (PurchasingAccountsPayableItemAsset item : purApDoc.getPurchasingAccountsPayableItemAssets()) {
319 if (itemIdentifier.equals(item.getPurchaseOrderItemIdentifier())) {
320 matchingItems.add(item);
321 }
322 }
323 }
324 }
325 return matchingItems;
326 }
327
328
329
330
331
332
333
334
335 public void setAccountsPayableItemsFromPurAp(PurchasingAccountsPayableItemAsset purchasingAccountsPayableItemAsset, String docTypeCode) {
336 Map<String, Object> pKeys = new HashMap<String, Object>();
337 pKeys.put(PurapPropertyConstants.ITEM_IDENTIFIER, purchasingAccountsPayableItemAsset.getAccountsPayableLineItemIdentifier());
338
339
340 if (CabConstants.PREQ.equalsIgnoreCase(docTypeCode)) {
341
342 PaymentRequestItem item = (PaymentRequestItem) businessObjectService.findByPrimaryKey(PaymentRequestItem.class, pKeys);
343 if (ObjectUtils.isNull(item)) {
344 throw new PurApDocumentUnavailableException("PaymentRequestItem with id = " + purchasingAccountsPayableItemAsset.getAccountsPayableLineItemIdentifier() + " doesn't exist in table.");
345 }
346
347 purchasingAccountsPayableItemAsset.setItemLineNumber(item.getItemLineNumber());
348 if (item.getItemType() != null) {
349 purchasingAccountsPayableItemAsset.setAdditionalChargeNonTradeInIndicator(item.getItemType().isAdditionalChargeIndicator() & !CabConstants.TRADE_IN_TYPE_CODE.equalsIgnoreCase(item.getItemTypeCode()));
350 purchasingAccountsPayableItemAsset.setTradeInAllowance(item.getItemType().isAdditionalChargeIndicator() & CabConstants.TRADE_IN_TYPE_CODE.equalsIgnoreCase(item.getItemTypeCode()));
351 purchasingAccountsPayableItemAsset.setItemTypeCode(item.getItemTypeCode());
352 }
353 purchasingAccountsPayableItemAsset.setItemAssignedToTradeInIndicator(item.getItemAssignedToTradeInIndicator());
354
355 PurchaseOrderItem poi = item.getPurchaseOrderItem();
356 if (poi != null) {
357 purchasingAccountsPayableItemAsset.setPurchaseOrderItemIdentifier(poi.getItemIdentifier());
358 }
359 }
360 else {
361
362 CreditMemoItem item = (CreditMemoItem) businessObjectService.findByPrimaryKey(CreditMemoItem.class, pKeys);
363 if (ObjectUtils.isNull(item)) {
364 throw new PurApDocumentUnavailableException("CreditMemoItem with id = " + purchasingAccountsPayableItemAsset.getAccountsPayableLineItemIdentifier() + " doesn't exist in table.");
365 }
366
367 purchasingAccountsPayableItemAsset.setItemLineNumber(item.getItemLineNumber());
368 if (item.getItemType() != null) {
369 purchasingAccountsPayableItemAsset.setAdditionalChargeNonTradeInIndicator(item.getItemType().isAdditionalChargeIndicator() & !CabConstants.TRADE_IN_TYPE_CODE.equalsIgnoreCase(item.getItemTypeCode()));
370 purchasingAccountsPayableItemAsset.setTradeInAllowance(item.getItemType().isAdditionalChargeIndicator() & CabConstants.TRADE_IN_TYPE_CODE.equalsIgnoreCase(item.getItemTypeCode()));
371 purchasingAccountsPayableItemAsset.setItemTypeCode(item.getItemTypeCode());
372 }
373 purchasingAccountsPayableItemAsset.setItemAssignedToTradeInIndicator(item.getItemAssignedToTradeInIndicator());
374
375 PurchaseOrderItem poi = getPurchaseOrderItemfromCreditMemoItem(item);
376 if (poi != null) {
377 purchasingAccountsPayableItemAsset.setPurchaseOrderItemIdentifier(poi.getItemIdentifier());
378 }
379
380 VendorCreditMemoDocument cmDoc = (VendorCreditMemoDocument) item.getPurapDocument();
381 if (ObjectUtils.isNotNull(cmDoc) && cmDoc.isSourceDocumentPaymentRequest()) {
382 purchasingAccountsPayableItemAsset.setPaymentRequestIdentifier(cmDoc.getPaymentRequestIdentifier());
383 }
384 }
385 }
386
387
388
389
390
391
392
393
394
395 protected PurchaseOrderItem getPurchaseOrderItemfromCreditMemoItem(CreditMemoItem item) {
396 if (ObjectUtils.isNotNull(item.getPurapDocumentIdentifier())) {
397 if (ObjectUtils.isNull(item.getPurapDocument())) {
398 item.refreshReferenceObject(PurapPropertyConstants.PURAP_DOC);
399 }
400 }
401
402
403 if (item.getPurapDocument() != null) {
404 PurchaseOrderDocument po = ((VendorCreditMemoDocument) item.getPurapDocument()).getPurchaseOrderDocument();
405 PurchaseOrderItem poi = null;
406 if (item.getItemType().isLineItemIndicator()) {
407 if (po.getItems() == null || po.getItems().isEmpty()) {
408 po.refreshReferenceObject("items");
409 }
410 poi = (PurchaseOrderItem) po.getItem(item.getItemLineNumber().intValue() - 1);
411 }
412 else {
413
414
415 poi = (PurchaseOrderItem) SpringContext.getBean(PurapService.class).getBelowTheLineByType(po, item.getItemType());
416 }
417 if (poi != null) {
418 return poi;
419 }
420 else {
421 if (LOG.isDebugEnabled()) {
422 LOG.debug("getPurchaseOrderItemfromCreditMemoItem() Returning null because PurchaseOrderItem object for line number" + item.getItemLineNumber() + "or itemType " + item.getItemTypeCode() + " is null");
423 }
424 return null;
425 }
426 }
427 else {
428
429 LOG.error("getPurchaseOrderItemfromCreditMemoItem() Returning null because paymentRequest object is null");
430 throw new PurError("Credit Memo Object in Purchase Order item line number " + item.getItemLineNumber() + "or itemType " + item.getItemTypeCode() + " is null");
431 }
432 }
433
434
435 public List<Long> retrieveValidAssetNumberForLocking(Integer poId, String capitalAssetSystemTypeCode, PurApItem purApItem) {
436 List<Long> capitalAssetNumbers = new ArrayList<Long>();
437 CapitalAssetSystem capitalAssetSystem = null;
438
439 if (PurapConstants.CapitalAssetTabStrings.INDIVIDUAL_ASSETS.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
440
441 capitalAssetSystem = getCapitalAssetSystemForIndividual(poId, purApItem);
442
443 }
444 else if (PurapConstants.CapitalAssetTabStrings.ONE_SYSTEM.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
445 capitalAssetSystem = this.getPurchaseOrderService().retrieveCapitalAssetSystemForOneSystem(poId);
446 }
447 else if (PurapConstants.CapitalAssetTabStrings.MULTIPLE_SYSTEMS.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
448 List<CapitalAssetSystem> capitalAssetSystems = this.getPurchaseOrderService().retrieveCapitalAssetSystemsForMultipleSystem(poId);
449 if (ObjectUtils.isNotNull(capitalAssetSystems) && !capitalAssetSystems.isEmpty()) {
450
451 capitalAssetSystem = capitalAssetSystems.get(0);
452 }
453 }
454
455 if (ObjectUtils.isNotNull(capitalAssetSystem) && capitalAssetSystem.getItemCapitalAssets() != null && !capitalAssetSystem.getItemCapitalAssets().isEmpty()) {
456 for (ItemCapitalAsset itemCapitalAsset : capitalAssetSystem.getItemCapitalAssets()) {
457 if (itemCapitalAsset.getCapitalAssetNumber() != null) {
458 Map pKeys = new HashMap<String, Object>();
459
460 pKeys.put(CamsPropertyConstants.Asset.CAPITAL_ASSET_NUMBER, itemCapitalAsset.getCapitalAssetNumber());
461
462 Asset asset = (Asset) businessObjectService.findByPrimaryKey(Asset.class, pKeys);
463 if (ObjectUtils.isNotNull(asset) && getAssetService().isCapitalAsset(asset) && !getAssetService().isAssetRetired(asset)) {
464 capitalAssetNumbers.add(itemCapitalAsset.getCapitalAssetNumber());
465 }
466 }
467 }
468 }
469 return capitalAssetNumbers;
470 }
471
472 protected CapitalAssetSystem getCapitalAssetSystemForIndividual(Integer poId, PurApItem purApItem) {
473 List<PurchasingCapitalAssetItem> capitalAssetItems = this.getPurchaseOrderService().retrieveCapitalAssetItemsForIndividual(poId);
474 if (capitalAssetItems == null || capitalAssetItems.isEmpty()) {
475 return null;
476 }
477
478 Integer purchaseOrderItemIdentifier = null;
479 PurchaseOrderItem poi = null;
480 if (purApItem instanceof PaymentRequestItem) {
481 poi = ((PaymentRequestItem) purApItem).getPurchaseOrderItem();
482
483 }
484 else if (purApItem instanceof CreditMemoItem) {
485 poi = getPurchaseOrderItemfromCreditMemoItem((CreditMemoItem) purApItem);
486 }
487
488 if (poi != null) {
489 purchaseOrderItemIdentifier = poi.getItemIdentifier();
490 }
491 for (PurchasingCapitalAssetItem capitalAssetItem : capitalAssetItems) {
492 if (capitalAssetItem.getItemIdentifier().equals(purchaseOrderItemIdentifier)) {
493 return capitalAssetItem.getPurchasingCapitalAssetSystem();
494 }
495 }
496 return null;
497 }
498
499 protected AssetService getAssetService() {
500 return SpringContext.getBean(AssetService.class);
501 }
502
503
504
505
506
507
508 public BusinessObjectService getBusinessObjectService() {
509 return businessObjectService;
510 }
511
512
513
514
515
516
517
518 public void setBusinessObjectService(BusinessObjectService businessObjectService) {
519 this.businessObjectService = businessObjectService;
520 }
521
522
523
524
525
526
527
528 public PurchaseOrderService getPurchaseOrderService() {
529 return SpringContext.getBean(PurchaseOrderService.class);
530 }
531
532
533 }