1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.ole.vnd.document.validation.impl;
17
18 import java.lang.reflect.Field;
19 import java.util.ArrayList;
20 import java.util.Date;
21 import java.util.HashMap;
22 import java.util.HashSet;
23 import java.util.Iterator;
24 import java.util.List;
25 import java.util.Map;
26 import java.util.Set;
27
28 import org.apache.commons.lang.StringUtils;
29 import org.kuali.ole.coa.businessobject.Chart;
30 import org.kuali.ole.coa.businessobject.Organization;
31 import org.kuali.ole.module.purap.businessobject.Carrier;
32 import org.kuali.ole.module.purap.document.PaymentRequestDocument;
33 import org.kuali.ole.module.purap.document.PurchaseOrderDocument;
34 import org.kuali.ole.select.service.OleForiegnVendorPhoneNumberService;
35 import org.kuali.ole.sys.OLEConstants;
36 import org.kuali.ole.sys.OLEKeyConstants;
37 import org.kuali.ole.sys.OLEPropertyConstants;
38 import org.kuali.ole.sys.context.SpringContext;
39 import org.kuali.ole.sys.service.PostalCodeValidationService;
40 import org.kuali.ole.vnd.VendorConstants;
41 import org.kuali.ole.vnd.VendorKeyConstants;
42 import org.kuali.ole.vnd.VendorParameterConstants;
43 import org.kuali.ole.vnd.VendorPropertyConstants;
44 import org.kuali.ole.vnd.businessobject.AddressType;
45 import org.kuali.ole.vnd.businessobject.OwnershipType;
46 import org.kuali.ole.vnd.businessobject.VendorAddress;
47 import org.kuali.ole.vnd.businessobject.VendorAlias;
48 import org.kuali.ole.vnd.businessobject.VendorCommodityCode;
49 import org.kuali.ole.vnd.businessobject.VendorContact;
50 import org.kuali.ole.vnd.businessobject.VendorContract;
51 import org.kuali.ole.vnd.businessobject.VendorContractOrganization;
52 import org.kuali.ole.vnd.businessobject.VendorCustomerNumber;
53 import org.kuali.ole.vnd.businessobject.VendorDefaultAddress;
54 import org.kuali.ole.vnd.businessobject.VendorDetail;
55 import org.kuali.ole.vnd.businessobject.VendorHeader;
56 import org.kuali.ole.vnd.businessobject.VendorPhoneNumber;
57 import org.kuali.ole.vnd.businessobject.VendorTransmissionFormatDetail;
58 import org.kuali.ole.vnd.businessobject.VendorType;
59 import org.kuali.ole.vnd.document.service.VendorService;
60 import org.kuali.ole.vnd.service.PhoneNumberService;
61 import org.kuali.ole.vnd.service.TaxNumberService;
62 import org.kuali.rice.core.api.datetime.DateTimeService;
63 import org.kuali.rice.core.api.parameter.ParameterEvaluatorService;
64 import org.kuali.rice.core.api.util.type.KualiDecimal;
65 import org.kuali.rice.coreservice.framework.parameter.ParameterService;
66 import org.kuali.rice.kns.document.MaintenanceDocument;
67 import org.kuali.rice.kns.maintenance.rules.MaintenanceDocumentRuleBase;
68 import org.kuali.rice.kns.service.DataDictionaryService;
69 import org.kuali.rice.krad.bo.PersistableBusinessObject;
70 import org.kuali.rice.krad.service.BusinessObjectService;
71 import org.kuali.rice.krad.service.PersistenceService;
72 import org.kuali.rice.krad.util.ErrorMessage;
73 import org.kuali.rice.krad.util.GlobalVariables;
74 import org.kuali.rice.krad.util.ObjectUtils;
75 import org.springframework.util.AutoPopulatingList;
76
77
78
79
80 public class VendorRule extends MaintenanceDocumentRuleBase {
81
82 private VendorDetail oldVendor;
83 private VendorDetail newVendor;
84
85
86
87
88
89
90
91
92
93
94
95 @Override
96 public void setupBaseConvenienceObjects(MaintenanceDocument document) {
97 oldVendor = (VendorDetail) document.getOldMaintainableObject().getBusinessObject();
98 newVendor = (VendorDetail) document.getNewMaintainableObject().getBusinessObject();
99 super.setNewBo(newVendor);
100 setupConvenienceObjects();
101 }
102
103
104
105
106 @Override
107 public void setupConvenienceObjects() {
108
109 refreshSubObjects(oldVendor);
110
111
112 refreshSubObjects(newVendor);
113 }
114
115
116
117
118
119
120
121 void refreshSubObjects(VendorDetail vendor) {
122 if (vendor == null) {
123 return;
124 }
125
126
127
128
129 if (!vendor.isVendorParentIndicator()) {
130 vendor.refreshNonUpdateableReferences();
131 vendor.getVendorHeader().refreshNonUpdateableReferences();
132
133 }
134 else {
135
136 List<String> headerFieldNames = getObjectReferencesListFromBOClass(VendorHeader.class);
137 vendor.getVendorHeader().refreshNonUpdateableReferences();
138 SpringContext.getBean(PersistenceService.class).retrieveReferenceObjects(vendor.getVendorHeader(), headerFieldNames);
139
140
141
142
143
144 List<String> detailFieldNames = getObjectReferencesListFromBOClass(vendor.getClass());
145 detailFieldNames.remove(VendorConstants.VENDOR_HEADER_ATTR);
146 SpringContext.getBean(PersistenceService.class).retrieveReferenceObjects(vendor, detailFieldNames);
147 }
148
149
150 if (vendor.getVendorAddresses() != null) {
151 for (VendorAddress address : vendor.getVendorAddresses()) {
152 address.refreshNonUpdateableReferences();
153 if (address.getVendorDefaultAddresses() != null) {
154 for (VendorDefaultAddress defaultAddress : address.getVendorDefaultAddresses()) {
155 defaultAddress.refreshNonUpdateableReferences();
156 }
157 }
158 }
159 }
160
161 if (vendor.getVendorContacts() != null) {
162 for (VendorContact contact : vendor.getVendorContacts()) {
163 contact.refreshNonUpdateableReferences();
164 }
165 }
166
167 if (vendor.getVendorContracts() != null) {
168 for (VendorContract contract : vendor.getVendorContracts()) {
169 contract.refreshNonUpdateableReferences();
170 }
171 }
172 }
173
174
175
176
177
178
179
180
181
182 private List getObjectReferencesListFromBOClass(Class theClass) {
183 List<String> results = new ArrayList();
184 for (Field theField : theClass.getDeclaredFields()) {
185
186 if ( PersistableBusinessObject.class.isAssignableFrom( theField.getType() ) ) {
187 results.add(theField.getName());
188 }
189 }
190 return results;
191 }
192
193
194
195
196 @Override
197 protected boolean processCustomApproveDocumentBusinessRules(MaintenanceDocument document) {
198 boolean valid = processValidation(document);
199 return valid & super.processCustomApproveDocumentBusinessRules(document);
200 }
201
202
203
204
205 @Override
206 protected boolean processCustomRouteDocumentBusinessRules(MaintenanceDocument document) {
207 boolean valid = processValidation(document);
208 return valid & super.processCustomRouteDocumentBusinessRules(document);
209 }
210
211
212
213
214 @Override
215 protected boolean processCustomSaveDocumentBusinessRules(MaintenanceDocument document) {
216 boolean valid = true;
217 return valid & super.processCustomSaveDocumentBusinessRules(document);
218 }
219
220
221
222
223
224
225
226 private boolean processValidation(MaintenanceDocument document) {
227 boolean valid = true;
228
229 valid &= processVendorValidation(document);
230 valid &= processContactValidation(document);
231 if (ObjectUtils.isNotNull(newVendor.getVendorHeader().getVendorType())) {
232 valid &= processAddressValidation(document);
233 valid &= processContractValidation(document);
234 valid &= processCommodityCodeValidation(document);
235 }
236
237 return valid;
238 }
239
240
241
242
243
244
245
246 boolean processVendorValidation(MaintenanceDocument document) {
247 boolean valid = true;
248 VendorDetail vendorDetail = (VendorDetail) document.getNewMaintainableObject().getBusinessObject();
249 valid &= validateTaxTypeAndTaxNumberBlankness(vendorDetail);
250 valid &= validateParentVendorTaxNumber(vendorDetail);
251 valid &= validateOwnershipTypeAllowed(vendorDetail);
252 if(!vendorDetail.isNonBillable()){
253 valid &= validateTaxNumberFromTaxNumberService(vendorDetail);
254 }
255 valid &= validateRestrictedReasonRequiredness(vendorDetail);
256 valid &= validateInactiveReasonRequiredness(vendorDetail);
257 valid &= validatePreInactiveIndicator(vendorDetail);
258
259
260
261
262
263
264 valid &= validateVendorNames(vendorDetail);
265 valid &= validateVendorSoldToNumber(vendorDetail);
266 valid &= validateMinimumOrderAmount(vendorDetail);
267 valid &= validateOwnershipCategory(vendorDetail);
268 valid &= validateVendorWithholdingTaxDates(vendorDetail);
269 valid &= validateVendorW8BenOrW9ReceivedIndicator(vendorDetail);
270 valid &= validateSearchAliases(vendorDetail);
271 valid &= validateContracts(vendorDetail);
272 return valid;
273 }
274
275 private boolean validateContracts(VendorDetail vendorDetail) {
276 boolean success = true;
277 int vendorPos = 0;
278 List<VendorContract> vendorContracts = vendorDetail.getVendorContracts();
279 for (VendorContract vendorContract : vendorContracts) {
280 List<VendorContractOrganization> organizations = vendorContract.getVendorContractOrganizations();
281 List<VendorContractOrganization> organizationCopy = new ArrayList<VendorContractOrganization>(organizations);
282 for (VendorContractOrganization organization :organizations ) {
283 String chartCode = organization.getChartOfAccountsCode();
284 String organizationCode = organization.getOrganizationCode();
285 if (StringUtils.isNotEmpty(chartCode) && StringUtils.isNotEmpty(organizationCode)) {
286 int counter = 0;
287 int organizationPos = 0;
288 for (VendorContractOrganization org : organizationCopy) {
289 if (chartCode.equalsIgnoreCase(org.getChartOfAccountsCode()) && organizationCode.equalsIgnoreCase(org.getOrganizationCode())) {
290 if (counter++ != 0) {
291 organizationCopy.remove(organization);
292 putFieldError(VendorPropertyConstants.VENDOR_CONTRACT + "[" + vendorPos + "]." +
293 VendorPropertyConstants.VENDOR_CONTRACT_ORGANIZATION + "[" + organizationPos + "]." +
294 VendorPropertyConstants.VENDOR_CUSTOMER_NUMBER_CHART_OF_ACCOUNTS_CODE,
295 VendorKeyConstants.ERROR_DUPLICATE_ENTRY_NOT_ALLOWED,chartCode + " " + organizationCode );
296 success = false;
297 break;
298 }
299 }
300 }
301 organizationPos++;
302 }
303 vendorPos++;
304 }
305 }
306 return success;
307 }
308
309
310 private boolean validateSearchAliases(VendorDetail vendorDetail) {
311 boolean success = true;
312 List<VendorAlias> searchAliases = vendorDetail.getVendorAliases();
313 List<VendorAlias> aliasList = new ArrayList<VendorAlias>(searchAliases);
314 int pos = 0;
315 for (VendorAlias searchAlias : searchAliases) {
316 String aliasName = searchAlias.getVendorAliasName();
317 if (aliasName != null) {
318 int counter = 0;
319 for (VendorAlias alias : aliasList) {
320 if (aliasName.equals(alias.getVendorAliasName())) {
321 if (counter++ != 0) {
322 putFieldError(VendorPropertyConstants.VENDOR_SEARCH_ALIASES + "[" + pos + "]." + VendorPropertyConstants.VENDOR_ALIAS_NAME, VendorKeyConstants.ERROR_DUPLICATE_ENTRY_NOT_ALLOWED,aliasName);
323 aliasList.remove(searchAlias);
324 success = false;
325 break;
326 }
327 }
328 }
329 }
330 pos++;
331 }
332 return success;
333 }
334
335
336
337
338
339
340 boolean validatePreInactiveIndicator(VendorDetail vendorDetail) {
341 boolean activeIndicator = vendorDetail.isActiveIndicator();
342 if(!activeIndicator){
343 Map vendorHeaderIdMap = new HashMap();
344 vendorHeaderIdMap.put("VNDR_HDR_GNRTD_ID", vendorDetail.getVendorHeaderGeneratedIdentifier());
345 BusinessObjectService
346 businessObjectService = SpringContext.getBean(BusinessObjectService.class);
347 List<PurchaseOrderDocument> vendorPurchaseOrderDocumentList = (List) businessObjectService.findMatching(PurchaseOrderDocument.class, vendorHeaderIdMap);
348 boolean statusFlag = false;
349 for(int i=0;i<vendorPurchaseOrderDocumentList.size();i++){
350 PurchaseOrderDocument purchaseOrderDocument =vendorPurchaseOrderDocumentList.get(i);
351 String status = purchaseOrderDocument.getApplicationDocumentStatus();
352
353 statusFlag = true;
354
355 }
356
357 if(!statusFlag){
358 if(vendorPurchaseOrderDocumentList.size() > 0){
359
360 putFieldError(VendorPropertyConstants.VENDOR_INACTIVE_REFERENCE, VendorKeyConstants.ERROR_INACTIVE_REFERENCE);
361 return false;
362 }
363 List<PurchaseOrderDocument> vendorPaymentRequestDocumentList = (List) businessObjectService.findMatching(PaymentRequestDocument.class, vendorHeaderIdMap);
364 if(vendorPaymentRequestDocumentList.size() > 0){
365 putFieldError(VendorPropertyConstants.VENDOR_INACTIVE_REFERENCE, VendorKeyConstants.ERROR_INACTIVE_REFERENCE);
366 return false;
367 }
368 }
369 }
370 return true;
371 }
372
373
374
375
376
377
378
379 boolean validateInactiveReasonRequiredness(VendorDetail vendorDetail) {
380 boolean activeIndicator = vendorDetail.isActiveIndicator();
381 boolean emptyInactiveReason = StringUtils.isEmpty(vendorDetail.getVendorInactiveReasonCode());
382
383
384 if (!activeIndicator && emptyInactiveReason) {
385 putFieldError(VendorPropertyConstants.VENDOR_INACTIVE_REASON, VendorKeyConstants.ERROR_INACTIVE_REASON_REQUIRED);
386 return false;
387 }
388
389 if (activeIndicator && !emptyInactiveReason) {
390 putFieldError(VendorPropertyConstants.VENDOR_INACTIVE_REASON, VendorKeyConstants.ERROR_INACTIVE_REASON_NOT_ALLOWED);
391 return false;
392 }
393 return true;
394 }
395
396
397
398
399
400
401
402
403
404 boolean validateTaxNumberRequiredness(VendorDetail vendorDetail) {
405 if (!vendorDetail.getVendorHeader().getVendorForeignIndicator() && vendorDetail.getVendorHeader().getVendorType()!=null && vendorDetail.getVendorHeader().getVendorType().isVendorTaxNumberRequiredIndicator() && StringUtils.isBlank(vendorDetail.getVendorHeader().getVendorTaxNumber())) {
406 if (vendorDetail.isVendorParentIndicator() && vendorDetail.getVendorHeader().getVendorType()!=null) {
407 putFieldError(VendorPropertyConstants.VENDOR_TAX_NUMBER, VendorKeyConstants.ERROR_VENDOR_TYPE_REQUIRES_TAX_NUMBER, vendorDetail.getVendorHeader().getVendorType().getVendorTypeDescription());
408 }
409 else {
410 putFieldError(VendorPropertyConstants.VENDOR_TAX_NUMBER, VendorKeyConstants.ERROR_VENDOR_PARENT_NEEDS_CHANGED);
411 }
412 return false;
413 }
414 return true;
415 }
416
417
418
419
420
421
422
423 boolean validateRestrictedReasonRequiredness(VendorDetail vendorDetail) {
424 if (ObjectUtils.isNotNull(vendorDetail.getVendorRestrictedIndicator()) && vendorDetail.getVendorRestrictedIndicator() && StringUtils.isEmpty(vendorDetail.getVendorRestrictedReasonText())) {
425 putFieldError(VendorPropertyConstants.VENDOR_RESTRICTED_REASON_TEXT, VendorKeyConstants.ERROR_RESTRICTED_REASON_REQUIRED);
426 return false;
427 }
428 return true;
429 }
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444 boolean validateParentVendorTaxNumber(VendorDetail vendorDetail) {
445 boolean valid = true;
446 boolean isParent = vendorDetail.isVendorParentIndicator();
447 Map criteria = new HashMap();
448 criteria.put(VendorPropertyConstants.VENDOR_TAX_TYPE_CODE, vendorDetail.getVendorHeader().getVendorTaxTypeCode());
449 criteria.put(VendorPropertyConstants.VENDOR_TAX_NUMBER, vendorDetail.getVendorHeader().getVendorTaxNumber());
450 criteria.put(OLEPropertyConstants.ACTIVE_INDICATOR, true);
451 Map negativeCriteria = new HashMap();
452 int existingVendor = 0;
453
454
455
456 if (ObjectUtils.isNotNull(vendorDetail.getVendorHeaderGeneratedIdentifier())) {
457 negativeCriteria.put(VendorPropertyConstants.VENDOR_HEADER_GENERATED_ID, vendorDetail.getVendorHeaderGeneratedIdentifier());
458 existingVendor = getBoService().countMatching(VendorDetail.class, criteria, negativeCriteria);
459 }
460 else {
461
462
463
464 existingVendor = getBoService().countMatching(VendorDetail.class, criteria);
465 }
466 if (existingVendor > 0) {
467 if (isParent) {
468 putFieldError(VendorPropertyConstants.VENDOR_TAX_NUMBER, VendorKeyConstants.ERROR_VENDOR_TAX_TYPE_AND_NUMBER_COMBO_EXISTS);
469 }
470 else {
471 putFieldError(VendorPropertyConstants.VENDOR_TAX_NUMBER, VendorKeyConstants.ERROR_VENDOR_PARENT_NEEDS_CHANGED);
472 }
473 valid &= false;
474 }
475 return valid;
476 }
477
478
479
480
481
482
483
484
485
486
487
488 boolean validateTaxTypeAndTaxNumberBlankness(VendorDetail vendorDetail) {
489 boolean valid = true;
490 boolean isParent = vendorDetail.isVendorParentIndicator();
491 if (!StringUtils.isBlank(vendorDetail.getVendorHeader().getVendorTaxNumber()) && (StringUtils.isBlank(vendorDetail.getVendorHeader().getVendorTaxTypeCode()))) {
492 if (isParent) {
493 putFieldError(VendorPropertyConstants.VENDOR_TAX_TYPE_CODE, VendorKeyConstants.ERROR_VENDOR_TAX_TYPE_CANNOT_BE_BLANK);
494 }
495 valid &= false;
496 }
497 else if (StringUtils.isBlank(vendorDetail.getVendorHeader().getVendorTaxNumber()) && !StringUtils.isBlank(vendorDetail.getVendorHeader().getVendorTaxTypeCode())) {
498 if (isParent) {
499 putFieldError(VendorPropertyConstants.VENDOR_TAX_TYPE_CODE, VendorKeyConstants.ERROR_VENDOR_TAX_TYPE_CANNOT_BE_SET);
500 }
501 valid &= false;
502 }
503
504 if (!valid && !isParent) {
505 putFieldError(VendorPropertyConstants.VENDOR_TAX_TYPE_CODE, VendorKeyConstants.ERROR_VENDOR_PARENT_NEEDS_CHANGED);
506 }
507
508 return valid;
509 }
510
511
512
513
514
515
516
517
518
519
520
521 protected boolean validateVendorNames(VendorDetail vendorDetail) {
522 boolean valid = true;
523 if (StringUtils.isBlank(vendorDetail.getVendorName())) {
524
525 if (StringUtils.isBlank(vendorDetail.getVendorFirstName()) && StringUtils.isBlank(vendorDetail.getVendorLastName())) {
526
527 putFieldError(VendorPropertyConstants.VENDOR_NAME, VendorKeyConstants.ERROR_VENDOR_NAME_REQUIRED);
528 valid &= false;
529 }
530
531 else if (StringUtils.isBlank(vendorDetail.getVendorFirstName()) || StringUtils.isBlank(vendorDetail.getVendorLastName())) {
532
533 putFieldError(VendorPropertyConstants.VENDOR_NAME, VendorKeyConstants.ERROR_VENDOR_BOTH_NAME_REQUIRED);
534 valid &= false;
535 }
536 else {
537 String vendorName = vendorDetail.getVendorLastName() + VendorConstants.NAME_DELIM + vendorDetail.getVendorFirstName();
538 if (vendorName.length() > VendorConstants.MAX_VENDOR_NAME_LENGTH) {
539 putFieldError(VendorPropertyConstants.VENDOR_LAST_NAME, VendorKeyConstants.ERROR_VENDOR_NAME_TOO_LONG);
540 valid &= false;
541 }
542
543 }
544 }
545 else {
546
547 if (!StringUtils.isBlank(vendorDetail.getVendorFirstName()) || !StringUtils.isBlank(vendorDetail.getVendorLastName())) {
548
549 putFieldError(VendorPropertyConstants.VENDOR_NAME, VendorKeyConstants.ERROR_VENDOR_NAME_INVALID);
550 valid &= false;
551 }
552 }
553 return valid;
554 }
555
556
557
558
559
560
561
562
563 protected boolean validateVendorSoldToNumber(VendorDetail vendorDetail) {
564 boolean valid = true;
565 String vendorSoldToNumber = vendorDetail.getVendorSoldToNumber();
566
567
568 if (StringUtils.isEmpty(vendorSoldToNumber)) {
569 vendorDetail.setSoldToVendorDetail(null);
570 vendorDetail.setVendorSoldToGeneratedIdentifier(null);
571 vendorDetail.setVendorSoldToAssignedIdentifier(null);
572 vendorDetail.setVendorSoldToNumber(null);
573 vendorDetail.setVendorSoldToName(null);
574 return valid;
575 }
576
577 VendorDetail vendorSoldTo = SpringContext.getBean(VendorService.class).getVendorDetail(vendorSoldToNumber);
578 if (vendorSoldTo != null) {
579
580 vendorDetail.setSoldToVendorDetail(vendorSoldTo);
581 vendorDetail.setVendorSoldToGeneratedIdentifier(vendorSoldTo.getVendorHeaderGeneratedIdentifier());
582 vendorDetail.setVendorSoldToAssignedIdentifier(vendorSoldTo.getVendorDetailAssignedIdentifier());
583 vendorDetail.setVendorSoldToName(vendorSoldTo.getVendorName());
584 }
585 else {
586
587 vendorDetail.setSoldToVendorDetail(null);
588 vendorDetail.setVendorSoldToName(null);
589 valid = false;
590 putFieldError(VendorPropertyConstants.VENDOR_SOLD_TO_NUMBER, VendorKeyConstants.VENDOR_SOLD_TO_NUMBER_INVALID);
591 }
592
593 return valid;
594 }
595
596
597
598
599
600
601
602
603
604
605
606 private boolean validateOwnershipTypeAllowed(VendorDetail vendorDetail) {
607 boolean valid = true;
608 boolean isParent = vendorDetail.isVendorParentIndicator();
609 String ownershipTypeCode = vendorDetail.getVendorHeader().getVendorOwnershipCode();
610 String taxTypeCode = vendorDetail.getVendorHeader().getVendorTaxTypeCode();
611 if (StringUtils.isNotEmpty(ownershipTypeCode) && StringUtils.isNotEmpty(taxTypeCode)) {
612 if (VendorConstants.TAX_TYPE_FEIN.equals(taxTypeCode)) {
613 if (!SpringContext.getBean(ParameterEvaluatorService.class).getParameterEvaluator(VendorDetail.class, VendorParameterConstants.FEIN_ALLOWED_OWNERSHIP_TYPES, ownershipTypeCode).evaluationSucceeds()) {
614 valid &= false;
615 }
616 }
617 else if (VendorConstants.TAX_TYPE_SSN.equals(taxTypeCode)) {
618 if (!SpringContext.getBean(ParameterEvaluatorService.class).getParameterEvaluator(VendorDetail.class, VendorParameterConstants.SSN_ALLOWED_OWNERSHIP_TYPES, ownershipTypeCode).evaluationSucceeds()) {
619 valid &= false;
620 }
621 }
622 }
623 if (!valid && isParent) {
624 putFieldError(VendorPropertyConstants.VENDOR_OWNERSHIP_CODE, VendorKeyConstants.ERROR_OWNERSHIP_TYPE_CODE_NOT_ALLOWED, new String[] { vendorDetail.getVendorHeader().getVendorOwnership().getVendorOwnershipDescription(), taxTypeCode });
625 }
626 else if (!valid && !isParent) {
627 putFieldError(VendorPropertyConstants.VENDOR_OWNERSHIP_CODE, VendorKeyConstants.ERROR_VENDOR_PARENT_NEEDS_CHANGED);
628 }
629 return valid;
630 }
631
632
633
634
635
636
637
638
639 private boolean validateMinimumOrderAmount(VendorDetail vendorDetail) {
640 boolean valid = true;
641 KualiDecimal minimumOrderAmount = vendorDetail.getVendorMinimumOrderAmount();
642 if (ObjectUtils.isNotNull(minimumOrderAmount)) {
643 KualiDecimal VENDOR_MIN_ORDER_AMOUNT = new KualiDecimal(SpringContext.getBean(ParameterService.class).getParameterValueAsString(VendorDetail.class, VendorParameterConstants.VENDOR_MIN_ORDER_AMOUNT));
644 if (ObjectUtils.isNotNull(VENDOR_MIN_ORDER_AMOUNT) && (VENDOR_MIN_ORDER_AMOUNT.compareTo(minimumOrderAmount) < 1) || (minimumOrderAmount.isNegative())) {
645 putFieldError(VendorPropertyConstants.VENDOR_MIN_ORDER_AMOUNT, VendorKeyConstants.ERROR_VENDOR_MAX_MIN_ORDER_AMOUNT, VENDOR_MIN_ORDER_AMOUNT.toString());
646 valid &= false;
647 }
648 }
649 return valid;
650 }
651
652
653
654
655
656
657
658
659
660
661 private boolean validateOwnershipCategory(VendorDetail vendorDetail) {
662 boolean valid = true;
663 boolean isParent = vendorDetail.isVendorParentIndicator();
664 OwnershipType ot = vendorDetail.getVendorHeader().getVendorOwnership();
665 if (ot != null && !ot.getVendorOwnershipCategoryAllowedIndicator()) {
666 if (ObjectUtils.isNotNull(vendorDetail.getVendorHeader().getVendorOwnershipCategory())) {
667 valid &= false;
668 }
669 }
670 if (!valid && isParent) {
671 putFieldError(VendorPropertyConstants.VENDOR_OWNERSHIP_CATEGORY_CODE, VendorKeyConstants.ERROR_OWNERSHIP_CATEGORY_CODE_NOT_ALLOWED, new String[] { vendorDetail.getVendorHeader().getVendorOwnershipCategory().getVendorOwnershipCategoryDescription(), vendorDetail.getVendorHeader().getVendorOwnership().getVendorOwnershipDescription() });
672 }
673 else if (!valid && !isParent) {
674 putFieldError(VendorPropertyConstants.VENDOR_OWNERSHIP_CODE, VendorKeyConstants.ERROR_VENDOR_PARENT_NEEDS_CHANGED);
675 }
676 return valid;
677 }
678
679
680
681
682
683
684
685
686
687
688 private boolean validateTaxNumberFromTaxNumberService(VendorDetail vendorDetail) {
689 boolean valid = true;
690 boolean isParent = vendorDetail.isVendorParentIndicator();
691 String taxNumber = vendorDetail.getVendorHeader().getVendorTaxNumber();
692 String taxType = vendorDetail.getVendorHeader().getVendorTaxTypeCode();
693 if (!StringUtils.isEmpty(taxType) && !StringUtils.isEmpty(taxNumber)) {
694 valid = SpringContext.getBean(TaxNumberService.class).isValidTaxNumber(taxNumber, taxType);
695 if (!valid && isParent) {
696 putFieldError(VendorPropertyConstants.VENDOR_TAX_NUMBER, VendorKeyConstants.ERROR_TAX_NUMBER_INVALID);
697 }
698 valid = SpringContext.getBean(TaxNumberService.class).isAllowedTaxNumber(taxNumber);
699 if (!valid && isParent) {
700 putFieldError(VendorPropertyConstants.VENDOR_TAX_NUMBER, VendorKeyConstants.ERROR_TAX_NUMBER_NOT_ALLOWED);
701 }
702 }
703 if (!valid && !isParent) {
704 putFieldError(VendorPropertyConstants.VENDOR_TAX_NUMBER, VendorKeyConstants.ERROR_VENDOR_PARENT_NEEDS_CHANGED);
705 }
706
707 return valid;
708 }
709
710
711
712
713
714
715
716 boolean processCommodityCodeValidation(MaintenanceDocument document) {
717 boolean valid = true;
718 List<VendorCommodityCode> vendorCommodities = newVendor.getVendorCommodities();
719 boolean commodityCodeRequired = false;
720 if(newVendor.getVendorHeader()!=null && newVendor.getVendorHeader().getVendorType()!=null){
721 commodityCodeRequired = newVendor.getVendorHeader().getVendorType().isCommodityRequiredIndicator();
722 }
723 if (commodityCodeRequired) {
724 if (vendorCommodities.size() == 0) {
725
726 String propertyName = "add." + VendorPropertyConstants.VENDOR_COMMODITIES_CODE_PURCHASING_COMMODITY_CODE;
727 putFieldError(propertyName, VendorKeyConstants.ERROR_VENDOR_COMMODITY_CODE_IS_REQUIRED_FOR_THIS_VENDOR_TYPE);
728 valid = false;
729 }
730
731
732 else if (vendorCommodities.size() > 0) {
733 valid &= validateCommodityCodeDefaultIndicator(vendorCommodities);
734 }
735 }
736 else if (vendorCommodities.size() > 0) {
737
738
739 int defaultCount = 0;
740 for (int i=0; i < vendorCommodities.size(); i++) {
741 VendorCommodityCode vcc = vendorCommodities.get(i);
742 if (vcc.isCommodityDefaultIndicator()) {
743 defaultCount ++;
744 if (defaultCount > 1) {
745 valid = false;
746 String propertyName = VendorPropertyConstants.VENDOR_COMMODITIES_CODE + "[" + i + "]." + VendorPropertyConstants.VENDOR_COMMODITIES_DEFAULT_INDICATOR;
747 putFieldError(propertyName, VendorKeyConstants.ERROR_VENDOR_COMMODITY_CODE_REQUIRE_ONE_DEFAULT_IND);
748 break;
749 }
750 }
751 }
752 }
753
754 return valid;
755 }
756
757
758
759
760
761
762
763
764 private boolean validateCommodityCodeDefaultIndicator(List<VendorCommodityCode> vendorCommodities) {
765 boolean valid = true;
766
767 boolean foundDefaultIndicator = false;
768 for (int i=0; i < vendorCommodities.size(); i++) {
769 VendorCommodityCode vcc = vendorCommodities.get(i);
770 if (vcc.isCommodityDefaultIndicator()) {
771 if (!foundDefaultIndicator) {
772 foundDefaultIndicator = true;
773 }
774 else {
775
776 String propertyName = VendorPropertyConstants.VENDOR_COMMODITIES_CODE + "[" + i + "]." + VendorPropertyConstants.VENDOR_COMMODITIES_DEFAULT_INDICATOR;
777 putFieldError(propertyName, VendorKeyConstants.ERROR_VENDOR_COMMODITY_CODE_REQUIRE_ONE_DEFAULT_IND);
778 valid = false;
779 }
780 }
781 }
782 if (!foundDefaultIndicator && vendorCommodities.size() > 0) {
783
784 String propertyName = VendorPropertyConstants.VENDOR_COMMODITIES_CODE + "[0]." + VendorPropertyConstants.VENDOR_COMMODITIES_DEFAULT_INDICATOR;
785 putFieldError(propertyName, VendorKeyConstants.ERROR_VENDOR_COMMODITY_CODE_REQUIRE_ONE_DEFAULT_IND);
786 valid = false;
787 }
788 return valid;
789 }
790
791
792
793
794
795
796
797 boolean processAddressValidation(MaintenanceDocument document) {
798 boolean valid = true;
799 boolean validAddressType = false;
800
801 List<VendorAddress> addresses = newVendor.getVendorAddresses();
802 String vendorTypeCode = newVendor.getVendorHeader().getVendorTypeCode();
803 String vendorAddressTypeRequiredCode = null;
804 if(newVendor.getVendorHeader()!=null && newVendor.getVendorHeader().getVendorType()!=null){
805 vendorAddressTypeRequiredCode = newVendor.getVendorHeader().getVendorType().getVendorAddressTypeRequiredCode();
806 }
807 if(addresses.size()==0){
808 putFieldError(VendorPropertyConstants.VENDOR_ADDRESS, VendorKeyConstants.OLE_VENDOR_ADDRESS);
809
810 valid = false;
811 validAddressType = false;
812 }
813 if(valid){
814
815 for (int i = 0; i < addresses.size(); i++) {
816 VendorAddress address = addresses.get(i);
817 String errorPath = MAINTAINABLE_ERROR_PREFIX + VendorPropertyConstants.VENDOR_ADDRESS + "[" + i + "]";
818 GlobalVariables.getMessageMap().clearErrorPath();
819 GlobalVariables.getMessageMap().addToErrorPath(errorPath);
820
821 this.getDictionaryValidationService().validateBusinessObject(address);
822 if (GlobalVariables.getMessageMap().hasErrors()) {
823 valid = false;
824 }
825
826 if (vendorAddressTypeRequiredCode!=null && address.getVendorAddressTypeCode()!=null && address.getVendorAddressTypeCode().equals(vendorAddressTypeRequiredCode)) {
827 validAddressType = true;
828 }
829
830
831 valid &= checkFaxNumber(address);
832
833 valid &= checkAddressCountryEmptyStateZip(address);
834
835 GlobalVariables.getMessageMap().clearErrorPath();
836 }
837
838 List<VendorPhoneNumber> phoneNumbers = newVendor.getVendorPhoneNumbers();
839 for(int j=0;j<phoneNumbers.size();j++){
840 VendorPhoneNumber phoneNumber = phoneNumbers.get(j);
841 String errorPath = MAINTAINABLE_ERROR_PREFIX + VendorPropertyConstants.VENDOR_PHONE_NUMBERS + "[" + j + "]";
842 GlobalVariables.getMessageMap().clearErrorPath();
843 GlobalVariables.getMessageMap().addToErrorPath(errorPath);
844 this.getDictionaryValidationService().validateBusinessObject(phoneNumber);
845 valid &= checkPhoneNumber(phoneNumber);
846 }
847
848
849 String vendorAddressTabPrefix = OLEConstants.ADD_PREFIX + "." + VendorPropertyConstants.VENDOR_ADDRESS + ".";
850 if (!StringUtils.isBlank(vendorTypeCode) && !StringUtils.isBlank(vendorAddressTypeRequiredCode) && !validAddressType) {
851 String[] parameters = new String[] { vendorTypeCode, vendorAddressTypeRequiredCode };
852 putFieldError(vendorAddressTabPrefix + VendorPropertyConstants.VENDOR_ADDRESS_TYPE_CODE, VendorKeyConstants.ERROR_ADDRESS_TYPE, parameters);
853 String addressLine1Label = SpringContext.getBean(DataDictionaryService.class).getAttributeLabel(VendorAddress.class, VendorPropertyConstants.VENDOR_ADDRESS_LINE_1);
854 String addressCityLabel = SpringContext.getBean(DataDictionaryService.class).getAttributeLabel(VendorAddress.class, VendorPropertyConstants.VENDOR_ADDRESS_CITY);
855 String addressCountryLabel = SpringContext.getBean(DataDictionaryService.class).getAttributeLabel(VendorAddress.class, VendorPropertyConstants.VENDOR_ADDRESS_COUNTRY);
856 putFieldError(vendorAddressTabPrefix + VendorPropertyConstants.VENDOR_ADDRESS_LINE_1, OLEKeyConstants.ERROR_REQUIRED, addressLine1Label);
857 putFieldError(vendorAddressTabPrefix + VendorPropertyConstants.VENDOR_ADDRESS_CITY, OLEKeyConstants.ERROR_REQUIRED, addressCityLabel);
858 putFieldError(vendorAddressTabPrefix + VendorPropertyConstants.VENDOR_ADDRESS_COUNTRY, OLEKeyConstants.ERROR_REQUIRED, addressCountryLabel);
859 valid = false;
860 }
861
862 valid &= validateDefaultAddressCampus(newVendor);
863
864
865 Map fieldValues = new HashMap();
866 fieldValues.put(VendorPropertyConstants.VENDOR_HEADER_GENERATED_ID, newVendor.getVendorHeaderGeneratedIdentifier());
867
868 List<VendorAddress> vendorDivisionAddresses = new ArrayList(SpringContext.getBean(BusinessObjectService.class).findMatchingOrderBy(VendorAddress.class, fieldValues, VendorPropertyConstants.VENDOR_DETAIL_ASSIGNED_ID, true));
869
870
871
872 HashSet<Integer> vendorDetailedIds = new HashSet();
873
874 HashSet<Integer> vendorDivisionsIdsWithDesiredAddressType = new HashSet();
875
876 for (VendorAddress vendorDivisionAddress : vendorDivisionAddresses) {
877
878 if (vendorDivisionAddress.getVendorDetailAssignedIdentifier() != 0) {
879 vendorDetailedIds.add(vendorDivisionAddress.getVendorDetailAssignedIdentifier());
880 if (vendorDivisionAddress.getVendorAddressTypeCode().equalsIgnoreCase(vendorAddressTypeRequiredCode)) {
881 vendorDivisionsIdsWithDesiredAddressType.add(vendorDivisionAddress.getVendorDetailAssignedIdentifier());
882 }
883 }
884 }
885
886
887 if (vendorDivisionsIdsWithDesiredAddressType.size() < vendorDetailedIds.size()) {
888 Iterator itr = vendorDetailedIds.iterator();
889 Integer value;
890 String vendorId;
891
892 while (itr.hasNext()) {
893 value = (Integer) itr.next();
894 if (!vendorDivisionsIdsWithDesiredAddressType.contains(value)) {
895 vendorId = newVendor.getVendorHeaderGeneratedIdentifier().toString() + '-' + value.toString();
896 String[] parameters = new String[] { vendorId, vendorTypeCode, vendorAddressTypeRequiredCode };
897
898
899 GlobalVariables.getMessageMap().putWarningWithoutFullErrorPath(MAINTAINABLE_ERROR_PREFIX + vendorAddressTabPrefix + VendorPropertyConstants.VENDOR_ADDRESS_TYPE_CODE, VendorKeyConstants.ERROR_ADDRESS_TYPE_DIVISIONS, parameters);
900 }
901 }
902 }
903
904 }
905 return valid;
906 }
907
908
909
910
911
912
913
914
915 boolean checkAddressCountryEmptyStateZip(VendorAddress address) {
916
917
918 boolean valid = SpringContext.getBean(PostalCodeValidationService.class).validateAddress(address.getVendorCountryCode(), address.getVendorStateCode(), address.getVendorZipCode(), VendorPropertyConstants.VENDOR_ADDRESS_STATE, VendorPropertyConstants.VENDOR_ADDRESS_ZIP);
919
920 return valid;
921 }
922
923
924
925
926
927
928
929
930 boolean findAllowDefaultAddressIndicatorHelper(VendorAddress vendorAddress) {
931
932 AddressType addressType = new AddressType();
933
934 addressType = vendorAddress.getVendorAddressType();
935 if (ObjectUtils.isNull(addressType)) {
936 return false;
937 }
938
939 return addressType.getVendorDefaultIndicator();
940
941 }
942
943
944
945
946
947
948
949
950
951
952
953 boolean checkDefaultAddressCampus(VendorDetail vendorDetail, VendorDefaultAddress addedDefaultAddress, VendorAddress parent) {
954 VendorAddress vendorAddress = parent;
955 if (ObjectUtils.isNull(vendorAddress)) {
956 return false;
957 }
958
959 int j = vendorDetail.getVendorAddresses().indexOf(vendorAddress);
960 String errorPath = MAINTAINABLE_ERROR_PREFIX + VendorPropertyConstants.VENDOR_ADDRESS + "[" + j + "]";
961 GlobalVariables.getMessageMap().addToErrorPath(errorPath);
962
963
964 boolean allowDefaultAddressIndicator = findAllowDefaultAddressIndicatorHelper(vendorAddress);
965 String addedAddressCampusCode = addedDefaultAddress.getVendorCampusCode();
966 String addedAddressTypeCode = vendorAddress.getVendorAddressTypeCode();
967
968
969
970 if (allowDefaultAddressIndicator == false) {
971 String[] parameters = new String[] { addedAddressTypeCode };
972 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_DEFAULT_ADDRESS + "[" + 0 + "]." + VendorPropertyConstants.VENDOR_DEFAULT_ADDRESS_CAMPUS, VendorKeyConstants.ERROR_ADDRESS_DEFAULT_CAMPUS_NOT_ALLOWED, parameters);
973 return false;
974 }
975
976 List<VendorDefaultAddress> vendorDefaultAddresses = vendorAddress.getVendorDefaultAddresses();
977 for (int i = 0; i < vendorDefaultAddresses.size(); i++) {
978 VendorDefaultAddress vendorDefaultAddress = vendorDefaultAddresses.get(i);
979 if (vendorDefaultAddress.getVendorCampusCode().equalsIgnoreCase(addedAddressCampusCode)) {
980 String[] parameters = new String[] { addedAddressCampusCode, addedAddressTypeCode };
981 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_DEFAULT_ADDRESS + "[" + i + "]." + VendorPropertyConstants.VENDOR_DEFAULT_ADDRESS_CAMPUS, VendorKeyConstants.ERROR_ADDRESS_DEFAULT_CAMPUS, parameters);
982 return false;
983 }
984 }
985
986 return true;
987 }
988
989
990
991
992
993
994
995
996
997
998 boolean validateDefaultAddressCampus(VendorDetail vendorDetail) {
999 List<VendorAddress> vendorAddresses = vendorDetail.getVendorAddresses();
1000 String addressTypeCode;
1001 String addressTypeDesc;
1002 String campusCode;
1003 boolean valid = true;
1004 boolean previousValue = false;
1005
1006
1007 HashMap addressTypeCodeDefaultIndicator = new HashMap();
1008
1009
1010 HashMap addressTypeDefaultCampus = new HashMap();
1011
1012
1013 HashSet addressTypesHavingDefaultTrue = new HashSet();
1014
1015 int i = 0;
1016 for (VendorAddress address : vendorAddresses) {
1017 addressTypeCode = address.getVendorAddressTypeCode();
1018 addressTypeDesc = address.getVendorAddressType().getVendorAddressTypeDescription();
1019 String errorPath = MAINTAINABLE_ERROR_PREFIX + VendorPropertyConstants.VENDOR_ADDRESS + "[" + i + "]";
1020 GlobalVariables.getMessageMap().addToErrorPath(errorPath);
1021 String[] parameters = new String[] { addressTypeCode };
1022
1023
1024
1025
1026
1027
1028
1029 if (findAllowDefaultAddressIndicatorHelper(address)) {
1030 if (address.isVendorDefaultAddressIndicator()) {
1031 addressTypesHavingDefaultTrue.add(addressTypeCode);
1032 }
1033 if (!addressTypeCodeDefaultIndicator.isEmpty() && addressTypeCodeDefaultIndicator.containsKey(addressTypeCode)) {
1034 previousValue = ((Boolean) addressTypeCodeDefaultIndicator.get(addressTypeCode)).booleanValue();
1035 }
1036
1037 if (addressTypeCodeDefaultIndicator.put(addressTypeCode, address.isVendorDefaultAddressIndicator()) != null && previousValue && address.isVendorDefaultAddressIndicator()) {
1038 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_DEFAULT_ADDRESS_INDICATOR, VendorKeyConstants.ERROR_ADDRESS_DEFAULT_INDICATOR,addressTypeDesc );
1039 valid = false;
1040 }
1041
1042 }
1043
1044 else {
1045 if (address.isVendorDefaultAddressIndicator()) {
1046 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_DEFAULT_ADDRESS_INDICATOR, VendorKeyConstants.ERROR_ADDRESS_DEFAULT_ADDRESS_NOT_ALLOWED, parameters);
1047 valid = false;
1048 }
1049
1050 }
1051
1052 List<VendorDefaultAddress> vendorDefaultAddresses = address.getVendorDefaultAddresses();
1053
1054
1055
1056
1057
1058 int j = 0;
1059 for (VendorDefaultAddress defaultAddress : vendorDefaultAddresses) {
1060 campusCode = (String) addressTypeDefaultCampus.put(addressTypeCode, defaultAddress.getVendorCampusCode());
1061 if (StringUtils.isNotBlank(campusCode) && campusCode.equalsIgnoreCase(defaultAddress.getVendorCampusCode())) {
1062 String[] newParameters = new String[] { defaultAddress.getVendorCampusCode(), addressTypeCode };
1063 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_DEFAULT_ADDRESS + "[" + j + "]." + VendorPropertyConstants.VENDOR_DEFAULT_ADDRESS_CAMPUS, VendorKeyConstants.ERROR_ADDRESS_DEFAULT_CAMPUS, newParameters);
1064 valid = false;
1065 }
1066 j++;
1067 }
1068 i++;
1069 GlobalVariables.getMessageMap().removeFromErrorPath(errorPath);
1070 }
1071
1072
1073 if (!addressTypeCodeDefaultIndicator.isEmpty()) {
1074 Set<String> addressTypes = addressTypeCodeDefaultIndicator.keySet();
1075
1076 for (String addressType : addressTypes) {
1077 if (!addressTypesHavingDefaultTrue.contains(addressType)) {
1078
1079 int addressIndex = 0;
1080 for (VendorAddress address : vendorAddresses) {
1081 String[] parameters = new String[] { address.getVendorAddressType().getVendorAddressTypeDescription() };
1082 String propertyName = VendorPropertyConstants.VENDOR_ADDRESS + "[" + addressIndex + "]." + VendorPropertyConstants.VENDOR_DEFAULT_ADDRESS_INDICATOR;
1083 if (address.getVendorAddressType().getVendorAddressTypeCode().equalsIgnoreCase(addressType)) {
1084 putFieldError(propertyName, VendorKeyConstants.ERROR_ADDRESS_DEFAULT_INDICATOR, parameters);
1085 break;
1086 }
1087 addressIndex++;
1088 }
1089 valid = false;
1090 }
1091
1092 }
1093 }
1094
1095 return valid;
1096 }
1097
1098
1099
1100
1101
1102
1103
1104
1105 boolean checkFaxNumber(VendorAddress address) {
1106 boolean valid = true;
1107 String faxNumber = address.getVendorFaxNumber();
1108 boolean foriegnVendor=false;
1109 if (newVendor.getVendorHeader() != null) {
1110 if (newVendor.getVendorHeader().getVendorForeignIndicator() != null) {
1111 foriegnVendor = newVendor.getVendorHeader().getVendorForeignIndicator();
1112 }
1113 }
1114
1115 if(foriegnVendor) {
1116
1117 if(StringUtils.isNotEmpty(faxNumber) && !SpringContext.getBean(OleForiegnVendorPhoneNumberService.class).isValidForiegnVendorPhoneNumber(faxNumber)){
1118 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_FAX_NUMBER, VendorKeyConstants.ERROR_FORIEGN_VENDOR_FAX_NUMBER);
1119 valid &= false;
1120 }
1121 }
1122 else {
1123 if (StringUtils.isNotEmpty(faxNumber) && !SpringContext.getBean(PhoneNumberService.class).isValidPhoneNumber(faxNumber)) {
1124 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_FAX_NUMBER, VendorKeyConstants.ERROR_FAX_NUMBER);
1125 valid &= false;
1126 }
1127 }
1128 return valid;
1129 }
1130
1131 boolean checkPhoneNumber(VendorPhoneNumber vendorPhoneNumber){
1132 boolean valid = true;
1133 String phoneNumber = vendorPhoneNumber.getVendorPhoneNumber();
1134 boolean foriegnVendor=false;
1135 if (newVendor.getVendorHeader() != null) {
1136 if (newVendor.getVendorHeader().getVendorForeignIndicator() != null) {
1137 foriegnVendor = newVendor.getVendorHeader().getVendorForeignIndicator();
1138 }
1139 }
1140 if(foriegnVendor) {
1141
1142 if(StringUtils.isNotEmpty(phoneNumber) && !SpringContext.getBean(OleForiegnVendorPhoneNumberService.class).isValidForiegnVendorPhoneNumber(phoneNumber)){
1143 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_PHONE_NUMBER, VendorKeyConstants.ERROR_FORIEGN_VENDOR_PHONE_NUMBER);
1144 valid &= false;
1145 }
1146 }
1147 else {
1148 if (StringUtils.isNotEmpty(phoneNumber) && !SpringContext.getBean(PhoneNumberService.class).isValidPhoneNumber(phoneNumber)) {
1149 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_PHONE_NUMBER, VendorKeyConstants.ERROR_PHONE_NUMBER);
1150 valid &= false;
1151 }
1152 }
1153 return valid;
1154 }
1155
1156
1157
1158
1159
1160
1161
1162 private boolean processContactValidation(MaintenanceDocument document) {
1163 boolean valid = true;
1164 int i = 0;
1165 for (VendorContact contact : newVendor.getVendorContacts()) {
1166 String errorPath = MAINTAINABLE_ERROR_PREFIX + VendorPropertyConstants.VENDOR_CONTACT + "[" + i + "]";
1167 GlobalVariables.getMessageMap().addToErrorPath(errorPath);
1168
1169 this.getDictionaryValidationService().validateBusinessObject(contact);
1170 Map<String, AutoPopulatingList<ErrorMessage>> errors = GlobalVariables.getMessageMap().getErrorMessages();
1171 if ((errors != null ) && (!errors.isEmpty())) {
1172 valid = false;
1173 }
1174 i++;
1175 GlobalVariables.getMessageMap().clearErrorPath();
1176 }
1177 return valid;
1178 }
1179
1180
1181
1182
1183
1184
1185
1186 private boolean processCustomerNumberValidation(MaintenanceDocument document) {
1187 boolean valid = true;
1188
1189 List<VendorCustomerNumber> customerNumbers = newVendor.getVendorCustomerNumbers();
1190 for (VendorCustomerNumber customerNumber : customerNumbers) {
1191 valid &= validateVendorCustomerNumber(customerNumber);
1192 }
1193 return valid;
1194 }
1195
1196
1197
1198
1199
1200
1201
1202 boolean validateVendorCustomerNumber(VendorCustomerNumber customerNumber) {
1203 boolean valid = true;
1204
1205
1206 String chartOfAccountsCode = customerNumber.getChartOfAccountsCode();
1207 String orgCode = customerNumber.getVendorOrganizationCode();
1208 String carrierCode = customerNumber.getVendorStandardDeliveryCarrier();
1209 if (!StringUtils.isBlank(chartOfAccountsCode) && !StringUtils.isBlank(orgCode)) {
1210 Map chartOrgMap = new HashMap();
1211 chartOrgMap.put("chartOfAccountsCode", chartOfAccountsCode);
1212 if (SpringContext.getBean(BusinessObjectService.class).countMatching(Chart.class, chartOrgMap) < 1) {
1213 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CUSTOMER_NUMBER_CHART_OF_ACCOUNTS_CODE, OLEKeyConstants.ERROR_EXISTENCE, chartOfAccountsCode);
1214 valid &= false;
1215 }
1216 chartOrgMap.put("organizationCode", orgCode);
1217 if (SpringContext.getBean(BusinessObjectService.class).countMatching(Organization.class, chartOrgMap) < 1) {
1218 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CUSTOMER_NUMBER_ORGANIZATION_CODE, OLEKeyConstants.ERROR_EXISTENCE, orgCode);
1219 valid &= false;
1220 }
1221
1222 }
1223 if (!StringUtils.isBlank(carrierCode)) {
1224 Map carrierMap = new HashMap();
1225 carrierMap.put("carrierCode", carrierCode);
1226 if (SpringContext.getBean(BusinessObjectService.class).countMatching(Carrier.class, carrierMap) < 1) {
1227 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CARRIER_CODE, OLEKeyConstants.ERROR_EXISTENCE, carrierCode);
1228 valid &= false;
1229 }
1230 }
1231
1232 return valid;
1233 }
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261 private boolean processContractValidation(MaintenanceDocument document) {
1262 boolean valid = true;
1263 List<VendorContract> contracts = newVendor.getVendorContracts();
1264 if (ObjectUtils.isNull(contracts)) {
1265 return valid;
1266 }
1267
1268
1269 if (contracts.size() > 0 && newVendor.getVendorHeader()!=null && newVendor.getVendorHeader().getVendorType()!=null && !newVendor.getVendorHeader().getVendorType().isVendorContractAllowedIndicator()) {
1270 valid = false;
1271 String errorPath = MAINTAINABLE_ERROR_PREFIX + VendorPropertyConstants.VENDOR_CONTRACT + "[0]";
1272 GlobalVariables.getMessageMap().addToErrorPath(errorPath);
1273 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_NAME, VendorKeyConstants.ERROR_VENDOR_CONTRACT_NOT_ALLOWED);
1274 GlobalVariables.getMessageMap().removeFromErrorPath(errorPath);
1275 return valid;
1276 }
1277
1278 for (int i = 0; i < contracts.size(); i++) {
1279 VendorContract contract = contracts.get(i);
1280
1281 String errorPath = MAINTAINABLE_ERROR_PREFIX + VendorPropertyConstants.VENDOR_CONTRACT + "[" + i + "]";
1282 GlobalVariables.getMessageMap().addToErrorPath(errorPath);
1283
1284 valid &= validateVendorContractPOLimitAndExcludeFlagCombination(contract);
1285 valid &= validateVendorContractBeginEndDates(contract);
1286 valid &= processContractB2BValidation(document, contract, i);
1287
1288 GlobalVariables.getMessageMap().removeFromErrorPath(errorPath);
1289 }
1290
1291
1292 return valid;
1293 }
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305 boolean validateVendorContractPOLimitAndExcludeFlagCombination(VendorContract contract) {
1306 boolean valid = true;
1307 boolean NoOrgHasApoLimit = true;
1308
1309 List<VendorContractOrganization> organizations = contract.getVendorContractOrganizations();
1310 if (ObjectUtils.isNotNull(organizations)) {
1311 int organizationCounter = 0;
1312 for (VendorContractOrganization organization : organizations) {
1313 if (ObjectUtils.isNotNull(organization.getVendorContractPurchaseOrderLimitAmount())) {
1314 NoOrgHasApoLimit = false;
1315 }
1316 valid &= validateVendorContractOrganization(organization);
1317 organizationCounter++;
1318 }
1319 }
1320 if (NoOrgHasApoLimit && ObjectUtils.isNull(contract.getOrganizationAutomaticPurchaseOrderLimit())) {
1321
1322 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_DEFAULT_APO_LIMIT, VendorKeyConstants.ERROR_VENDOR_CONTRACT_NO_APO_LIMIT);
1323 valid &= false;
1324 }
1325 return valid;
1326 }
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337 boolean validateVendorContractBeginEndDates(VendorContract contract) {
1338 boolean valid = true;
1339
1340 if (ObjectUtils.isNotNull(contract.getVendorContractBeginningDate()) && ObjectUtils.isNull(contract.getVendorContractEndDate())) {
1341 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_END_DATE, VendorKeyConstants.ERROR_VENDOR_CONTRACT_BEGIN_DATE_NO_END_DATE);
1342 valid &= false;
1343 }
1344 else {
1345 if (ObjectUtils.isNull(contract.getVendorContractBeginningDate()) && ObjectUtils.isNotNull(contract.getVendorContractEndDate())) {
1346 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_BEGIN_DATE, VendorKeyConstants.ERROR_VENDOR_CONTRACT_END_DATE_NO_BEGIN_DATE);
1347 valid &= false;
1348 }
1349 }
1350 if (valid && ObjectUtils.isNotNull(contract.getVendorContractBeginningDate()) && ObjectUtils.isNotNull(contract.getVendorContractEndDate())) {
1351 if (contract.getVendorContractBeginningDate().after(contract.getVendorContractEndDate())) {
1352 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_BEGIN_DATE, VendorKeyConstants.ERROR_VENDOR_CONTRACT_BEGIN_DATE_AFTER_END);
1353 valid &= false;
1354 }
1355 }
1356
1357 return valid;
1358 }
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368 boolean validateVendorContractOrganization(VendorContractOrganization organization) {
1369 boolean valid = true;
1370
1371 boolean isExcluded = organization.isVendorContractExcludeIndicator();
1372 if (isExcluded) {
1373 if (ObjectUtils.isNotNull(organization.getVendorContractPurchaseOrderLimitAmount())) {
1374
1375 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_ORGANIZATION_APO_LIMIT, VendorKeyConstants.ERROR_VENDOR_CONTRACT_ORG_EXCLUDED_WITH_APO_LIMIT);
1376 valid &= false;
1377 }
1378 }
1379 else {
1380 if (ObjectUtils.isNull(organization.getVendorContractPurchaseOrderLimitAmount())) {
1381
1382 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_ORGANIZATION_APO_LIMIT, VendorKeyConstants.ERROR_VENDOR_CONTRACT_ORG_NOT_EXCLUDED_NO_APO_LIMIT);
1383 valid &= false;
1384 }
1385 }
1386
1387
1388 String chartOfAccountsCode = organization.getChartOfAccountsCode();
1389 String orgCode = organization.getOrganizationCode();
1390 if (!StringUtils.isBlank(chartOfAccountsCode) && !StringUtils.isBlank(orgCode)) {
1391 Map chartOrgMap = new HashMap();
1392 chartOrgMap.put("chartOfAccountsCode", chartOfAccountsCode);
1393 if (SpringContext.getBean(BusinessObjectService.class).countMatching(Chart.class, chartOrgMap) < 1) {
1394 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_CHART_OF_ACCOUNTS_CODE, OLEKeyConstants.ERROR_EXISTENCE, chartOfAccountsCode);
1395 valid &= false;
1396 }
1397 chartOrgMap.put("organizationCode", orgCode);
1398 if (SpringContext.getBean(BusinessObjectService.class).countMatching(Organization.class, chartOrgMap) < 1) {
1399 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_ORGANIZATION_CODE, OLEKeyConstants.ERROR_EXISTENCE, orgCode);
1400 valid &= false;
1401 }
1402 }
1403
1404 return valid;
1405 }
1406
1407
1408
1409
1410
1411
1412
1413 private boolean processContractB2BValidation(MaintenanceDocument document, VendorContract contract, int contractPos) {
1414 boolean valid = true;
1415 List<Integer> indexOfB2BContracts = new ArrayList();
1416
1417 List<VendorContract> contracts = newVendor.getVendorContracts();
1418 if (ObjectUtils.isNull(contracts)) {
1419 return valid;
1420 }
1421
1422 if(contractPos == -1){
1423 if(contract.getVendorB2bIndicator()){
1424 for (int i = 0; i < contracts.size(); i++) {
1425 VendorContract vndrContract = contracts.get(i);
1426 if(vndrContract.getVendorB2bIndicator()){
1427
1428 if(contract.getVendorCampusCode().equals(vndrContract.getVendorCampusCode())){
1429 valid &= false;
1430 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_B2B_INDICATOR, VendorKeyConstants.ERROR_VENDOR_CONTRACT_B2B_LIMIT_EXCEEDED, contract.getVendorCampusCode());
1431 }
1432 }
1433 }
1434 }
1435 } else
1436 {
1437 if(contract.getVendorB2bIndicator()){
1438 for (int i = 0; i < contracts.size(); i++) {
1439 VendorContract vndrContract = contracts.get(i);
1440 if(vndrContract.getVendorB2bIndicator()){
1441
1442 if(i != contractPos){
1443
1444 if(contract.getVendorCampusCode().equals(vndrContract.getVendorCampusCode())){
1445 valid &= false;
1446 String [] errorArray = new String []{contract.getVendorContractName(), contract.getVendorCampusCode()};
1447 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_CONTRACT_B2B_INDICATOR, VendorKeyConstants.ERROR_VENDOR_CONTRACT_B2B_LIMIT_EXCEEDED_DB, errorArray);
1448 }
1449 }
1450 }
1451 }
1452 }
1453 }
1454 return valid;
1455 }
1456
1457
1458
1459
1460
1461
1462
1463
1464 @Override
1465 public boolean processCustomAddCollectionLineBusinessRules(MaintenanceDocument document, String collectionName, PersistableBusinessObject bo) {
1466 boolean success = true;
1467
1468
1469 bo.refreshNonUpdateableReferences();
1470
1471 if (bo instanceof VendorAddress) {
1472 VendorAddress address = (VendorAddress) bo;
1473 success &= checkAddressCountryEmptyStateZip(address);
1474 VendorDetail vendorDetail = (VendorDetail) document.getNewMaintainableObject().getBusinessObject();
1475 }
1476 if (bo instanceof VendorContract) {
1477 VendorContract contract = (VendorContract) bo;
1478 success &= validateVendorContractBeginEndDates(contract);
1479 success &= processContractB2BValidation(document,contract, -1);
1480 }
1481 if (bo instanceof VendorContractOrganization) {
1482 VendorContractOrganization contractOrg = (VendorContractOrganization) bo;
1483 success &= validateVendorContractOrganization(contractOrg);
1484 }
1485 if (bo instanceof VendorCustomerNumber) {
1486 VendorCustomerNumber customerNumber = (VendorCustomerNumber) bo;
1487 success &= validateVendorCustomerNumber(customerNumber);
1488 }
1489
1490
1491
1492
1493
1494 if (bo instanceof VendorTransmissionFormatDetail) {
1495 VendorDetail newVendorDetail = (VendorDetail) document.getNewMaintainableObject().getBusinessObject();
1496 newVendorDetail.refreshNonUpdateableReferences();
1497 VendorTransmissionFormatDetail vendorTransmissionFormatDetail = (VendorTransmissionFormatDetail) bo;
1498 success &= validateVendorTransmissionFormatDetail(vendorTransmissionFormatDetail,newVendorDetail);
1499 }
1500
1501 if (bo instanceof VendorDefaultAddress) {
1502 VendorDefaultAddress defaultAddress = (VendorDefaultAddress) bo;
1503 String parentName = StringUtils.substringBeforeLast(collectionName, ".");
1504 VendorAddress parent = (VendorAddress) ObjectUtils.getPropertyValue(this.getNewBo(), parentName);
1505 VendorDetail vendorDetail = (VendorDetail) document.getNewMaintainableObject().getBusinessObject();
1506 success &= checkDefaultAddressCampus(vendorDetail, defaultAddress, parent);
1507 }
1508
1509 return success;
1510 }
1511
1512
1513 boolean validateVendorTransmissionFormatDetail(VendorTransmissionFormatDetail vendorTransmissionFormatDetail,VendorDetail vendorDetail){
1514 boolean valid = true;
1515 boolean preferredTransmissionFlag = false;
1516 int oldPreferredTransmissionFlagCount = 0;
1517 boolean newVendorPreferredTransmissionFormat = vendorTransmissionFormatDetail.isVendorPreferredTransmissionFormat();
1518 for (VendorTransmissionFormatDetail oldVendorTransmissionFormatDetail : vendorDetail.getVendorTransmissionFormat()) {
1519 oldVendorTransmissionFormatDetail.refreshNonUpdateableReferences();
1520 if(oldVendorTransmissionFormatDetail.isVendorPreferredTransmissionFormat()){
1521 preferredTransmissionFlag = true;
1522 oldPreferredTransmissionFlagCount = oldPreferredTransmissionFlagCount + 1;
1523 }
1524 }
1525 if(oldPreferredTransmissionFlagCount > 1){
1526 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_PREFERRED_TRANSMISSION, OLEKeyConstants.ERROR_DUPLICATE_PREFERRED_FORMAT, "preferred transmission format");
1527 valid &= false;
1528 }
1529 if(newVendorPreferredTransmissionFormat && preferredTransmissionFlag){
1530 GlobalVariables.getMessageMap().putError(VendorPropertyConstants.VENDOR_PREFERRED_TRANSMISSION, OLEKeyConstants.ERROR_DUPLICATE_PREFERRED_FORMAT, "preferred transmission format");
1531 valid &= false;
1532 }
1533
1534 return valid;
1535 }
1536
1537
1538
1539
1540
1541
1542
1543
1544 private boolean validateVendorWithholdingTaxDates(VendorDetail vdDocument) {
1545 boolean valid = true;
1546 DateTimeService dateTimeService = SpringContext.getBean(DateTimeService.class);
1547
1548 Date beginDate = vdDocument.getVendorHeader().getVendorFederalWithholdingTaxBeginningDate();
1549 Date endDate = vdDocument.getVendorHeader().getVendorFederalWithholdingTaxEndDate();
1550 if (ObjectUtils.isNotNull(beginDate) && ObjectUtils.isNotNull(endDate)) {
1551 if (dateTimeService.dateDiff(beginDate, endDate, false) <= 0) {
1552 putFieldError(VendorPropertyConstants.VENDOR_FEDERAL_WITHOLDING_TAX_BEGINNING_DATE, VendorKeyConstants.ERROR_VENDOR_TAX_BEGIN_DATE_AFTER_END);
1553 valid &= false;
1554 }
1555 }
1556 return valid;
1557
1558 }
1559
1560
1561
1562
1563
1564
1565
1566 private boolean validateVendorW8BenOrW9ReceivedIndicator(VendorDetail vdDocument) {
1567 boolean valid = true;
1568
1569 if (ObjectUtils.isNotNull(vdDocument.getVendorHeader().getVendorW9ReceivedIndicator()) && ObjectUtils.isNotNull(vdDocument.getVendorHeader().getVendorW8BenReceivedIndicator()) && vdDocument.getVendorHeader().getVendorW9ReceivedIndicator() && vdDocument.getVendorHeader().getVendorW8BenReceivedIndicator()) {
1570 putFieldError(VendorPropertyConstants.VENDOR_W9_RECEIVED_INDICATOR, VendorKeyConstants.ERROR_VENDOR_W9_AND_W8_RECEIVED_INDICATOR_BOTH_TRUE);
1571 valid &= false;
1572 }
1573 return valid;
1574
1575 }
1576
1577
1578
1579
1580
1581
1582
1583
1584 @Override
1585 public boolean processAddCollectionLineBusinessRules(MaintenanceDocument document, String collectionName, PersistableBusinessObject bo) {
1586 if (collectionName.equals(VendorPropertyConstants.VENDOR_CONTRACT)) {
1587 VendorDetail vendorDetail = (VendorDetail)document.getDocumentBusinessObject();
1588 vendorDetail.getVendorHeader().refreshReferenceObject("vendorType");
1589 VendorType vendorType = vendorDetail.getVendorHeader().getVendorType();
1590 if (vendorType!=null && !vendorType.isVendorContractAllowedIndicator()) {
1591 String propertyName = "add." + collectionName + "." + VendorPropertyConstants.VENDOR_CONTRACT_NAME;
1592 putFieldError(propertyName, VendorKeyConstants.ERROR_VENDOR_CONTRACT_NOT_ALLOWED);
1593 return false;
1594 }
1595 }
1596 return super.processAddCollectionLineBusinessRules(document, collectionName, bo);
1597 }
1598 }