1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.student.enrollment.class1.lpr.service.impl;
17
18 import java.util.ArrayList;
19 import java.util.Date;
20 import java.util.HashSet;
21 import java.util.Iterator;
22 import java.util.LinkedHashMap;
23 import java.util.List;
24 import java.util.Map;
25 import java.util.Set;
26
27 import javax.jws.WebParam;
28
29 import org.kuali.rice.core.api.criteria.QueryByCriteria;
30 import org.kuali.student.common.mock.MockService;
31 import org.kuali.student.common.util.UUIDHelper;
32 import org.kuali.student.enrollment.lpr.dto.LprInfo;
33 import org.kuali.student.enrollment.lpr.dto.LprTransactionInfo;
34 import org.kuali.student.enrollment.lpr.dto.LprTransactionItemInfo;
35 import org.kuali.student.enrollment.lpr.service.LprService;
36 import org.kuali.student.enrollment.lui.dto.LuiInfo;
37 import org.kuali.student.enrollment.lui.service.LuiService;
38 import org.kuali.student.r2.common.dto.BulkStatusInfo;
39 import org.kuali.student.r2.common.dto.ContextInfo;
40 import org.kuali.student.r2.common.dto.MetaInfo;
41 import org.kuali.student.r2.common.dto.StatusInfo;
42 import org.kuali.student.r2.common.dto.ValidationResultInfo;
43 import org.kuali.student.r2.common.exceptions.AlreadyExistsException;
44 import org.kuali.student.r2.common.exceptions.DataValidationErrorException;
45 import org.kuali.student.r2.common.exceptions.DoesNotExistException;
46 import org.kuali.student.r2.common.exceptions.InvalidParameterException;
47 import org.kuali.student.r2.common.exceptions.MissingParameterException;
48 import org.kuali.student.r2.common.exceptions.OperationFailedException;
49 import org.kuali.student.r2.common.exceptions.PermissionDeniedException;
50 import org.kuali.student.r2.common.exceptions.ReadOnlyException;
51 import org.kuali.student.r2.common.exceptions.VersionMismatchException;
52 import org.kuali.student.r2.common.util.constants.LprServiceConstants;
53 import org.kuali.student.r2.core.class1.util.ValidationUtils;
54
55 public class LprServiceMockImpl implements LprService, MockService {
56
57 private LuiService luiService;
58
59 public LuiService getLuiService() {
60 return luiService;
61 }
62
63 public void setLuiService(LuiService luiService) {
64 this.luiService = luiService;
65 }
66
67
68 @Override
69 public void clear() {
70 this.lprMap.clear();
71 this.lprTransactionMap.clear();
72
73 }
74
75 @Override
76 public LprInfo getLpr(String lprId, ContextInfo contextInfo)
77 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
78 PermissionDeniedException {
79 if (!this.lprMap.containsKey(lprId)) {
80 throw new DoesNotExistException(lprId);
81 }
82 return this.lprMap.get(lprId);
83 }
84
85
86 @Override
87 public List<LprInfo> getLprsByLuis(
88 List<String> luiIds,
89 ContextInfo contextInfo)
90 throws DoesNotExistException, InvalidParameterException,
91 MissingParameterException, OperationFailedException,
92 PermissionDeniedException {
93 List<LprInfo> lprs = new ArrayList<LprInfo>();
94
95 Set<LprInfo> allLprs = new HashSet<LprInfo>(this.lprMap.values());
96
97 for (String luiId : luiIds) {
98
99 Iterator<LprInfo> it = allLprs.iterator();
100 while (it.hasNext()) {
101 LprInfo lprInfo = it.next();
102
103 if (lprInfo.getLuiId().equals(luiId)) {
104 lprs.add(lprInfo);
105 it.remove();
106 }
107 }
108
109 }
110
111 return lprs;
112 }
113
114 @Override
115 public List<LprInfo> getLprsByIds(List<String> lprIds, ContextInfo contextInfo)
116 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
117 PermissionDeniedException {
118 List<LprInfo> list = new ArrayList<LprInfo>();
119 for (String id : lprIds) {
120 list.add(this.getLpr(id, contextInfo));
121 }
122 return list;
123 }
124
125 @Override
126 public List<String> getLuiIdsByPersonAndTypeAndState(String personId, String lprTypeKey, String relationState, ContextInfo contextInfo)
127 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
128 PermissionDeniedException {
129 List<String> list = new ArrayList<String>();
130 for (LprInfo info : lprMap.values()) {
131 if (personId.equals(info.getPersonId())) {
132 if (lprTypeKey.equals(info.getTypeKey())) {
133 if (relationState.equals(info.getStateKey())) {
134 list.add(info.getLuiId());
135 }
136 }
137 }
138 }
139 return list;
140 }
141
142 @Override
143 public List<String> getPersonIdsByLuiAndTypeAndState(String luiId, String lprTypeKey, String relationState, ContextInfo contextInfo)
144 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
145 PermissionDeniedException {
146 List<String> list = new ArrayList<String>();
147 for (LprInfo info : lprMap.values()) {
148 if (luiId.equals(info.getLuiId())) {
149 if (lprTypeKey.equals(info.getTypeKey())) {
150 if (relationState.equals(info.getStateKey())) {
151 list.add(info.getId());
152 }
153 }
154 }
155 }
156 return list;
157 }
158
159 @Override
160 public List<LprInfo> getLprsByPersonAndLui(String personId, String luiId, ContextInfo contextInfo)
161 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
162 PermissionDeniedException {
163 List<LprInfo> list = new ArrayList<LprInfo>();
164 for (LprInfo info : lprMap.values()) {
165 if (personId.equals(info.getPersonId())) {
166 if (luiId.equals(info.getLuiId())) {
167 list.add(info);
168 }
169 }
170 }
171 return list;
172 }
173
174 @Override
175 public List<LprInfo> getLprsByPerson(String personId, ContextInfo contextInfo)
176 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
177 PermissionDeniedException {
178 List<LprInfo> list = new ArrayList<LprInfo>();
179 for (LprInfo info : lprMap.values()) {
180 if (personId.equals(info.getPersonId())) {
181 list.add(info);
182 }
183 }
184 return list;
185 }
186
187 @Override
188 public List<LprInfo> getLprsByLui(String luiId, ContextInfo contextInfo)
189 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
190 PermissionDeniedException {
191 List<LprInfo> list = new ArrayList<LprInfo>();
192 for (LprInfo info : lprMap.values()) {
193 if (luiId.equals(info.getLuiId())) {
194 list.add(info);
195 }
196 }
197 return list;
198 }
199
200 @Override
201 public List<LprInfo> getLprsByLuiAndType(String luiId, String lprTypeKey, ContextInfo contextInfo)
202 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
203 PermissionDeniedException {
204 List<LprInfo> list = new ArrayList<LprInfo>();
205 for (LprInfo info : lprMap.values()) {
206 if (luiId.equals(info.getTypeKey())) {
207 if (lprTypeKey.equals(info.getTypeKey())) {
208 list.add(info);
209 }
210 }
211 }
212 return list;
213 }
214
215 @Override
216 public List<LprInfo> getLprsByPersonForAtp(String personId, String atpId, ContextInfo contextInfo)
217 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
218 PermissionDeniedException {
219 List<LprInfo> list = new ArrayList<LprInfo>();
220 for (LprInfo info : lprMap.values()) {
221 if (personId.equals(info.getPersonId())) {
222 LuiInfo lui = luiService.getLui(info.getLuiId(), contextInfo);
223 if (atpId.equals(lui.getAtpId())) {
224 list.add(info);
225 }
226 }
227 }
228 return list;
229 }
230
231 @Override
232 public List<LprInfo> getLprsByPersonAndTypeForAtp(String personId, String atpId, String lprTypeKey, ContextInfo contextInfo)
233 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
234 PermissionDeniedException {
235 List<LprInfo> list = new ArrayList<LprInfo>();
236 for (LprInfo info : lprMap.values()) {
237 if (personId.equals(info.getPersonId())) {
238 if (lprTypeKey.equals(info.getTypeKey())) {
239 LuiInfo lui = luiService.getLui(info.getLuiId(), contextInfo);
240 if (atpId.equals(lui.getAtpId())) {
241 list.add(info);
242 }
243 }
244 }
245 }
246 return list;
247 }
248
249 @Override
250 public List<LprInfo> getLprsByPersonAndLuiType(String personId, String luiTypeKey, ContextInfo contextInfo)
251 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
252 PermissionDeniedException {
253 List<LprInfo> list = new ArrayList<LprInfo>();
254 for (LprInfo info : lprMap.values()) {
255 if (personId.equals(info.getTypeKey())) {
256 if (luiTypeKey.equals(info.getTypeKey())) {
257 list.add(info);
258 }
259 }
260 }
261 return list;
262 }
263
264 @Override
265 public List<LprInfo> getLprsByPersonForAtpAndLuiType(String personId, String atpId, String luiTypeKey, ContextInfo contextInfo)
266 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
267 PermissionDeniedException {
268 List<LprInfo> list = new ArrayList<LprInfo>();
269 for (LprInfo info : lprMap.values()) {
270 if (personId.equals(info.getTypeKey())) {
271 if (atpId.equals(info.getTypeKey())) {
272 if (luiTypeKey.equals(info.getTypeKey())) {
273 list.add(info);
274 }
275 }
276 }
277 }
278 return list;
279 }
280
281 @Override
282 public List<ValidationResultInfo> validateLpr(String validationType, String luiId, String personId, String lprTypeKey, LprInfo lprInfo, ContextInfo contextInfo)
283 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
284 PermissionDeniedException {
285
286 return new ArrayList<ValidationResultInfo>();
287 }
288
289 @Override
290 public List<String> searchForLprIds(QueryByCriteria criteria, ContextInfo contextInfo)
291 throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
292 return new ArrayList<String>();
293 }
294
295 @Override
296 public List<LprInfo> searchForLprs(QueryByCriteria criteria, ContextInfo contextInfo)
297 throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
298 throw new OperationFailedException("searchForLprs has not been implemented");
299 }
300
301
302 private Map<String, LprInfo> lprMap = new LinkedHashMap<String, LprInfo>();
303
304 @Override
305 public LprInfo createLpr(String personId, String luiId, String lprTypeKey, LprInfo lprInfo, ContextInfo contextInfo)
306 throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException,
307 OperationFailedException, PermissionDeniedException, ReadOnlyException {
308
309 if (!lprTypeKey.equals(lprInfo.getTypeKey())) {
310 throw new InvalidParameterException("The type parameter does not match the type on the info object");
311 }
312
313 LprInfo copy = new LprInfo(lprInfo);
314 if (copy.getId() == null) {
315 copy.setId(UUIDHelper.genStringUUID());
316 }
317 copy.setMeta(newMeta(contextInfo));
318 lprMap.put(copy.getId(), copy);
319 return new LprInfo(copy);
320 }
321
322 @Override
323 public List<BulkStatusInfo> createLprsForPerson(String personId, String lprTypeKey, List<LprInfo> lprInfos, ContextInfo contextInfo)
324 throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException,
325 OperationFailedException, PermissionDeniedException, ReadOnlyException {
326 List<BulkStatusInfo> list = new ArrayList<BulkStatusInfo>(lprInfos.size());
327 for (LprInfo info : lprInfos) {
328 BulkStatusInfo bsi = new BulkStatusInfo();
329 try {
330 LprInfo created = this.createLpr(personId, info.getLuiId(), lprTypeKey, info, contextInfo);
331 bsi.setSuccess(Boolean.TRUE);
332 bsi.setId(created.getId());
333 } catch (DataValidationErrorException de) {
334 bsi.setSuccess(Boolean.FALSE);
335 bsi.setMessage(asString(de.getValidationResults()));
336 }
337 list.add(bsi);
338 }
339 return list;
340 }
341
342 private String asString(List<ValidationResultInfo> vris) {
343 StringBuilder sb = new StringBuilder();
344 String newLine = ";";
345 for (ValidationResultInfo vri : vris) {
346 sb.append(newLine);
347 newLine = "/n";
348 sb.append(vri.getMessage());
349 }
350 return sb.toString();
351 }
352
353 @Override
354 public List<BulkStatusInfo> createLprsForLui(String luiId, String lprTypeKey, List<LprInfo> lprInfos, ContextInfo contextInfo)
355 throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException,
356 OperationFailedException, PermissionDeniedException, ReadOnlyException {
357 List<BulkStatusInfo> list = new ArrayList<BulkStatusInfo>(lprInfos.size());
358 for (LprInfo info : lprInfos) {
359 BulkStatusInfo bsi = new BulkStatusInfo();
360 try {
361 LprInfo created = this.createLpr(info.getPersonId(), luiId, lprTypeKey, info, contextInfo);
362 bsi.setSuccess(Boolean.TRUE);
363 bsi.setId(created.getId());
364 } catch (DataValidationErrorException de) {
365 bsi.setSuccess(Boolean.FALSE);
366 bsi.setMessage(ValidationUtils.asString(de.getValidationResults()));
367 }
368 list.add(bsi);
369 }
370 return list;
371 }
372
373 @Override
374 public LprInfo updateLpr(String lprId, LprInfo lprInfo, ContextInfo contextInfo)
375 throws DoesNotExistException, DataValidationErrorException, InvalidParameterException, MissingParameterException,
376 OperationFailedException, PermissionDeniedException, ReadOnlyException, VersionMismatchException {
377
378 if (!lprId.equals(lprInfo.getId())) {
379 throw new InvalidParameterException("The id parameter does not match the id on the info object");
380 }
381 LprInfo copy = new LprInfo(lprInfo);
382 LprInfo old = this.getLpr(lprInfo.getId(), contextInfo);
383 if (!old.getMeta().getVersionInd().equals(copy.getMeta().getVersionInd())) {
384 throw new VersionMismatchException(old.getMeta().getVersionInd());
385 }
386 copy.setMeta(updateMeta(copy.getMeta(), contextInfo));
387 this.lprMap.put(lprInfo.getId(), copy);
388 return new LprInfo(copy);
389 }
390
391 @Override
392 public StatusInfo deleteLpr(String lprId, ContextInfo contextInfo)
393 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
394 PermissionDeniedException {
395 if (this.lprMap.remove(lprId) == null) {
396 throw new DoesNotExistException(lprId);
397 }
398 return newStatus();
399 }
400
401
402 private Map<String, LprTransactionInfo> lprTransactionMap = new LinkedHashMap<String, LprTransactionInfo>();
403
404 @Override
405 public LprTransactionInfo createLprTransaction(String lprTransactionType, LprTransactionInfo lprTransactionInfo, ContextInfo contextInfo)
406 throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException,
407 OperationFailedException, PermissionDeniedException {
408
409 if (!lprTransactionType.equals(lprTransactionInfo.getTypeKey())) {
410 throw new InvalidParameterException("The type parameter does not match the type on the info object");
411 }
412 LprTransactionInfo copy = new LprTransactionInfo(lprTransactionInfo);
413 if (copy.getId() == null) {
414 copy.setId(UUIDHelper.genStringUUID());
415 }
416 copy.setMeta(newMeta(contextInfo));
417
418 lprTransactionMap.put(copy.getId(), copy);
419 return new LprTransactionInfo(copy);
420 }
421
422 @Override
423 public LprTransactionInfo createLprTransactionFromExisting(String lprTransactionId, ContextInfo contextInfo)
424 throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException,
425 OperationFailedException, PermissionDeniedException {
426 throw new OperationFailedException("createLprTransactionFromExisting has not been implemented");
427 }
428
429 @Override
430 public LprTransactionInfo updateLprTransaction(String lprTransactionId, LprTransactionInfo lprTransactionInfo, ContextInfo contextInfo)
431 throws DataValidationErrorException, DoesNotExistException, InvalidParameterException, MissingParameterException,
432 OperationFailedException, PermissionDeniedException, VersionMismatchException {
433
434 if (!lprTransactionId.equals(lprTransactionInfo.getId())) {
435 throw new InvalidParameterException("The id parameter does not match the id on the info object");
436 }
437 LprTransactionInfo copy = new LprTransactionInfo(lprTransactionInfo);
438 LprTransactionInfo old = this.getLprTransaction(lprTransactionInfo.getId(), contextInfo);
439 if (!old.getMeta().getVersionInd().equals(copy.getMeta().getVersionInd())) {
440 throw new VersionMismatchException(old.getMeta().getVersionInd());
441 }
442 copy.setMeta(updateMeta(copy.getMeta(), contextInfo));
443 this.lprTransactionMap.put(lprTransactionInfo.getId(), copy);
444 return new LprTransactionInfo(copy);
445 }
446
447 @Override
448 public LprTransactionInfo getLprTransaction(String lprTransactionId, ContextInfo contextInfo)
449 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
450 PermissionDeniedException {
451 if (!this.lprTransactionMap.containsKey(lprTransactionId)) {
452 throw new DoesNotExistException(lprTransactionId);
453 }
454 return this.lprTransactionMap.get(lprTransactionId);
455 }
456
457 @Override
458 public List<LprTransactionItemInfo> getLprTransactionItemsByPersonAndLui(String personId, String luiId, ContextInfo contextInfo)
459 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
460 PermissionDeniedException {
461 List<LprTransactionItemInfo> list = new ArrayList<LprTransactionItemInfo>();
462 for (LprTransactionInfo trans : lprTransactionMap.values()) {
463 for (LprTransactionItemInfo info : trans.getLprTransactionItems()) {
464 if (personId.equals(info.getPersonId())) {
465 if (luiId.equals(info.getNewLuiId())) {
466 list.add(info);
467 } else if (luiId.equals(info.getExistingLuiId())) {
468 list.add(info);
469 }
470 }
471 }
472 }
473 return list;
474 }
475
476 @Override
477 public List<LprTransactionInfo> getLprTransactionsByIds(List<String> lprTransactionIds, ContextInfo contextInfo)
478 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
479 PermissionDeniedException {
480 List<LprTransactionInfo> list = new ArrayList<LprTransactionInfo>();
481 for (String id : lprTransactionIds) {
482 list.add(this.getLprTransaction(id, contextInfo));
483 }
484 return list;
485 }
486
487 @Override
488 public List<LprTransactionItemInfo> getLprTransactionItemsByResultingLpr(String lprId, ContextInfo contextInfo)
489 throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
490 List<LprTransactionItemInfo> list = new ArrayList<LprTransactionItemInfo>();
491 for (LprTransactionInfo trans : this.lprTransactionMap.values()) {
492 for (LprTransactionItemInfo info : trans.getLprTransactionItems()) {
493 if (info.getLprTransactionItemResult() != null) {
494 if (lprId.equals(info.getLprTransactionItemResult().getResultingLprId())) {
495 list.add(info);
496 }
497 }
498 }
499 }
500 return list;
501 }
502
503 @Override
504 public List<LprTransactionItemInfo> getLprTransactionItemsByLui(String luiId, ContextInfo contextInfo)
505 throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
506 List<LprTransactionItemInfo> list = new ArrayList<LprTransactionItemInfo>();
507
508 for (LprTransactionInfo trans : lprTransactionMap.values()) {
509 for (LprTransactionItemInfo info : trans.getLprTransactionItems()) {
510 if (luiId.equals(info.getNewLuiId())) {
511 list.add(info);
512 } else if (luiId.equals(info.getExistingLuiId())) {
513 list.add(info);
514 }
515 }
516 }
517 return list;
518 }
519
520 @Override
521 public List<LprTransactionInfo> getUnsubmittedLprTransactionsByRequestingPersonAndAtp(String requestingPersonId, String atpId, ContextInfo contextInfo)
522 throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
523 List<LprTransactionInfo> list = new ArrayList<LprTransactionInfo>();
524 for (LprTransactionInfo info : lprTransactionMap.values()) {
525 if (requestingPersonId.equals(info.getRequestingPersonId())) {
526 if (atpId.equals(info.getAtpId())) {
527 if (info.getStateKey().equals(LprServiceConstants.LPRTRANS_NEW_STATE_KEY)) {
528 list.add(info);
529 }
530 }
531 }
532 }
533 return list;
534 }
535
536 @Override
537 public StatusInfo deleteLprTransaction(String lprTransactionId, ContextInfo contextInfo)
538 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
539 PermissionDeniedException {
540 if (this.lprTransactionMap.remove(lprTransactionId) == null) {
541 throw new DoesNotExistException(lprTransactionId);
542 }
543 return newStatus();
544 }
545
546 @Override
547 public LprTransactionInfo processLprTransaction(String lprTransactionId, ContextInfo contextInfo)
548 throws AlreadyExistsException, DoesNotExistException, InvalidParameterException, MissingParameterException,
549 OperationFailedException, PermissionDeniedException {
550 throw new OperationFailedException("processLprTransaction has not been implemented");
551 }
552
553 @Override
554 public List<ValidationResultInfo> verifyLprTransaction(String lprTransactionId, ContextInfo contextInfo)
555 throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException,
556 PermissionDeniedException {
557 throw new OperationFailedException("verifyLprTransaction has not been implemented");
558 }
559
560 @Override
561 public List<LprTransactionInfo> searchForLprTransactions(QueryByCriteria criteria, ContextInfo contextInfo)
562 throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
563 throw new OperationFailedException("searchForLprTransactions has not been implemented");
564 }
565
566 @Override
567 public List<String> searchForLprTransactionIds(QueryByCriteria criteria, ContextInfo contextInfo)
568 throws InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException {
569 throw new OperationFailedException("searchForLprTransactionIds has not been implemented");
570 }
571
572 private MetaInfo newMeta(ContextInfo context) {
573 MetaInfo meta = new MetaInfo();
574 meta.setCreateId(context.getPrincipalId());
575 meta.setCreateTime(new Date());
576 meta.setUpdateId(context.getPrincipalId());
577 meta.setUpdateTime(meta.getCreateTime());
578 meta.setVersionInd("0");
579 return meta;
580 }
581
582 private StatusInfo newStatus() {
583 StatusInfo status = new StatusInfo();
584 status.setSuccess(Boolean.TRUE);
585 return status;
586 }
587
588 private MetaInfo updateMeta(MetaInfo old, ContextInfo context) {
589 MetaInfo meta = new MetaInfo(old);
590 meta.setUpdateId(context.getPrincipalId());
591 meta.setUpdateTime(new Date());
592 meta.setVersionInd((Integer.parseInt(meta.getVersionInd()) + 1) + "");
593 return meta;
594 }
595
596
597
598
599 @Override
600 public List<ValidationResultInfo> validateLprTransaction(
601 String validationType,
602 String lprTransactionType,
603 LprTransactionInfo lprTransactionInfo,
604 ContextInfo contextInfo)
605 throws DoesNotExistException, InvalidParameterException,
606 MissingParameterException, OperationFailedException,
607 PermissionDeniedException {
608 return new ArrayList<ValidationResultInfo>();
609 }
610
611 }