1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.student.lum.lo.service.impl;
17
18 import java.util.ArrayList;
19 import java.util.HashMap;
20 import java.util.Iterator;
21 import java.util.List;
22 import java.util.Map;
23
24 import javax.jws.WebService;
25
26 import org.kuali.student.common.dictionary.dto.ObjectStructureDefinition;
27 import org.kuali.student.common.dictionary.service.DictionaryService;
28 import org.kuali.student.common.dto.DtoConstants;
29 import org.kuali.student.common.dto.StatusInfo;
30 import org.kuali.student.common.exceptions.AlreadyExistsException;
31 import org.kuali.student.common.exceptions.DataValidationErrorException;
32 import org.kuali.student.common.exceptions.DependentObjectsExistException;
33 import org.kuali.student.common.exceptions.DoesNotExistException;
34 import org.kuali.student.common.exceptions.InvalidParameterException;
35 import org.kuali.student.common.exceptions.MissingParameterException;
36 import org.kuali.student.common.exceptions.OperationFailedException;
37 import org.kuali.student.common.exceptions.PermissionDeniedException;
38 import org.kuali.student.common.exceptions.UnsupportedActionException;
39 import org.kuali.student.common.exceptions.VersionMismatchException;
40 import org.kuali.student.common.search.dto.SearchCriteriaTypeInfo;
41 import org.kuali.student.common.search.dto.SearchParam;
42 import org.kuali.student.common.search.dto.SearchRequest;
43 import org.kuali.student.common.search.dto.SearchResult;
44 import org.kuali.student.common.search.dto.SearchResultCell;
45 import org.kuali.student.common.search.dto.SearchResultRow;
46 import org.kuali.student.common.search.dto.SearchResultTypeInfo;
47 import org.kuali.student.common.search.dto.SearchTypeInfo;
48 import org.kuali.student.common.search.service.SearchManager;
49 import org.kuali.student.common.validation.dto.ValidationResultInfo;
50 import org.kuali.student.common.validator.Validator;
51 import org.kuali.student.common.validator.ValidatorFactory;
52 import org.kuali.student.lum.lo.dao.LoDao;
53 import org.kuali.student.lum.lo.dto.LoCategoryInfo;
54 import org.kuali.student.lum.lo.dto.LoCategoryTypeInfo;
55 import org.kuali.student.lum.lo.dto.LoInfo;
56 import org.kuali.student.lum.lo.dto.LoLoRelationInfo;
57 import org.kuali.student.lum.lo.dto.LoLoRelationTypeInfo;
58 import org.kuali.student.lum.lo.dto.LoRepositoryInfo;
59 import org.kuali.student.lum.lo.dto.LoTypeInfo;
60 import org.kuali.student.lum.lo.entity.Lo;
61 import org.kuali.student.lum.lo.entity.LoCategory;
62 import org.kuali.student.lum.lo.entity.LoCategoryType;
63 import org.kuali.student.lum.lo.entity.LoLoRelation;
64 import org.kuali.student.lum.lo.entity.LoLoRelationType;
65 import org.kuali.student.lum.lo.entity.LoRepository;
66 import org.kuali.student.lum.lo.entity.LoType;
67 import org.kuali.student.lum.lo.service.LearningObjectiveService;
68 import org.springframework.transaction.annotation.Transactional;
69
70
71
72
73
74 @WebService(endpointInterface = "org.kuali.student.lum.lo.service.LearningObjectiveService", serviceName = "LearningObjectiveService", portName = "LearningObjectiveService", targetNamespace = "http://student.kuali.org/wsdl/lo")
75 @Transactional(readOnly=true,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
76 public class LearningObjectiveServiceImpl implements LearningObjectiveService {
77 private LoDao loDao;
78 private SearchManager searchManager;
79 private DictionaryService dictionaryServiceDelegate;
80 private ValidatorFactory validatorFactory;
81
82 public LoDao getLoDao() {
83 return loDao;
84 }
85
86 public void setLoDao(LoDao dao) {
87 this.loDao = dao;
88 }
89
90 public void setSearchManager(SearchManager searchManager) {
91 this.searchManager = searchManager;
92 }
93
94 public void setDictionaryServiceDelegate(DictionaryService dictionaryServiceDelegate) {
95 this.dictionaryServiceDelegate = dictionaryServiceDelegate;
96 }
97
98 public ValidatorFactory getValidatorFactory() {
99 return validatorFactory;
100 }
101
102 public void setValidatorFactory(ValidatorFactory validatorFactory) {
103 this.validatorFactory = validatorFactory;
104 }
105
106
107
108
109
110 @Override
111 public List<LoRepositoryInfo> getLoRepositories()
112 throws OperationFailedException {
113 List<LoRepository> repositories = loDao.find(LoRepository.class);
114 return LearningObjectiveServiceAssembler.toLoRepositoryInfos(repositories);
115 }
116
117
118
119
120
121 @Override
122 public LoRepositoryInfo getLoRepository(String loRepositoryKey)
123 throws DoesNotExistException, InvalidParameterException,
124 MissingParameterException, OperationFailedException {
125 checkForMissingParameter(loRepositoryKey, "loRepositoryKey");
126 return LearningObjectiveServiceAssembler.toLoRepositoryInfo(loDao.fetch(LoRepository.class, loRepositoryKey));
127 }
128
129
130
131
132
133 @Override
134 public List<LoTypeInfo> getLoTypes() throws OperationFailedException {
135 List<LoType> find = loDao.find(LoType.class);
136 return LearningObjectiveServiceAssembler.toLoTypeInfos(find);
137 }
138
139
140
141
142
143 @Override
144 public LoTypeInfo getLoType(String loTypeKey) throws DoesNotExistException,
145 InvalidParameterException, MissingParameterException,
146 OperationFailedException {
147 checkForMissingParameter(loTypeKey, "loTypeKey");
148 LoType fetch = loDao.fetch(LoType.class, loTypeKey);
149 return LearningObjectiveServiceAssembler.toLoTypeInfo(fetch);
150 }
151
152
153
154
155
156 @Override
157 public List<LoLoRelationTypeInfo> getLoLoRelationTypes()
158 throws OperationFailedException {
159 List<LoLoRelationType> fetch = loDao.find(LoLoRelationType.class);
160 return LearningObjectiveServiceAssembler.toLoLoRelationTypeInfos(fetch);
161 }
162
163
164
165
166
167 @Override
168 public LoLoRelationTypeInfo getLoLoRelationType(String loLoRelationTypeKey)
169 throws OperationFailedException, MissingParameterException, DoesNotExistException {
170 checkForMissingParameter(loLoRelationTypeKey, "loLoRelationTypeKey");
171 return LearningObjectiveServiceAssembler.toLoLoRelationTypeInfo(loDao.fetch(LoLoRelationType.class, loLoRelationTypeKey));
172 }
173
174 @Override
175 public List<String> getAllowedLoLoRelationTypesForLoType(String loTypeKey, String relatedLoTypeKey)
176 throws DoesNotExistException, InvalidParameterException,
177 MissingParameterException, OperationFailedException {
178 checkForMissingParameter(loTypeKey, "loTypeKey");
179 checkForMissingParameter(relatedLoTypeKey, "relatedLoTypeKey");
180
181 return loDao.getAllowedLoLoRelationTypesForLoType(loTypeKey, relatedLoTypeKey);
182 }
183
184
185
186
187
188 @Override
189 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
190 public StatusInfo addLoCategoryToLo(String loCategoryId, String loId)
191 throws AlreadyExistsException, DoesNotExistException,
192 InvalidParameterException, MissingParameterException,
193 OperationFailedException, PermissionDeniedException,
194 UnsupportedActionException {
195 checkForMissingParameter(loCategoryId, "loCategoryId");
196 checkForMissingParameter(loId, "loId");
197 StatusInfo statusInfo = new StatusInfo();
198 statusInfo.setSuccess(loDao.addLoCategoryToLo(loCategoryId, loId));
199 return statusInfo;
200 }
201
202
203
204
205 @Override
206 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
207 public LoInfo createLo(String repositoryId, String loType, LoInfo loInfo)
208 throws DataValidationErrorException, DoesNotExistException,
209 InvalidParameterException, MissingParameterException,
210 OperationFailedException, PermissionDeniedException {
211 checkForMissingParameter(repositoryId, "repositoryId");
212 checkForMissingParameter(loType, "loType");
213 checkForMissingParameter(loInfo, "loInfo");
214
215
216
217 List<ValidationResultInfo> val = validateLo("SYSTEM", loInfo);
218 if(null != val && val.size() > 0) {
219 for (ValidationResultInfo result : val) {
220 System.err.println("Validation error. Element: " + result.getElement() + ", Value: " + result.getMessage());
221 }
222 throw new DataValidationErrorException("Validation error!", val);
223 }
224
225
226
227 LoType type = null;
228 LoRepository repository = null;
229 try {
230 type = loDao.fetch(LoType.class, loType);
231 repository = loDao.fetch(LoRepository.class, repositoryId);
232 } catch (DoesNotExistException dnee) {
233 throw new DoesNotExistException("Specified " + (null == type ? "LoType" : "LoRepository") + " does not exist", dnee);
234 }
235
236 loInfo.setLoRepositoryKey(repositoryId);
237 loInfo.setType(loType);
238
239 Lo lo = null;
240 try {
241 lo = LearningObjectiveServiceAssembler.toLo(false, loInfo, loDao);
242 } catch (VersionMismatchException vme) {
243
244 throw new OperationFailedException("VersionMismatchException caught during Learning Objective creation");
245 }
246 lo.setLoType(type);
247 lo.setLoRepository(repository);
248 loDao.create(lo);
249
250 return LearningObjectiveServiceAssembler.toLoInfo(lo);
251 }
252
253
254
255
256 @Override
257 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
258 public StatusInfo deleteLo(String loId)
259 throws DependentObjectsExistException, DoesNotExistException,
260 InvalidParameterException, MissingParameterException,
261 OperationFailedException, PermissionDeniedException {
262 checkForMissingParameter(loId, "loId");
263
264 StatusInfo returnStatus = new StatusInfo();
265 returnStatus.setSuccess(loDao.deleteLo(loId));
266 return returnStatus;
267 }
268
269
270
271
272 @Override
273 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
274 public StatusInfo deleteLoCategory(String loCategoryId)
275 throws DependentObjectsExistException, DoesNotExistException,
276 InvalidParameterException, MissingParameterException,
277 OperationFailedException, PermissionDeniedException {
278 checkForMissingParameter(loCategoryId, "loCategoryId");
279
280 loDao.deleteLoCategory(loCategoryId);
281
282 return new StatusInfo();
283 }
284
285
286
287
288 @Override
289 public LoInfo getLo(String loId) throws DoesNotExistException,
290 InvalidParameterException, MissingParameterException,
291 OperationFailedException {
292 checkForMissingParameter(loId, "loId");
293
294 return LearningObjectiveServiceAssembler.toLoInfo(loDao.fetch(Lo.class, loId));
295 }
296
297
298
299
300 @Override
301 public List<LoInfo> getLoByIdList(List<String> loIds)
302 throws InvalidParameterException, MissingParameterException,
303 OperationFailedException {
304 checkForMissingParameter(loIds, "loId");
305 checkForEmptyList(loIds, "loId");
306 List<Lo> los = loDao.getLoByIdList(loIds);
307 return LearningObjectiveServiceAssembler.toLoInfos(los);
308 }
309
310
311
312
313 @Override
314 public List<LoCategoryInfo> getLoCategories(String loRepositoryKey)
315 throws DoesNotExistException, InvalidParameterException,
316 MissingParameterException, OperationFailedException {
317 checkForMissingParameter(loRepositoryKey, "loRepositoryKey");
318 List<LoCategory> categories = loDao.getLoCategories(loRepositoryKey);
319 return LearningObjectiveServiceAssembler.toLoCategoryInfos(categories);
320 }
321
322
323
324
325 @Override
326 public List<LoCategoryInfo> getLoCategoriesForLo(String loId)
327 throws DoesNotExistException, InvalidParameterException,
328 MissingParameterException, OperationFailedException {
329 checkForMissingParameter(loId, "loId");
330 List<LoCategory> categories = loDao.getLoCategoriesForLo(loId);
331 return LearningObjectiveServiceAssembler.toLoCategoryInfos(categories);
332 }
333
334
335
336
337 @Override
338 public LoCategoryInfo getLoCategory(String loCategoryId)
339 throws DoesNotExistException, InvalidParameterException,
340 MissingParameterException, OperationFailedException {
341 checkForMissingParameter(loCategoryId, "loCategoryId");
342
343 return LearningObjectiveServiceAssembler.toLoCategoryInfo(loDao.fetch(LoCategory.class, loCategoryId));
344 }
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360 @Override
361 public List<LoInfo> getLosByLoCategory(String loCategoryId)
362 throws DoesNotExistException, InvalidParameterException,
363 MissingParameterException, OperationFailedException {
364 checkForMissingParameter(loCategoryId, "loCategoryId");
365 List<Lo> los = loDao.getLosByLoCategory(loCategoryId);
366 return LearningObjectiveServiceAssembler.toLoInfos(los);
367 }
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430 @Override
431 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
432 public StatusInfo removeLoCategoryFromLo(String loCategoryId, String loId)
433 throws DoesNotExistException, InvalidParameterException,
434 MissingParameterException, OperationFailedException,
435 PermissionDeniedException, UnsupportedActionException {
436 checkForMissingParameter(loCategoryId, "loCategoryId");
437 checkForMissingParameter(loId, "loId");
438
439 StatusInfo statusInfo = new StatusInfo();
440 statusInfo.setSuccess(loDao.removeLoCategoryFromLo(loCategoryId, loId));
441 return statusInfo;
442 }
443
444
445
446
447 @Override
448 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
449 public LoInfo updateLo(String loId, LoInfo loInfo)
450 throws DataValidationErrorException, DoesNotExistException,
451 InvalidParameterException, MissingParameterException,
452 OperationFailedException, PermissionDeniedException,
453 VersionMismatchException {
454 checkForMissingParameter(loId, "loId");
455 checkForMissingParameter(loInfo, "loInfo");
456
457
458 List<ValidationResultInfo> val = validateLo("SYSTEM", loInfo);
459 if(null != val && val.size() > 0) {
460 for (ValidationResultInfo result : val) {
461 System.err.println("Validation error. Element: " + result.getElement() + ", Value: " + result.getMessage());
462 }
463 throw new DataValidationErrorException("Validation error!", val);
464 }
465
466 Lo lo = loDao.fetch(Lo.class, loId);
467
468 if (!String.valueOf(lo.getVersionNumber()).equals(loInfo.getMetaInfo().getVersionInd())){
469 throw new VersionMismatchException("LO to be updated is not the current version");
470 }
471
472 lo = LearningObjectiveServiceAssembler.toLo(true, lo, loInfo, loDao);
473 loDao.update(lo);
474 return LearningObjectiveServiceAssembler.toLoInfo(lo);
475 }
476
477
478
479
480 @Override
481 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
482 public LoCategoryInfo updateLoCategory(String loCategoryId,
483 LoCategoryInfo loCategoryInfo) throws DataValidationErrorException,
484 DoesNotExistException, InvalidParameterException,
485 MissingParameterException, OperationFailedException,
486 PermissionDeniedException, VersionMismatchException {
487 checkForMissingParameter(loCategoryId, "loCategoryId");
488 checkForMissingParameter(loCategoryInfo, "loCategoryInfo");
489
490
491 List<ValidationResultInfo> val = validateLoCategory("SYSTEM", loCategoryInfo);
492
493
494 if (doesLoCategoryExist(loCategoryInfo.getLoRepository(), loCategoryInfo, loCategoryId)) {
495 ValidationResultInfo vr = new ValidationResultInfo();
496 vr.setElement("LO Category Name");
497 vr.setError("LO Category already exists");
498 val.add(vr);
499 }
500 if(null != val && val.size() > 0) {
501 for (ValidationResultInfo result : val) {
502 System.err.println("Validation error. Element: " + result.getElement() + ", Value: " + result.getMessage());
503 }
504 throw new DataValidationErrorException("Validation error!", val);
505 }
506 LoCategory loCategory = loDao.fetch(LoCategory.class, loCategoryId);
507
508 if (!String.valueOf(loCategory.getVersionNumber()).equals(loCategoryInfo.getMetaInfo().getVersionInd())){
509 throw new VersionMismatchException("LoCategory to be updated is not the current version");
510 }
511
512
513 if (loCategory.getState().equals("active") && ( ! loCategoryInfo.getState().equals("active") )) {
514
515
516 List<LoInfo> loInfos = getLosByLoCategory(loCategoryId);
517 if (null != loInfos) {
518
519 for (LoInfo info : loInfos) {
520 if (info.getState().equals("active")) {
521 try {
522 removeLoCategoryFromLo(loCategoryId, info.getId());
523 } catch (UnsupportedActionException uaee) {
524 throw new OperationFailedException("Unable to update LoCategory: could not remove association with active LearningObjective", uaee);
525 }
526 }
527 }
528 }
529 }
530
531
532 if ( ! loCategory.getLoCategoryType().getId().equals(loCategoryInfo.getType()) ) {
533 loCategory = cloneLoCategory(loCategory, loCategoryInfo);
534 } else {
535 loCategory = LearningObjectiveServiceAssembler.toLoCategory(loCategory, loCategoryInfo, loDao);
536 loDao.update(loCategory);
537 }
538 return LearningObjectiveServiceAssembler.toLoCategoryInfo(loCategory);
539 }
540
541
542
543
544 private LoCategory cloneLoCategory(LoCategory loCategory, LoCategoryInfo loCategoryInfo) throws DoesNotExistException, InvalidParameterException, OperationFailedException {
545 LoCategoryType catType = null;
546
547 try {
548 catType = loDao.fetch(LoCategoryType.class, loCategoryInfo.getType());
549 } catch (DoesNotExistException dnee) {
550 throw new DoesNotExistException("Attempt to set LoCategory's type to nonexistent LoCategoryType", dnee);
551 }
552
553
554 LoCategoryInfo newLoCategoryInfo = LearningObjectiveServiceAssembler.toLoCategoryInfo(loCategory);
555 newLoCategoryInfo.setType(catType.getId());
556 newLoCategoryInfo.setName(loCategoryInfo.getName());
557 LoCategory newLoCategory = loDao.create(LearningObjectiveServiceAssembler.toLoCategory(newLoCategoryInfo, loDao));
558
559
560 List<Lo> catsLos = loDao.getLosByLoCategory(loCategory.getId());
561 for (Lo lo : catsLos) {
562 try {
563
564 loDao.addLoCategoryToLo(newLoCategory.getId(), lo.getId());
565
566 loDao.removeLoCategoryFromLo(loCategory.getId(), lo.getId());
567 } catch (UnsupportedActionException uae) {
568 throw new OperationFailedException(uae.getMessage(), uae);
569 }
570 }
571
572
573 loCategory.setState("Suspended");
574 loDao.update(loCategory);
575
576 return newLoCategory;
577 }
578
579
580
581
582 @Override
583 public List<ValidationResultInfo> validateLo(String validationType,
584 LoInfo loInfo) throws DoesNotExistException,
585 InvalidParameterException, MissingParameterException,
586 OperationFailedException {
587 checkForMissingParameter(validationType, "validationType");
588 checkForMissingParameter(loInfo, "loInfo");
589
590
591
592
593
594
595
596
597
598 ObjectStructureDefinition objStructure = this.getObjectStructure(LoInfo.class.getName());
599 Validator validator = validatorFactory.getValidator();
600 return validator.validateObject(loInfo, objStructure);
601 }
602
603
604
605
606 @Override
607 public List<ValidationResultInfo> validateLoCategory(String validationType,
608 LoCategoryInfo loCategoryInfo) throws DoesNotExistException,
609 InvalidParameterException, MissingParameterException,
610 OperationFailedException {
611 checkForMissingParameter(validationType, "validationType");
612 checkForMissingParameter(loCategoryInfo, "loCategoryInfo");
613
614
615
616
617
618
619
620
621
622 ObjectStructureDefinition objStructure = this.getObjectStructure(LoCategoryInfo.class.getName());
623 Validator validator = validatorFactory.getValidator();
624 return validator.validateObject(loCategoryInfo, objStructure);
625
626 }
627
628 @Override
629 public List<ValidationResultInfo> validateLoLoRelation(
630 String validationType, LoLoRelationInfo loLoRelationInfo)
631 throws DoesNotExistException, InvalidParameterException,
632 MissingParameterException, OperationFailedException {
633
634 ObjectStructureDefinition objStructure = this.getObjectStructure(LoLoRelationInfo.class.getName());
635 Validator validator = validatorFactory.getValidator();
636 return validator.validateObject(loLoRelationInfo, objStructure);
637 }
638
639
640
641
642
643
644
645
646 private void checkForMissingParameter(Object param, String paramName)
647 throws MissingParameterException {
648 if (param == null) {
649 throw new MissingParameterException(paramName + " can not be null");
650 }
651 }
652
653
654
655
656
657
658 private void checkForEmptyList(Object param, String paramName)
659 throws MissingParameterException {
660 if (param != null && param instanceof List && ((List<?>)param).size() == 0) {
661 throw new MissingParameterException(paramName + " can not be an empty list");
662 }
663 }
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685 private boolean doesLoCategoryExist(String loRepositoryKey, LoCategoryInfo loCategoryInfo, String loCategoryId)
686 throws MissingParameterException, DataValidationErrorException {
687 if (loCategoryInfo.getName() == null)
688 {
689 return false;
690 }
691 boolean exists = false;
692 SearchRequest request = new SearchRequest();
693 request.setSearchKey("lo.search.loCategoriesByNameRepoTypeState");
694
695 List<SearchParam> searchParams = new ArrayList<SearchParam>();
696 SearchParam qpv1 = new SearchParam();
697 qpv1.setKey("lo.queryParam.loCategoryName");
698 qpv1.setValue(loCategoryInfo.getName().toLowerCase());
699 searchParams.add(qpv1);
700 SearchParam qpv2 = new SearchParam();
701 qpv2.setKey("lo.queryParam.loCategoryRepo");
702 qpv2.setValue(loRepositoryKey);
703 searchParams.add(qpv2);
704 SearchParam qpv3 = new SearchParam();
705 qpv3.setKey("lo.queryParam.loCategoryType");
706 qpv3.setValue(loCategoryInfo.getType());
707 searchParams.add(qpv3);
708 SearchParam qpv4 = new SearchParam();
709 qpv4.setKey("lo.queryParam.loCategoryState");
710 qpv4.setValue(loCategoryInfo.getState());
711 searchParams.add(qpv4);
712
713 request.setParams(searchParams);
714
715 SearchResult result = search(request);
716
717 if(loCategoryId != null && !loCategoryId.trim().equals("")){
718 if (result.getRows().size() > 0) {
719 for(SearchResultRow srrow : result.getRows()){
720 List<SearchResultCell> srCells = srrow.getCells();
721 if(srCells != null && srCells.size() > 0){
722 for(SearchResultCell srcell : srCells){
723 if(!srcell.getValue().equals(loCategoryId)) {
724 exists = true;
725 }
726 }
727 }
728 }
729 }
730 }
731 else{
732 if (result.getRows().size() > 0) {
733 exists = true;
734 }
735 }
736 return exists;
737 }
738
739 @Override
740 public ObjectStructureDefinition getObjectStructure(String objectTypeKey) {
741 return dictionaryServiceDelegate.getObjectStructure(objectTypeKey);
742 }
743
744 @Override
745 public List<String> getObjectTypes() {
746 return dictionaryServiceDelegate.getObjectTypes();
747 }
748
749
750
751
752 @Override
753 public SearchCriteriaTypeInfo getSearchCriteriaType(
754 String searchCriteriaTypeKey) throws DoesNotExistException,
755 InvalidParameterException, MissingParameterException,
756 OperationFailedException {
757
758 return searchManager.getSearchCriteriaType(searchCriteriaTypeKey);
759 }
760
761
762
763
764 @Override
765 public List<SearchCriteriaTypeInfo> getSearchCriteriaTypes()
766 throws OperationFailedException {
767 return searchManager.getSearchCriteriaTypes();
768 }
769
770
771
772
773 @Override
774 public SearchResultTypeInfo getSearchResultType(String searchResultTypeKey)
775 throws DoesNotExistException, InvalidParameterException,
776 MissingParameterException, OperationFailedException {
777 checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
778 return searchManager.getSearchResultType(searchResultTypeKey);
779 }
780
781
782
783
784 @Override
785 public List<SearchResultTypeInfo> getSearchResultTypes()
786 throws OperationFailedException {
787 return searchManager.getSearchResultTypes();
788 }
789
790
791
792
793 @Override
794 public SearchTypeInfo getSearchType(String searchTypeKey)
795 throws DoesNotExistException, InvalidParameterException,
796 MissingParameterException, OperationFailedException {
797 checkForMissingParameter(searchTypeKey, "searchTypeKey");
798 return searchManager.getSearchType(searchTypeKey);
799 }
800
801
802
803
804 @Override
805 public List<SearchTypeInfo> getSearchTypes()
806 throws OperationFailedException {
807 return searchManager.getSearchTypes();
808 }
809
810
811
812
813 @Override
814 public List<SearchTypeInfo> getSearchTypesByCriteria(
815 String searchCriteriaTypeKey) throws DoesNotExistException,
816 InvalidParameterException, MissingParameterException,
817 OperationFailedException {
818 checkForMissingParameter(searchCriteriaTypeKey, "searchCriteriaTypeKey");
819 return searchManager.getSearchTypesByCriteria(searchCriteriaTypeKey);
820 }
821
822
823
824
825 @Override
826 public List<SearchTypeInfo> getSearchTypesByResult(
827 String searchResultTypeKey) throws DoesNotExistException,
828 InvalidParameterException, MissingParameterException,
829 OperationFailedException {
830 checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
831 return searchManager.getSearchTypesByResult(searchResultTypeKey);
832 }
833
834 @Override
835 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
836 public LoLoRelationInfo createLoLoRelation(String loId, String relatedLoId,
837 String loLoRelationType, LoLoRelationInfo loLoRelationInfo)
838 throws AlreadyExistsException,
839 DataValidationErrorException, DoesNotExistException,
840 InvalidParameterException, MissingParameterException,
841 OperationFailedException, PermissionDeniedException {
842 checkForMissingParameter(loId, "loId");
843 checkForMissingParameter(relatedLoId, "relatedLoId");
844 checkForMissingParameter(loLoRelationType, "loLoRelationType");
845 checkForMissingParameter(loLoRelationInfo, "loLoRelationInfo");
846
847
848 List<ValidationResultInfo> val = validateLoLoRelation("SYSTEM", loLoRelationInfo);
849 if(null != val && val.size() > 0) {
850 for (ValidationResultInfo result : val) {
851 System.err.println("Validation error. Element: " + result.getElement() + ", Value: " + result.getMessage());
852 }
853 throw new DataValidationErrorException("Validation error!", val);
854 }
855
856 if (null == loLoRelationInfo.getState()) {
857 loLoRelationInfo.setState(DtoConstants.STATE_DRAFT);
858 }
859 Lo lo = loDao.fetch(Lo.class, loId);
860 Lo relatedLo = loDao.fetch(Lo.class, relatedLoId);
861 LoLoRelationType type = loDao.fetch(LoLoRelationType.class, loLoRelationType);
862 loLoRelationInfo.setLoId(loId);
863 loLoRelationInfo.setRelatedLoId(relatedLoId);
864 loLoRelationInfo.setType(loLoRelationType);
865
866 LoLoRelation relation = null;
867 try {
868 relation = LearningObjectiveServiceAssembler.toLoLoRelation(false, loLoRelationInfo, loDao);
869 } catch (VersionMismatchException vme) {
870
871 throw new OperationFailedException("VersionMismatchException caught during LoLoRelation creation");
872 }
873 relation.setLo(lo);
874 relation.setRelatedLo(relatedLo);
875 relation.setLoLoRelationType(type);
876
877 relation = loDao.create(relation);
878
879 return LearningObjectiveServiceAssembler.toLoLoRelationInfo(relation);
880 }
881
882 @Override
883 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
884 public StatusInfo deleteLoLoRelation(String loLoRelationId)
885 throws DoesNotExistException, InvalidParameterException,
886 MissingParameterException, OperationFailedException,
887 PermissionDeniedException {
888 checkForMissingParameter(loLoRelationId, "loLoRelationId");
889
890 loDao.deleteLoLoRelation(loLoRelationId);
891
892 return new StatusInfo();
893 }
894
895 @Override
896 public LoLoRelationInfo getLoLoRelation(String loLoRelationId)
897 throws DoesNotExistException, InvalidParameterException,
898 MissingParameterException, OperationFailedException {
899 checkForMissingParameter(loLoRelationId, "loLoRelationId");
900 return LearningObjectiveServiceAssembler.toLoLoRelationInfo(loDao.fetch(LoLoRelation.class, loLoRelationId));
901 }
902
903 @Override
904 public List<LoLoRelationInfo> getLoLoRelationsByLoId(String loId)
905 throws DoesNotExistException, InvalidParameterException,
906 MissingParameterException, OperationFailedException {
907 List<LoLoRelation> llRelations = loDao.getLoLoRelationsByLoId(loId);
908 return LearningObjectiveServiceAssembler.toLoLoRelationInfos(llRelations);
909 }
910
911 @Override
912 public List<LoInfo> getLosByRelatedLoId(String relatedLoId,
913 String loLoRelationType) throws DoesNotExistException,
914 InvalidParameterException, MissingParameterException,
915 OperationFailedException {
916 List<Lo> relatedLos = loDao.getLosByRelatedLoId(relatedLoId, loLoRelationType);
917 return LearningObjectiveServiceAssembler.toLoInfos(relatedLos);
918 }
919
920 @Override
921 public List<LoInfo> getRelatedLosByLoId(String loId, String loLoRelationTypeKey)
922 throws DoesNotExistException, InvalidParameterException,
923 MissingParameterException, OperationFailedException {
924 checkForMissingParameter(loId, "loId");
925 checkForMissingParameter(loLoRelationTypeKey, "loLoRelationTypeKey");
926 List<Lo> relatedLos = loDao.getRelatedLosByLoId(loId, loLoRelationTypeKey);
927 return LearningObjectiveServiceAssembler.toLoInfos(relatedLos);
928 }
929
930 @Override
931 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
932 public LoLoRelationInfo updateLoLoRelation(String loLoRelationId,
933 LoLoRelationInfo loLoRelationInfo)
934 throws DataValidationErrorException, DoesNotExistException,
935 InvalidParameterException, MissingParameterException,
936 OperationFailedException, PermissionDeniedException,
937 VersionMismatchException {
938
939
940
941 List<ValidationResultInfo> val = validateLoLoRelation("SYSTEM", loLoRelationInfo);
942 if(null != val && val.size() > 0) {
943 throw new DataValidationErrorException("Validation error!", val);
944 }
945
946
947 return null;
948 }
949
950 @Override
951 @Transactional(readOnly=false,noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})
952 public LoCategoryInfo createLoCategory(String loRepositoryKey,
953 String loCategoryTypeKey, LoCategoryInfo loCategoryInfo)
954 throws DataValidationErrorException, DoesNotExistException,
955 InvalidParameterException, MissingParameterException,
956 OperationFailedException, PermissionDeniedException {
957 checkForMissingParameter(loRepositoryKey, "loRepositoryKey");
958 checkForMissingParameter(loCategoryTypeKey, "loCategoryTypeKey");
959 checkForMissingParameter(loCategoryInfo, "loCategoryInfo");
960
961
962 List<ValidationResultInfo> val = validateLoCategory("SYSTEM", loCategoryInfo);
963
964
965 if (doesLoCategoryExist(loRepositoryKey, loCategoryInfo, null)) {
966 ValidationResultInfo vr = new ValidationResultInfo();
967 vr.setElement("LO Category Name");
968 vr.setError("LO Category already exists");
969 val.add(vr);
970 }
971 if(null != val && val.size() > 0) {
972 for (ValidationResultInfo result : val) {
973 System.err.println("Validation error. Element: " + result.getElement() + ", Value: " + result.getMessage());
974 }
975 throw new DataValidationErrorException("Validation error!", val);
976 }
977
978 LoCategory category = LearningObjectiveServiceAssembler.toLoCategory(loCategoryInfo, loDao);
979 LoCategoryType loCatType = loDao.fetch(LoCategoryType.class, loCategoryTypeKey);
980 category.setLoCategoryType(loCatType);
981 LoRepository loRepository = loDao.fetch(LoRepository.class, loRepositoryKey);
982 category.setLoRepository(loRepository);
983 loDao.create(category);
984 return LearningObjectiveServiceAssembler.toLoCategoryInfo(category);
985 }
986
987 @Override
988 public LoCategoryTypeInfo getLoCategoryType(String loCategoryTypeKey)
989 throws DoesNotExistException, InvalidParameterException,
990 MissingParameterException, OperationFailedException {
991 checkForMissingParameter(loCategoryTypeKey, "loCategoryTypeKey");
992 LoCategoryType loCatType = loDao.fetch(LoCategoryType.class, loCategoryTypeKey);
993 return LearningObjectiveServiceAssembler.toLoCategoryTypeInfo(loCatType);
994 }
995
996 @Override
997 public List<LoCategoryTypeInfo> getLoCategoryTypes()
998 throws OperationFailedException {
999 List<LoCategoryType> categoryTypes = loDao.find(LoCategoryType.class);
1000 return LearningObjectiveServiceAssembler.toLoCategoryTypeInfos(categoryTypes);
1001 }
1002
1003 @Override
1004 public List<LoInfo> getLosByRepository(String loRepositoryKey,
1005 String loTypeKey, String loStateKey)
1006 throws InvalidParameterException, MissingParameterException,
1007 OperationFailedException {
1008 checkForMissingParameter(loRepositoryKey, "loRepositoryKey");
1009 List<Lo> los = loDao.getLosByRepository(loRepositoryKey);
1010 return LearningObjectiveServiceAssembler.toLoInfos(los);
1011 }
1012
1013 @Override
1014 public SearchResult search(SearchRequest searchRequest) throws MissingParameterException {
1015 checkForMissingParameter(searchRequest, "searchRequest");
1016 SearchResult result = searchManager.search(searchRequest, loDao);
1017 if("lo.search.loByCategory".equals(searchRequest.getSearchKey())){
1018
1019
1020 groupCategories(result);
1021
1022
1023 }
1024
1025 return result;
1026 }
1027
1028
1029 private void groupCategories(SearchResult result) {
1030 Map<String,SearchResultCell> idToCellMap = new HashMap<String,SearchResultCell>();
1031 for(Iterator<SearchResultRow> iter = result.getRows().iterator();iter.hasNext();){
1032 SearchResultRow row = iter.next();
1033 SearchResultCell categoryCell = null;
1034 String loId = null;
1035
1036 for(SearchResultCell cell:row.getCells()){
1037 if("lo.resultColumn.categoryName".equals(cell.getKey())){
1038 categoryCell = cell;
1039 break;
1040 }else if("lo.resultColumn.loId".equals(cell.getKey())){
1041 loId = cell.getValue();
1042 }
1043 }
1044
1045 if(loId!=null){
1046 if(idToCellMap.containsKey(loId)){
1047 SearchResultCell cell = idToCellMap.get(loId);
1048 if(cell == null){
1049 cell = new SearchResultCell("lo.resultColumn.categoryName","");
1050 idToCellMap.put(loId, cell);
1051 }
1052 if(categoryCell!=null){
1053 if(cell.getValue()==null||cell.getValue().isEmpty()){
1054 cell.setValue(categoryCell.getValue());
1055 }else if(categoryCell.getValue()!=null && !categoryCell.getValue().isEmpty()){
1056 cell.setValue(cell.getValue()+", "+categoryCell.getValue());
1057 }
1058 }
1059
1060 iter.remove();
1061 } else {
1062
1063 idToCellMap.put(loId, categoryCell);
1064 }
1065 }
1066 }
1067 }
1068
1069 }