001 /*
002 * Copyright 2011 The Kuali Foundation.
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.kuali.kfs.module.cab.document.service.impl;
017
018 import java.util.ArrayList;
019 import java.util.Collection;
020 import java.util.HashMap;
021 import java.util.Iterator;
022 import java.util.List;
023 import java.util.Map;
024
025 import org.apache.log4j.Logger;
026 import org.kuali.kfs.integration.purap.CapitalAssetSystem;
027 import org.kuali.kfs.integration.purap.ItemCapitalAsset;
028 import org.kuali.kfs.module.cab.CabConstants;
029 import org.kuali.kfs.module.cab.CabPropertyConstants;
030 import org.kuali.kfs.module.cab.businessobject.PurchasingAccountsPayableDocument;
031 import org.kuali.kfs.module.cab.businessobject.PurchasingAccountsPayableItemAsset;
032 import org.kuali.kfs.module.cab.document.exception.PurApDocumentUnavailableException;
033 import org.kuali.kfs.module.cab.document.service.PurApInfoService;
034 import org.kuali.kfs.module.cab.document.web.struts.PurApLineForm;
035 import org.kuali.kfs.module.cam.CamsConstants;
036 import org.kuali.kfs.module.cam.CamsPropertyConstants;
037 import org.kuali.kfs.module.cam.businessobject.Asset;
038 import org.kuali.kfs.module.cam.document.service.AssetService;
039 import org.kuali.kfs.module.purap.PurapConstants;
040 import org.kuali.kfs.module.purap.PurapPropertyConstants;
041 import org.kuali.kfs.module.purap.businessobject.CreditMemoItem;
042 import org.kuali.kfs.module.purap.businessobject.PaymentRequestItem;
043 import org.kuali.kfs.module.purap.businessobject.PurApItem;
044 import org.kuali.kfs.module.purap.businessobject.PurchaseOrderItem;
045 import org.kuali.kfs.module.purap.businessobject.PurchasingCapitalAssetItem;
046 import org.kuali.kfs.module.purap.document.PurchaseOrderDocument;
047 import org.kuali.kfs.module.purap.document.VendorCreditMemoDocument;
048 import org.kuali.kfs.module.purap.document.service.PurapService;
049 import org.kuali.kfs.module.purap.document.service.PurchaseOrderService;
050 import org.kuali.kfs.module.purap.exception.PurError;
051 import org.kuali.kfs.sys.context.SpringContext;
052 import org.kuali.rice.kns.service.BusinessObjectService;
053 import org.kuali.rice.kns.util.ObjectUtils;
054
055
056 /**
057 * This class provides default implementations of {@link PurApLineService}
058 */
059 public class PurApInfoServiceImpl implements PurApInfoService {
060 private static final Logger LOG = Logger.getLogger(PurApInfoServiceImpl.class);
061 private BusinessObjectService businessObjectService;
062
063 protected static final String PURCHASE_ORDER_CURRENT_INDICATOR = "purchaseOrderCurrentIndicator";
064
065 /**
066 * @see org.kuali.kfs.module.cab.document.service.PurApInfoService#getDocumentNumberForPurchaseOrderIdentifier(java.lang.Integer)
067 */
068 public PurchaseOrderDocument getCurrentDocumentForPurchaseOrderIdentifier(Integer poId) {
069 Map<String, Object> fieldValues = new HashMap<String, Object>();
070
071 fieldValues.put(CabPropertyConstants.PurchasingAccountsPayableDocument.PURAP_DOCUMENT_IDENTIFIER, poId);
072 fieldValues.put(PURCHASE_ORDER_CURRENT_INDICATOR, "Y");
073 Collection<PurchaseOrderDocument> poDocs = getBusinessObjectService().findMatching(PurchaseOrderDocument.class, fieldValues);
074 if (poDocs != null && !poDocs.isEmpty()) {
075 Iterator<PurchaseOrderDocument> poIterator = poDocs.iterator();
076 if (poIterator.hasNext()) {
077 return poIterator.next();
078 }
079 }
080
081 return null;
082 }
083
084 /**
085 * @see org.kuali.kfs.module.cab.document.service.PurApLineService#setPurchaseOrderInfo(org.kuali.kfs.module.cab.document.web.struts.PurApLineForm)
086 */
087 public void setPurchaseOrderFromPurAp(PurApLineForm purApLineForm) {
088 PurchaseOrderDocument purchaseOrderDocument = getCurrentDocumentForPurchaseOrderIdentifier(purApLineForm.getPurchaseOrderIdentifier());
089
090 if (ObjectUtils.isNull(purchaseOrderDocument)) {
091 return;
092 }
093 // Set contact email address.
094 if (purchaseOrderDocument.getInstitutionContactEmailAddress() != null) {
095 purApLineForm.setPurApContactEmailAddress(purchaseOrderDocument.getInstitutionContactEmailAddress());
096 }
097 else if (purchaseOrderDocument.getRequestorPersonEmailAddress() != null) {
098 purApLineForm.setPurApContactEmailAddress(purchaseOrderDocument.getRequestorPersonEmailAddress());
099 }
100
101 // Set contact phone number.
102 if (purchaseOrderDocument.getInstitutionContactPhoneNumber() != null) {
103 purApLineForm.setPurApContactPhoneNumber(purchaseOrderDocument.getInstitutionContactPhoneNumber());
104 }
105 else if (purchaseOrderDocument.getRequestorPersonPhoneNumber() != null) {
106 purApLineForm.setPurApContactPhoneNumber(purchaseOrderDocument.getRequestorPersonPhoneNumber());
107 }
108
109 // set reqs_id
110 purApLineForm.setRequisitionIdentifier(purchaseOrderDocument.getRequisitionIdentifier());
111
112 }
113
114
115 /**
116 * Set CAMS transaction type code the user entered in PurAp
117 *
118 * @param poId
119 */
120 public void setCamsTransactionFromPurAp(List<PurchasingAccountsPayableDocument> purApDocs) {
121 if (ObjectUtils.isNull(purApDocs) || purApDocs.isEmpty()) {
122 return;
123 }
124 Integer poId = purApDocs.get(0).getPurchaseOrderIdentifier();
125 PurchaseOrderDocument purApdocument = getCurrentDocumentForPurchaseOrderIdentifier(poId);
126 if (ObjectUtils.isNull(purApdocument)) {
127 return;
128 }
129
130 String capitalAssetSystemTypeCode = purApdocument.getCapitalAssetSystemTypeCode();
131 String capitalAssetSystemStateCode = purApdocument.getCapitalAssetSystemStateCode();
132 boolean individualItemLock = false;
133
134 if (PurapConstants.CapitalAssetTabStrings.INDIVIDUAL_ASSETS.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
135 // If PurAp sets the CAMS as INDIVIDUAL system
136 setIndividualAssetsFromPurAp(poId, purApDocs, capitalAssetSystemStateCode);
137 individualItemLock = true;
138 }
139 else if (PurapConstants.CapitalAssetTabStrings.ONE_SYSTEM.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
140 // If PurAp sets the CAMS as ONE system
141 setOneSystemFromPurAp(poId, purApDocs, capitalAssetSystemStateCode);
142
143 }
144 else if (PurapConstants.CapitalAssetTabStrings.MULTIPLE_SYSTEMS.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
145 // If PurAp sets the CAMS as MULTIPLE system
146 setMultipleSystemFromPurAp(poId, purApDocs, capitalAssetSystemStateCode);
147 }
148
149 // Setting locking information based on capital asset system type code. Currently, only individual system can set asset
150 // numbers for each item
151 for (PurchasingAccountsPayableDocument purApDoc : purApDocs) {
152 for (PurchasingAccountsPayableItemAsset itemAsset : purApDoc.getPurchasingAccountsPayableItemAssets()) {
153 itemAsset.setLockingInformation(individualItemLock ? itemAsset.getAccountsPayableLineItemIdentifier().toString() : CamsConstants.defaultLockingInformation);
154 }
155 }
156 }
157
158 /**
159 * Set Multiple system capital asset transaction type code and asset numbers.
160 *
161 * @param poId
162 * @param purApDocs
163 */
164 protected void setMultipleSystemFromPurAp(Integer poId, List<PurchasingAccountsPayableDocument> purApDocs, String capitalAssetSystemStateCode) {
165 List<CapitalAssetSystem> capitalAssetSystems = this.getPurchaseOrderService().retrieveCapitalAssetSystemsForMultipleSystem(poId);
166 if (ObjectUtils.isNotNull(capitalAssetSystems) && !capitalAssetSystems.isEmpty()) {
167 // PurAp doesn't support multiple system asset information for KFS3.0. It works as one system for 3.0.
168 CapitalAssetSystem capitalAssetSystem = capitalAssetSystems.get(0);
169 if (ObjectUtils.isNotNull(capitalAssetSystem)) {
170 String capitalAssetTransactionType = getCapitalAssetTransTypeForOneSystem(poId);
171 // if modify existing asset, acquire the assets from Purap
172 List<ItemCapitalAsset> purApCapitalAssets = null;
173 if (PurapConstants.CapitalAssetSystemStates.MODIFY.equalsIgnoreCase(capitalAssetSystemStateCode)) {
174 purApCapitalAssets = getAssetsFromItemCapitalAsset(capitalAssetSystem.getItemCapitalAssets());
175 }
176
177 // set TransactionTypeCode, itemCapitalAssets and system identifier for each item
178 for (PurchasingAccountsPayableDocument purApDoc : purApDocs) {
179 setItemAssetsCamsTransaction(capitalAssetSystem.getCapitalAssetSystemIdentifier(), capitalAssetTransactionType, purApCapitalAssets, purApDoc.getPurchasingAccountsPayableItemAssets());
180 }
181 }
182 }
183 }
184
185 /**
186 * Set One System capital asset transaction type code and asset numbers.
187 *
188 * @param poId
189 * @param purApDocs
190 */
191 protected void setOneSystemFromPurAp(Integer poId, List<PurchasingAccountsPayableDocument> purApDocs, String capitalAssetSystemStateCode) {
192 CapitalAssetSystem capitalAssetSystem = this.getPurchaseOrderService().retrieveCapitalAssetSystemForOneSystem(poId);
193 String capitalAssetTransactionTypeCode = getCapitalAssetTransTypeForOneSystem(poId);
194 List<ItemCapitalAsset> purApCapitalAssets = null;
195 // if modify existing asset, acquire the assets from Purap
196 if (PurapConstants.CapitalAssetSystemStates.MODIFY.equalsIgnoreCase(capitalAssetSystemStateCode)) {
197 purApCapitalAssets = getAssetsFromItemCapitalAsset(capitalAssetSystem.getItemCapitalAssets());
198 }
199
200 for (PurchasingAccountsPayableDocument purApDoc : purApDocs) {
201 // set TransactionTypeCode, itemCapitalAssets and system identifier for each item
202 setItemAssetsCamsTransaction(capitalAssetSystem.getCapitalAssetSystemIdentifier(), capitalAssetTransactionTypeCode, purApCapitalAssets, purApDoc.getPurchasingAccountsPayableItemAssets());
203 }
204 }
205
206 /**
207 * Update item assets by PurAp Cams Transaction setting
208 *
209 * @param capitalAssetSystemIdentifier
210 * @param capitRalAssetTransactionTypeCode
211 * @param purApCapitalAssets
212 * @param itemAssets
213 */
214 protected void setItemAssetsCamsTransaction(Integer capitalAssetSystemIdentifier, String capitalAssetTransactionTypeCode, List<ItemCapitalAsset> purApCapitalAssets, List<PurchasingAccountsPayableItemAsset> itemAssets) {
215 for (PurchasingAccountsPayableItemAsset item : itemAssets) {
216 item.setCapitalAssetTransactionTypeCode(capitalAssetTransactionTypeCode);
217 // set for item capital assets
218 if (purApCapitalAssets != null && !purApCapitalAssets.isEmpty()) {
219 item.getPurApItemAssets().addAll(purApCapitalAssets);
220 }
221 // set for capital asset system ID
222 item.setCapitalAssetSystemIdentifier(capitalAssetSystemIdentifier);
223 }
224 }
225
226 /**
227 * Get capitalAssetTransactionTypeCode for one system from PurAp.
228 *
229 * @param poId
230 * @return
231 */
232 protected String getCapitalAssetTransTypeForOneSystem(Integer poId) {
233 PurchaseOrderDocument poDoc = getCurrentDocumentForPurchaseOrderIdentifier(poId);
234 if (ObjectUtils.isNotNull(poDoc)) {
235 List<PurchasingCapitalAssetItem> capitalAssetItems = poDoc.getPurchasingCapitalAssetItems();
236
237 if (ObjectUtils.isNotNull(capitalAssetItems) && capitalAssetItems.get(0) != null) {
238 return capitalAssetItems.get(0).getCapitalAssetTransactionTypeCode();
239 }
240 }
241 return null;
242 }
243
244 /**
245 * Set Individual system asset transaction type and asset numbers.
246 *
247 * @param poId
248 * @param purApDocs
249 */
250 protected void setIndividualAssetsFromPurAp(Integer poId, List<PurchasingAccountsPayableDocument> purApDocs, String capitalAssetSystemStateCode) {
251 List<PurchasingCapitalAssetItem> capitalAssetItems = this.getPurchaseOrderService().retrieveCapitalAssetItemsForIndividual(poId);
252 String capitalAssetTransactionTypeCode = null;
253 List<ItemCapitalAsset> purApCapitalAssets = null;
254
255 // For each capitalAssetItem from PurAp, we set it to all matching CAB items
256 for (PurchasingCapitalAssetItem purchasingCapitalAssetItem : capitalAssetItems) {
257 capitalAssetTransactionTypeCode = purchasingCapitalAssetItem.getCapitalAssetTransactionTypeCode();
258 // get matching CAB items origin from the same PO item.
259 List<PurchasingAccountsPayableItemAsset> matchingItems = getMatchingItems(purchasingCapitalAssetItem.getItemIdentifier(), purApDocs);
260 // if modify existing asset, acquire the assets from Puraps
261 if (PurapConstants.CapitalAssetSystemStates.MODIFY.equalsIgnoreCase(capitalAssetSystemStateCode)) {
262 purApCapitalAssets = getAssetsFromItemCapitalAsset(purchasingCapitalAssetItem.getPurchasingCapitalAssetSystem().getItemCapitalAssets());
263 }
264
265 // set TransactionTypeCode, itemCapitalAssets and system identifier for each matching item
266 setItemAssetsCamsTransaction(purchasingCapitalAssetItem.getCapitalAssetSystemIdentifier(), capitalAssetTransactionTypeCode, purApCapitalAssets, matchingItems);
267 }
268 }
269
270 /**
271 * Get asset number list from ItemCapitalAsset list.
272 *
273 * @param itemCapitalAssets
274 * @return
275 */
276 protected List<ItemCapitalAsset> getAssetsFromItemCapitalAsset(List<ItemCapitalAsset> itemCapitalAssets) {
277 List<ItemCapitalAsset> assetNumbers = new ArrayList<ItemCapitalAsset>();
278
279 for (ItemCapitalAsset asset : itemCapitalAssets) {
280 if (asset.getCapitalAssetNumber() != null && !isAssetNumberDuplicate(asset.getCapitalAssetNumber(), assetNumbers)) {
281 assetNumbers.add(asset);
282 }
283 }
284 return assetNumbers;
285 }
286
287 /**
288 * Check if given capitalAssetNumber is an duplicate number in assetNumbers list.
289 *
290 * @param capitalAssetNumber
291 * @param assetNumbers
292 * @return
293 */
294 protected boolean isAssetNumberDuplicate(Long candidateNumber, List<ItemCapitalAsset> assetNumbers) {
295 for (ItemCapitalAsset existingNumber : assetNumbers) {
296 if (existingNumber.getCapitalAssetNumber().equals(candidateNumber)) {
297 return true;
298 }
299 }
300 return false;
301 }
302
303 /**
304 * Finding out the matching PREQ/CM items originating from the same PurchaseOrderItem.
305 *
306 * @param itemIdentifier
307 * @param purApDocs
308 * @return
309 */
310 protected List<PurchasingAccountsPayableItemAsset> getMatchingItems(Integer itemIdentifier, List<PurchasingAccountsPayableDocument> purApDocs) {
311 List<PurchasingAccountsPayableItemAsset> matchingItems = new ArrayList<PurchasingAccountsPayableItemAsset>();
312
313 if (itemIdentifier != null) {
314 for (PurchasingAccountsPayableDocument purApDoc : purApDocs) {
315 for (PurchasingAccountsPayableItemAsset item : purApDoc.getPurchasingAccountsPayableItemAssets()) {
316 if (itemIdentifier.equals(item.getPurchaseOrderItemIdentifier())) {
317 matchingItems.add(item);
318 }
319 }
320 }
321 }
322 return matchingItems;
323 }
324
325
326 /**
327 * Set CAB line item information from PurAp PaymentRequestItem or CreditMemoItem.
328 *
329 * @param purchasingAccountsPayableItemAsset
330 * @param docTypeCode
331 */
332 public void setAccountsPayableItemsFromPurAp(PurchasingAccountsPayableItemAsset purchasingAccountsPayableItemAsset, String docTypeCode) {
333 Map<String, Object> pKeys = new HashMap<String, Object>();
334 pKeys.put(PurapPropertyConstants.ITEM_IDENTIFIER, purchasingAccountsPayableItemAsset.getAccountsPayableLineItemIdentifier());
335
336 // Access PurAp data based on item type(PREQ or CM).
337 if (CabConstants.PREQ.equalsIgnoreCase(docTypeCode)) {
338 // for PREQ document
339 PaymentRequestItem item = (PaymentRequestItem) businessObjectService.findByPrimaryKey(PaymentRequestItem.class, pKeys);
340 if (ObjectUtils.isNull(item)) {
341 throw new PurApDocumentUnavailableException("PaymentRequestItem with id = " + purchasingAccountsPayableItemAsset.getAccountsPayableLineItemIdentifier() + " doesn't exist in table.");
342 }
343
344 purchasingAccountsPayableItemAsset.setItemLineNumber(item.getItemLineNumber());
345 if (item.getItemType() != null) {
346 purchasingAccountsPayableItemAsset.setAdditionalChargeNonTradeInIndicator(item.getItemType().isAdditionalChargeIndicator() & !CabConstants.TRADE_IN_TYPE_CODE.equalsIgnoreCase(item.getItemTypeCode()));
347 purchasingAccountsPayableItemAsset.setTradeInAllowance(item.getItemType().isAdditionalChargeIndicator() & CabConstants.TRADE_IN_TYPE_CODE.equalsIgnoreCase(item.getItemTypeCode()));
348 purchasingAccountsPayableItemAsset.setItemTypeCode(item.getItemTypeCode());
349 }
350 purchasingAccountsPayableItemAsset.setItemAssignedToTradeInIndicator(item.getItemAssignedToTradeInIndicator());
351 // PurchaseOrderItemIdentifier will be used when populate PurAp asset data
352 PurchaseOrderItem poi = item.getPurchaseOrderItem();
353 if (poi != null) {
354 purchasingAccountsPayableItemAsset.setPurchaseOrderItemIdentifier(poi.getItemIdentifier());
355 }
356 }
357 else {
358 // for CM document
359 CreditMemoItem item = (CreditMemoItem) businessObjectService.findByPrimaryKey(CreditMemoItem.class, pKeys);
360 if (ObjectUtils.isNull(item)) {
361 throw new PurApDocumentUnavailableException("CreditMemoItem with id = " + purchasingAccountsPayableItemAsset.getAccountsPayableLineItemIdentifier() + " doesn't exist in table.");
362 }
363
364 purchasingAccountsPayableItemAsset.setItemLineNumber(item.getItemLineNumber());
365 if (item.getItemType() != null) {
366 purchasingAccountsPayableItemAsset.setAdditionalChargeNonTradeInIndicator(item.getItemType().isAdditionalChargeIndicator() & !CabConstants.TRADE_IN_TYPE_CODE.equalsIgnoreCase(item.getItemTypeCode()));
367 purchasingAccountsPayableItemAsset.setTradeInAllowance(item.getItemType().isAdditionalChargeIndicator() & CabConstants.TRADE_IN_TYPE_CODE.equalsIgnoreCase(item.getItemTypeCode()));
368 purchasingAccountsPayableItemAsset.setItemTypeCode(item.getItemTypeCode());
369 }
370 purchasingAccountsPayableItemAsset.setItemAssignedToTradeInIndicator(item.getItemAssignedToTradeInIndicator());
371 // PurchaseOrderItemIdentifier will be used when populate PurAp asset data
372 PurchaseOrderItem poi = getPurchaseOrderItemfromCreditMemoItem(item);
373 if (poi != null) {
374 purchasingAccountsPayableItemAsset.setPurchaseOrderItemIdentifier(poi.getItemIdentifier());
375 }
376 // if PREQ Credit Memo document
377 VendorCreditMemoDocument cmDoc = (VendorCreditMemoDocument) item.getPurapDocument();
378 if (ObjectUtils.isNotNull(cmDoc) && cmDoc.isSourceDocumentPaymentRequest()) {
379 purchasingAccountsPayableItemAsset.setPaymentRequestIdentifier(cmDoc.getPaymentRequestIdentifier());
380 }
381 }
382 }
383
384
385 /**
386 * Retreives a purchase order item for a given CreditMemoItem by inspecting the item type to see if its above the line or below
387 * the line and returns the appropriate type.
388 *
389 * @param item
390 * @return
391 */
392 protected PurchaseOrderItem getPurchaseOrderItemfromCreditMemoItem(CreditMemoItem item) {
393 if (ObjectUtils.isNotNull(item.getPurapDocumentIdentifier())) {
394 if (ObjectUtils.isNull(item.getPurapDocument())) {
395 item.refreshReferenceObject(PurapPropertyConstants.PURAP_DOC);
396 }
397 }
398 // ideally we should do this a different way - maybe move it all into the service or save this info somehow (make sure and
399 // update though)
400 if (item.getPurapDocument() != null) {
401 PurchaseOrderDocument po = ((VendorCreditMemoDocument) item.getPurapDocument()).getPurchaseOrderDocument();
402 PurchaseOrderItem poi = null;
403 if (item.getItemType().isLineItemIndicator()) {
404 if (po.getItems() == null || po.getItems().isEmpty()) {
405 po.refreshReferenceObject("items");
406 }
407 poi = (PurchaseOrderItem) po.getItem(item.getItemLineNumber().intValue() - 1);
408 }
409 else {
410 // To get the purchaseOrderItem by given CreditMemoItem. Since the additional charge type may be different in CM and
411 // PO, there could be no PO Item for a given CM item.
412 poi = (PurchaseOrderItem) SpringContext.getBean(PurapService.class).getBelowTheLineByType(po, item.getItemType());
413 }
414 if (poi != null) {
415 return poi;
416 }
417 else {
418 LOG.debug("getPurchaseOrderItemfromCreditMemoItem() Returning null because PurchaseOrderItem object for line number" + item.getItemLineNumber() + "or itemType " + item.getItemTypeCode() + " is null");
419 return null;
420 }
421 }
422 else {
423
424 LOG.error("getPurchaseOrderItemfromCreditMemoItem() Returning null because paymentRequest object is null");
425 throw new PurError("Credit Memo Object in Purchase Order item line number " + item.getItemLineNumber() + "or itemType " + item.getItemTypeCode() + " is null");
426 }
427 }
428
429
430 public List<Long> retrieveValidAssetNumberForLocking(Integer poId, String capitalAssetSystemTypeCode, PurApItem purApItem) {
431 List<Long> capitalAssetNumbers = new ArrayList<Long>();
432 CapitalAssetSystem capitalAssetSystem = null;
433
434 if (PurapConstants.CapitalAssetTabStrings.INDIVIDUAL_ASSETS.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
435 // If PurAp sets the CAMS as INDIVIDUAL system
436 capitalAssetSystem = getCapitalAssetSystemForIndividual(poId, purApItem);
437
438 }
439 else if (PurapConstants.CapitalAssetTabStrings.ONE_SYSTEM.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
440 capitalAssetSystem = this.getPurchaseOrderService().retrieveCapitalAssetSystemForOneSystem(poId);
441 }
442 else if (PurapConstants.CapitalAssetTabStrings.MULTIPLE_SYSTEMS.equalsIgnoreCase(capitalAssetSystemTypeCode)) {
443 List<CapitalAssetSystem> capitalAssetSystems = this.getPurchaseOrderService().retrieveCapitalAssetSystemsForMultipleSystem(poId);
444 if (ObjectUtils.isNotNull(capitalAssetSystems) && !capitalAssetSystems.isEmpty()) {
445 // PurAp doesn't support multiple system asset information for KFS3.0. It works as One system.
446 capitalAssetSystem = capitalAssetSystems.get(0);
447 }
448 }
449
450 if (ObjectUtils.isNotNull(capitalAssetSystem) && capitalAssetSystem.getItemCapitalAssets() != null && !capitalAssetSystem.getItemCapitalAssets().isEmpty()) {
451 for (ItemCapitalAsset itemCapitalAsset : capitalAssetSystem.getItemCapitalAssets()) {
452 if (itemCapitalAsset.getCapitalAssetNumber() != null) {
453 Map pKeys = new HashMap<String, Object>();
454 // Asset must be valid and capital active 'A','C','S','U'
455 pKeys.put(CamsPropertyConstants.Asset.CAPITAL_ASSET_NUMBER, itemCapitalAsset.getCapitalAssetNumber());
456
457 Asset asset = (Asset) businessObjectService.findByPrimaryKey(Asset.class, pKeys);
458 if (ObjectUtils.isNotNull(asset) && getAssetService().isCapitalAsset(asset) && !getAssetService().isAssetRetired(asset)) {
459 capitalAssetNumbers.add(itemCapitalAsset.getCapitalAssetNumber());
460 }
461 }
462 }
463 }
464 return capitalAssetNumbers;
465 }
466
467 protected CapitalAssetSystem getCapitalAssetSystemForIndividual(Integer poId, PurApItem purApItem) {
468 List<PurchasingCapitalAssetItem> capitalAssetItems = this.getPurchaseOrderService().retrieveCapitalAssetItemsForIndividual(poId);
469 if (capitalAssetItems == null || capitalAssetItems.isEmpty()) {
470 return null;
471 }
472
473 Integer purchaseOrderItemIdentifier = null;
474 PurchaseOrderItem poi = null;
475 if (purApItem instanceof PaymentRequestItem) {
476 poi = ((PaymentRequestItem) purApItem).getPurchaseOrderItem();
477
478 }
479 else if (purApItem instanceof CreditMemoItem) {
480 poi = getPurchaseOrderItemfromCreditMemoItem((CreditMemoItem) purApItem);
481 }
482
483 if (poi != null) {
484 purchaseOrderItemIdentifier = poi.getItemIdentifier();
485 }
486 for (PurchasingCapitalAssetItem capitalAssetItem : capitalAssetItems) {
487 if (capitalAssetItem.getItemIdentifier().equals(purchaseOrderItemIdentifier)) {
488 return capitalAssetItem.getPurchasingCapitalAssetSystem();
489 }
490 }
491 return null;
492 }
493
494 protected AssetService getAssetService() {
495 return SpringContext.getBean(AssetService.class);
496 }
497
498 /**
499 * Gets the businessObjectService attribute.
500 *
501 * @return Returns the businessObjectService.
502 */
503 public BusinessObjectService getBusinessObjectService() {
504 return businessObjectService;
505 }
506
507
508 /**
509 * Sets the businessObjectService attribute value.
510 *
511 * @param businessObjectService The businessObjectService to set.
512 */
513 public void setBusinessObjectService(BusinessObjectService businessObjectService) {
514 this.businessObjectService = businessObjectService;
515 }
516
517
518 /**
519 * Gets the purchaseOrderService attribute.
520 *
521 * @return Returns the purchaseOrderService.
522 */
523 public PurchaseOrderService getPurchaseOrderService() {
524 return SpringContext.getBean(PurchaseOrderService.class);
525 }
526
527
528 }