1
2
3
4
5 package org.kuali.rice.krms.impl.repository.mock;
6
7 import java.util.ArrayList;
8 import java.util.Date;
9 import java.util.LinkedHashMap;
10 import java.util.LinkedHashSet;
11 import java.util.List;
12 import java.util.Map;
13 import java.util.Set;
14 import org.junit.After;
15 import org.junit.AfterClass;
16 import org.junit.Before;
17 import org.junit.BeforeClass;
18 import org.junit.Test;
19 import static org.junit.Assert.*;
20 import org.kuali.rice.krms.api.repository.RuleManagementService;
21 import org.kuali.rice.krms.api.repository.agenda.AgendaDefinition;
22 import org.kuali.rice.krms.api.repository.agenda.AgendaItemDefinition;
23 import org.kuali.rice.krms.api.repository.context.ContextDefinition;
24 import org.kuali.rice.krms.api.repository.language.NaturalLanguageTemplate;
25 import org.kuali.rice.krms.api.repository.language.NaturalLanguageUsage;
26 import org.kuali.rice.krms.api.repository.proposition.PropositionDefinition;
27 import org.kuali.rice.krms.api.repository.proposition.PropositionParameter;
28 import org.kuali.rice.krms.api.repository.proposition.PropositionParameterType;
29 import org.kuali.rice.krms.api.repository.proposition.PropositionType;
30 import org.kuali.rice.krms.api.repository.rule.RuleDefinition;
31 import org.kuali.rice.krms.api.repository.term.TermDefinition;
32 import org.kuali.rice.krms.api.repository.term.TermParameterDefinition;
33 import org.kuali.rice.krms.api.repository.term.TermRepositoryService;
34 import org.kuali.rice.krms.api.repository.term.TermResolverDefinition;
35 import org.kuali.rice.krms.api.repository.term.TermSpecificationDefinition;
36 import org.kuali.rice.krms.api.repository.type.KrmsTypeDefinition;
37 import org.kuali.rice.krms.api.repository.type.KrmsTypeRepositoryService;
38 import org.kuali.rice.krms.impl.repository.language.SimpleNaturalLanguageTemplater;
39 import org.kuali.student.krms.naturallanguage.util.KsKrmsConstants;
40 import org.kuali.student.r2.common.dto.ContextInfo;
41 import org.kuali.student.r2.core.versionmanagement.dto.VersionDisplayInfo;
42 import org.kuali.student.r2.lum.clu.dto.CluInfo;
43 import org.kuali.student.r2.lum.clu.dto.CluSetInfo;
44 import org.kuali.student.r2.lum.clu.service.CluService;
45 import org.kuali.student.r2.lum.lu.service.impl.CluDataLoader;
46 import org.kuali.student.r2.lum.lu.service.impl.CluServiceMockImpl;
47 import org.kuali.student.r2.lum.util.constants.CluServiceConstants;
48
49
50
51
52
53 public class RuleManagementServiceMockImplTest {
54
55 public RuleManagementServiceMockImplTest() {
56 }
57 private KrmsTypeRepositoryService krmsTypeRepositoryService = null;
58 private RuleManagementService ruleManagementService = null;
59 private TermRepositoryService termRepositoryService = null;
60 private CluService cluService = null;
61
62 @BeforeClass
63 public static void setUpClass() {
64 }
65
66 @AfterClass
67 public static void tearDownClass() {
68 }
69 private ContextInfo contextInfo;
70
71 @Before
72 public void setUp() {
73 contextInfo = new ContextInfo();
74 contextInfo.setPrincipalId("TESTUSER");
75 contextInfo.setCurrentDate(new Date());
76
77 this.krmsTypeRepositoryService = new KrmsTypeRepositoryServiceMockImpl();
78 this.termRepositoryService = new TermRepositoryServiceMockImpl();
79 this.ruleManagementService = new RuleManagementServiceMockImpl();
80 ((RuleManagementServiceMockImpl) this.ruleManagementService).setTemplater(new SimpleNaturalLanguageTemplater());
81 ((RuleManagementServiceMockImpl) this.ruleManagementService).setTermRepositoryService(termRepositoryService);
82 KrmsConfigurationLoader loader = new KrmsConfigurationLoader();
83 loader.setKrmsTypeRepositoryService(this.krmsTypeRepositoryService);
84 loader.setRuleManagementService(this.ruleManagementService);
85 loader.setTermRepositoryService(this.termRepositoryService);
86 loader.loadConfiguration();
87
88 this.cluService = new CluServiceMockImpl();
89 CluDataLoader cluDataLoader = new CluDataLoader();
90 cluDataLoader.setCluService(cluService);
91 cluDataLoader.setContextInfo(contextInfo);
92 cluDataLoader.load();
93
94 }
95
96 @After
97 public void tearDown() {
98 }
99
100 @Test
101 public void testStadardAuthoringUsageCase() {
102 System.out.println("testStadardAuthoringUsageCase");
103
104 List<KrmsTypeDefinition> types = null;
105 Set<String> expected = null;
106 String languageCode = KsKrmsConstants.LANGUAGE_CODE_ENGLISH;
107
108
109 types = this.krmsTypeRepositoryService.findAllContextTypes();
110 expected = new LinkedHashSet<String>();
111 expected.add(KsKrmsConstants.CONTEXT_TYPE_COURSE);
112 expected.add(KsKrmsConstants.CONTEXT_TYPE_PROGRAM);
113 expected.add(KsKrmsConstants.CONTEXT_TYPE_COURSE_OFFERING);
114 this.checkTypeNamesAnyOrder(expected, types);
115
116
117
118
119 System.out.println("Please choose which context of rules that you want to work on:");
120 for (KrmsTypeDefinition type : types) {
121 System.out.println(" " + this.getScreenDescription(type.getId(), languageCode));
122 }
123 System.out.print("==> Choose: ");
124 String selectedId = this.simulateUserChoosingContextTypeId();
125 System.out.println(selectedId);
126 KrmsTypeDefinition selectedContextType = this.krmsTypeRepositoryService.getTypeById(selectedId);
127 String description = this.getScreenDescription(selectedContextType.getId(), languageCode);
128 System.out.println("Editing Rules for Context: " + description);
129
130
131
132 types = this.krmsTypeRepositoryService.findAgendaTypesForContextType(selectedContextType.getId());
133 expected = new LinkedHashSet<String>();
134 expected.add(KsKrmsConstants.AGENDA_TYPE_COURSE_ENROLLMENTELIGIBILITY);
135 expected.add(KsKrmsConstants.AGENDA_TYPE_COURSE_CREDITCONSTRAINTS);
136 this.checkTypeNamesOrdered(expected, types);
137
138 String title = "Please choose which type of rule you want to work on:";
139 int defaultIndex = 0;
140 KrmsTypeDefinition courseEligAgendaType = this.simulateUserChoosingType(title, types, languageCode, defaultIndex);
141
142
143
144 types = this.krmsTypeRepositoryService.findAgendaTypesForAgendaType(courseEligAgendaType.getId());
145 expected = new LinkedHashSet<String>();
146 this.checkTypeNamesOrdered(expected, types);
147
148
149 types = this.krmsTypeRepositoryService.findRuleTypesForAgendaType(courseEligAgendaType.getId());
150 expected = new LinkedHashSet<String>();
151 expected.add(KsKrmsConstants.RULE_TYPE_COURSE_ACADEMICREADINESS_STUDENTELIGIBILITYPREREQ);
152 expected.add(KsKrmsConstants.RULE_TYPE_COURSE_ACADEMICREADINESS_COREQ);
153 expected.add(KsKrmsConstants.RULE_TYPE_COURSE_RECOMMENDEDPREPARATION);
154 expected.add(KsKrmsConstants.RULE_TYPE_COURSE_ACADEMICREADINESS_ANTIREQ);
155 this.checkTypeNamesOrdered(expected, types);
156
157 title = "Please choose which type of rule you want to work on:";
158 defaultIndex = 0;
159 KrmsTypeDefinition eligPrereqRuleType = this.simulateUserChoosingType(title, types, languageCode, defaultIndex);
160
161
162 types = this.krmsTypeRepositoryService.findPropositionTypesForRuleType(eligPrereqRuleType.getId());
163 expected = new LinkedHashSet<String>();
164 expected.add(KsKrmsConstants.PROPOSITION_TYPE_FREEFORM_TEXT);
165 expected.add(KsKrmsConstants.PROPOSITION_TYPE_SUCCESS_COMPL_COURSE);
166 expected.add(KsKrmsConstants.PROPOSITION_TYPE_CUMULATIVE_GPA_MIN);
167 expected.add(KsKrmsConstants.PROPOSITION_TYPE_ADMITTED_TO_PROGRAM);
168 expected.add(KsKrmsConstants.PROPOSITION_TYPE_SUCCESS_CREDIT_COURSESET_COMPLETED_NOF);
169 expected.add(KsKrmsConstants.PROPOSITION_TYPE_SUCCESS_CREDITS_COURSESET_COMPLETED_NOF_ORG);
170 expected.add(KsKrmsConstants.PROPOSITION_TYPE_SUCCESS_COURSE_COURSESET_COMPLETED_ALL);
171 expected.add(KsKrmsConstants.PROPOSITION_TYPE_SUCCESS_COURSE_COURSESET_COMPLETED_NOF);
172 expected.add(KsKrmsConstants.PROPOSITION_TYPE_COURSE_COURSESET_GPA_MIN);
173 expected.add(KsKrmsConstants.PROPOSITION_TYPE_COURSE_COURSESET_GRADE_MIN);
174 expected.add(KsKrmsConstants.PROPOSITION_TYPE_COURSE_COURSESET_NOF_GRADE_MIN);
175 expected.add(KsKrmsConstants.PROPOSITION_TYPE_COURSE_COURSESET_GRADE_MAX);
176 expected.add(KsKrmsConstants.PROPOSITION_TYPE_ADMITTED_TO_PROGRAM_CAMPUS);
177 expected.add(KsKrmsConstants.PROPOSITION_TYPE_NOTADMITTED_TO_PROGRAM);
178 expected.add(KsKrmsConstants.PROPOSITION_TYPE_PERMISSION_INSTRUCTOR_REQUIRED);
179 expected.add(KsKrmsConstants.PROPOSITION_TYPE_PERMISSION_ADMIN_ORG);
180 expected.add(KsKrmsConstants.PROPOSITION_TYPE_COURSE_TEST_SCORE_MIN);
181 expected.add(KsKrmsConstants.PROPOSITION_TYPE_TEST_SCORE_BETWEEN_VALUES);
182 expected.add(KsKrmsConstants.PROPOSITION_TYPE_TEST_SCORE);
183 this.checkTypeNamesOrdered(expected, types);
184
185 title = "Please choose which type of rule you want to work on:";
186 defaultIndex = 7;
187 KrmsTypeDefinition nOfCoursesPropositionType = this.simulateUserChoosingType(title, types, languageCode, defaultIndex);
188 NaturalLanguageTemplate nlTemplate = this.getRuleEditUsageNaturalLanguageTemplate(nOfCoursesPropositionType.getId(), languageCode);
189 assertNotNull(nlTemplate);
190 assertEquals("#if($intValue == 1 && $courseCluSet.getCluList().size() == 1)Must have successfully completed $courseCluSet.getCluSetAsCode()#{else}Must have successfully completed a minimum of $intValue $NLHelper.getProperGrammar($intValue, \"course\") from $courseCluSet.getCluSetAsCode()#end", nlTemplate.getTemplate());
191
192
193
194
195
196
197
198
199
200
201
202
203 types = this.krmsTypeRepositoryService.findPropositionParameterTypesForPropositionType(nOfCoursesPropositionType.getId());
204 expected = new LinkedHashSet<String>();
205 expected.add(KsKrmsConstants.PROPOSITION_PARAMETER_TYPE_TERM_NUMBER_OF_COMPLETED_COURSES);
206 expected.add(KsKrmsConstants.PROPOSITION_PARAMETER_TYPE_CONSTANT_VALUE_N);
207 expected.add(KsKrmsConstants.PROPOSITION_PARAMETER_TYPE_OPERATOR_LESS_THAN_OR_EQUAL_TO);
208 this.checkTypeNamesOrdered(expected, types);
209
210
211 this.displayScreenDescriptions(types, languageCode);
212
213
214 KrmsTypeDefinition nOfCoursesTermType = types.get(0);
215 nlTemplate = this.getRuleEditUsageNaturalLanguageTemplate(nOfCoursesTermType.getId(), languageCode);
216 assertNotNull(nlTemplate);
217 String termName = nlTemplate.getTemplate();
218 assertEquals("NumberOfCompletedCourses", termName);
219 assertNull(this.getComponentId(nlTemplate));
220
221
222 KrmsTypeDefinition constantValueN = types.get(1);
223 nlTemplate = this.getRuleEditUsageNaturalLanguageTemplate(constantValueN.getId(), languageCode);
224 assertNotNull(nlTemplate);
225 String constantValue = nlTemplate.getTemplate();
226 assertEquals("1", constantValue);
227 String constantValueComponentId = this.getComponentId(nlTemplate);
228 assertEquals("KRMS-NumberOfCourses-ConstantValue", constantValueComponentId);
229
230
231 KrmsTypeDefinition lessThanEqualOperatorType = types.get(2);
232 nlTemplate = this.getRuleEditUsageNaturalLanguageTemplate(lessThanEqualOperatorType.getId(), languageCode);
233 assertNotNull(nlTemplate);
234 String operator = nlTemplate.getTemplate();
235 assertEquals("<=", operator);
236 assertNull(this.getComponentId(nlTemplate));
237
238
239 types = this.krmsTypeRepositoryService.findTermParameterTypesForTermPropositionParameterType(nOfCoursesTermType.getId());
240 expected = new LinkedHashSet<String>();
241 expected.add(KsKrmsConstants.TERM_PARAMETER_TYPE_COURSE_CLUSET_ID);
242 this.checkTypeNamesOrdered(expected, types);
243 this.displayScreenDescriptions(types, languageCode);
244 KrmsTypeDefinition cluSetIdType = types.get(0);
245 nlTemplate = this.getRuleEditUsageNaturalLanguageTemplate(cluSetIdType.getId(), languageCode);
246 assertNotNull(nlTemplate);
247 assertEquals("CourseSetId", nlTemplate.getTemplate());
248 String cluSetIdComponentId = this.getComponentId(nlTemplate);
249 assertEquals("KRMS-MultiCourse-Section", cluSetIdComponentId);
250 String componentBuilderClass = this.getComponentBuilderClass(nlTemplate);
251 assertEquals("org.kuali.student.enrollment.class1.krms.builder.MultiCourseComponentBuilder", componentBuilderClass);
252
253
254 TermSpecificationDefinition termSpec =
255 this.termRepositoryService.getTermSpecificationByNameAndNamespace(termName,
256 KsKrmsConstants.NAMESPACE_CODE);
257 assertNotNull(termSpec);
258
259 TermResolverDefinition termResolver =
260 this.termRepositoryService.getTermResolverByNameAndNamespace(termName,
261 KsKrmsConstants.NAMESPACE_CODE);
262 assertNotNull(termResolver);
263
264
265
266
267
268
269
270
271 CluInfo anchorClu = this.getClu("COURSE1");
272
273
274
275 ContextDefinition.Builder bldr = ContextDefinition.Builder.create(KsKrmsConstants.NAMESPACE_CODE, selectedContextType.getName());
276
277
278 bldr.setTypeId(selectedContextType.getId());
279 bldr.setDescription(description);
280 bldr.setActive(true);
281 ContextDefinition context = this.ruleManagementService.findCreateContext(bldr.build());
282 assertNotNull(context);
283 assertEquals(context.getName(), selectedContextType.getName());
284 assertEquals(context.getNamespace(), selectedContextType.getNamespace());
285
286 assertEquals(context.getTypeId(), selectedContextType.getId());
287 assertEquals(context.getDescription(), description);
288
289
290 String id = null;
291 String name = courseEligAgendaType.getName() + " for " + anchorClu.getOfficialIdentifier().getCode() + " " + anchorClu.getId();
292 String typeId = courseEligAgendaType.getId();
293 String contextId = context.getId();
294 AgendaDefinition.Builder agendaBldr = AgendaDefinition.Builder.create(id, name, typeId, contextId);
295 agendaBldr.setActive(false);
296 AgendaDefinition agenda = this.ruleManagementService.createAgenda(agendaBldr.build());
297
298
299 String ruleId = null;
300
301 name = eligPrereqRuleType.getName() + " for " + anchorClu.getOfficialIdentifier().getCode() + " " + anchorClu.getId();
302 String namespace = KsKrmsConstants.NAMESPACE_CODE;
303 typeId = eligPrereqRuleType.getId();
304 String propId = null;
305 RuleDefinition.Builder ruleBldr = RuleDefinition.Builder.create(ruleId, name, namespace, typeId, propId);
306 ruleBldr.setActive(true);
307 RuleDefinition rule = this.ruleManagementService.createRule(ruleBldr.build());
308
309
310 id = null;
311 String agendaId = agenda.getId();
312 AgendaItemDefinition.Builder itemBldr = AgendaItemDefinition.Builder.create(id, agendaId);
313 itemBldr.setRuleId(ruleId);
314 AgendaItemDefinition item = this.ruleManagementService.createAgendaItem(itemBldr.build());
315
316 agendaBldr = AgendaDefinition.Builder.create(agenda);
317 agendaBldr.setActive(true);
318 agendaBldr.setFirstItemId(item.getId());
319 this.ruleManagementService.updateAgenda(agendaBldr.build());
320 agenda = this.ruleManagementService.getAgenda(agenda.getId());
321
322
323 CluInfo courseClu2 = this.getClu("COURSE2");
324 CluInfo courseClu3 = this.getClu("COURSE3");
325 CluInfo courseClu4 = this.getClu("COURSE4");
326 List<String> versionIndIds = this.getVersionIndIds(anchorClu, courseClu2, courseClu3);
327 CluSetInfo cluSet = createCourseSet("Courses 1, 2, & 3", versionIndIds);
328
329 propId = null;
330 String propTypeCode = PropositionType.SIMPLE.getCode();
331 ruleId = rule.getId();
332 typeId = nOfCoursesPropositionType.getId();
333 List<PropositionParameter.Builder> parameters = new ArrayList<PropositionParameter.Builder>();
334
335
336
337 KrmsTypeDefinition type = nOfCoursesTermType;
338 nlTemplate = this.getRuleEditUsageNaturalLanguageTemplate(type.getId(), languageCode);
339 id = null;
340 propId = null;
341 String value = null;
342 String parameterType = serviceName2PropositionParameterType(type.getServiceName()).getCode();
343 Integer sequenceNumber = 1;
344 PropositionParameter.Builder propParamBldr = PropositionParameter.Builder.create(id, propId, value, parameterType, sequenceNumber);
345
346
347 id = null;
348 TermSpecificationDefinition.Builder termSpecBldr = TermSpecificationDefinition.Builder.create(termSpec);
349 List<TermParameterDefinition.Builder> termParameters = new ArrayList<TermParameterDefinition.Builder>();
350 description = termSpec.getName() + " for " + cluSet.getId();
351 TermDefinition.Builder termBldr = TermDefinition.Builder.create(id, termSpecBldr, termParameters);
352 termBldr.setDescription(description);
353
354 id = null;
355 typeId = cluSetIdType.getId();
356 nlTemplate = this.getRuleEditUsageNaturalLanguageTemplate(typeId, languageCode);
357 name = nlTemplate.getTemplate();
358 value = cluSet.getId();
359 TermParameterDefinition.Builder termParamBldr = TermParameterDefinition.Builder.create(id, typeId, name, value);
360 termParameters.add(termParamBldr);
361 propParamBldr.setTermValue(termBldr.build());
362 parameters.add(propParamBldr);
363
364
365 type = constantValueN;
366 nlTemplate = this.getRuleEditUsageNaturalLanguageTemplate(type.getId(), languageCode);
367 id = null;
368 propId = null;
369 value = nlTemplate.getTemplate();
370 parameterType = serviceName2PropositionParameterType(type.getServiceName()).getCode();
371 sequenceNumber = 2;
372 propParamBldr = PropositionParameter.Builder.create(id, propId, value, parameterType, sequenceNumber);
373 parameters.add(propParamBldr);
374
375
376 type = lessThanEqualOperatorType;
377 nlTemplate = this.getRuleEditUsageNaturalLanguageTemplate(type.getId(), languageCode);
378 id = null;
379 propId = null;
380 value = nlTemplate.getTemplate();
381 parameterType = serviceName2PropositionParameterType(type.getServiceName()).getCode();
382 sequenceNumber = 3;
383 propParamBldr = PropositionParameter.Builder.create(id, propId, value, parameterType, sequenceNumber);
384 parameters.add(propParamBldr);
385
386 PropositionDefinition.Builder propBldr = PropositionDefinition.Builder.create(propId, propTypeCode, ruleId, typeId, parameters);
387
388 String enDescription = this.ruleManagementService.translateNaturalLanguageForProposition(getTypeDescriptionUsage ().getId(), propBldr.build(), languageCode);
389 System.out.println ("description=" + enDescription);
390
391
392
393
394
395 PropositionDefinition propositon = this.ruleManagementService.createProposition(propBldr.build());
396
397
398 }
399
400
401
402
403
404
405 private PropositionParameterType serviceName2PropositionParameterType(String serviceTypeName) {
406 if (serviceTypeName.equals(KrmsTypeRepositoryService.TERM_PROPOSITION_PARAMETER_SERVICE_NAME)) {
407 return PropositionParameterType.TERM;
408 }
409 if (serviceTypeName.equals(KrmsTypeRepositoryService.CONSTANT_VALUE_PROPOSITION_PARAMETER_SERVICE_NAME)) {
410 return PropositionParameterType.CONSTANT;
411 }
412 if (serviceTypeName.equals(KrmsTypeRepositoryService.OPERATOR_PROPOSITION_PARAMETER_SERVICE_NAME)) {
413 return PropositionParameterType.OPERATOR;
414 }
415 if (serviceTypeName.equals(KrmsTypeRepositoryService.FUNCTION_PROPOSITION_PARAMETER_SERVICE_NAME)) {
416 return PropositionParameterType.FUNCTION;
417 }
418 throw new IllegalArgumentException(serviceTypeName);
419 }
420
421 public CluSetInfo createCourseSet(String name, List<String> versionIndIds) {
422 CluSetInfo cluSetInfo = new CluSetInfo();
423 cluSetInfo.setTypeKey(CluServiceConstants.CLUSET_TYPE_CREDIT_COURSE);
424 cluSetInfo.setStateKey("Active");
425 cluSetInfo.setName(name);
426 cluSetInfo.setEffectiveDate(new Date());
427 cluSetInfo.setIsReferenceable(Boolean.TRUE);
428 cluSetInfo.setIsReusable(Boolean.FALSE);
429 cluSetInfo.setCluIds(versionIndIds);
430 try {
431 cluSetInfo = this.cluService.createCluSet(cluSetInfo.getTypeKey(), cluSetInfo, contextInfo);
432 } catch (Exception ex) {
433 throw new IllegalArgumentException(ex);
434 }
435 return cluSetInfo;
436 }
437
438 private List<String> getVersionIndIds(CluInfo... clus) {
439 List<String> list = new ArrayList<String>();
440 for (CluInfo clu : clus) {
441 list.add(clu.getVersion().getVersionIndId());
442 }
443 return list;
444 }
445
446 private CluInfo getClu(String id) {
447 try {
448 return this.cluService.getClu(id, contextInfo);
449 } catch (Exception ex) {
450 throw new RuntimeException(ex);
451 }
452 }
453
454 private transient Map<String, NaturalLanguageUsage> name2NaturalLanguageUsageCache = null;
455
456 private NaturalLanguageUsage getNaturalLanguageUsage(String name, String namespace) {
457 if (name2NaturalLanguageUsageCache == null) {
458 name2NaturalLanguageUsageCache = new LinkedHashMap<String, NaturalLanguageUsage>();
459 }
460 String key = namespace + ":" + name;
461 NaturalLanguageUsage usage = name2NaturalLanguageUsageCache.get(key);
462 if (usage != null) {
463 return usage;
464 }
465
466 usage = this.ruleManagementService.getNaturalLanguageUsageByNameAndNamespace(name, namespace);
467 assertNotNull(usage);
468 assertEquals(name, usage.getName());
469 assertEquals(namespace, usage.getNamespace());
470 name2NaturalLanguageUsageCache.put(key, usage);
471 return usage;
472 }
473
474 private NaturalLanguageUsage getTypeDescriptionUsage() {
475 return this.getNaturalLanguageUsage(KsKrmsConstants.KRMS_NL_TYPE_DESCRIPTION, KsKrmsConstants.NAMESPACE_CODE);
476 }
477
478 private NaturalLanguageUsage getRuleEditUsage() {
479 return this.getNaturalLanguageUsage(KsKrmsConstants.KRMS_NL_RULE_EDIT, KsKrmsConstants.NAMESPACE_CODE);
480 }
481
482 private NaturalLanguageUsage getPreviewUsage() {
483 return this.getNaturalLanguageUsage(KsKrmsConstants.KRMS_NL_PREVIEW, KsKrmsConstants.NAMESPACE_CODE);
484 }
485
486 private String simulateUserChoosingContextTypeId() {
487 KrmsTypeDefinition type = this.krmsTypeRepositoryService.getTypeByName(KsKrmsConstants.NAMESPACE_CODE, KsKrmsConstants.CONTEXT_TYPE_COURSE);
488 assertNotNull(type);
489 assertEquals(KsKrmsConstants.CONTEXT_TYPE_COURSE, type.getName());
490 assertEquals(KsKrmsConstants.NAMESPACE_CODE, type.getNamespace());
491 return type.getId();
492 }
493
494 private KrmsTypeDefinition simulateUserChoosingType(String title, List<KrmsTypeDefinition> types, String languageCode, int defaultIndex) {
495 System.out.println(title);
496 this.displayScreenDescriptions(types, languageCode);
497 System.out.print("==> Choose: ");
498 KrmsTypeDefinition selected = types.get(defaultIndex);
499 System.out.println(selected.getName());
500 return selected;
501 }
502
503 private void displayScreenDescriptions(List<KrmsTypeDefinition> types, String languageCode) {
504 for (KrmsTypeDefinition type : types) {
505 System.out.println(this.getScreenDescription(type.getId(), languageCode));
506 }
507 }
508
509 private String getScreenDescription(String typeId, String languageCode) {
510
511 NaturalLanguageTemplate template =
512 this.ruleManagementService.findNaturalLanguageTemplateByLanguageCodeTypeIdAndNluId(languageCode,
513 typeId,
514 this.getTypeDescriptionUsage().getId());
515 if (template == null) {
516 System.out.println("could not find template for " + typeId + " with language " + languageCode + " and for type description usage");
517 }
518 assertNotNull(template);
519 assertEquals(languageCode, template.getLanguageCode());
520 assertEquals(typeId, template.getTypeId());
521 assertEquals(getTypeDescriptionUsage().getId(), template.getNaturalLanguageUsageId());
522 return template.getTemplate();
523 }
524
525 private String getComponentId(NaturalLanguageTemplate template) {
526 return template.getAttributes().get(KsKrmsConstants.ATTRIBUTE_COMPONENT_ID);
527 }
528
529 private String getComponentBuilderClass(NaturalLanguageTemplate template) {
530 return template.getAttributes().get(KsKrmsConstants.ATTRIBUTE_COMPONENT_BUILDER_CLASS);
531 }
532
533 private NaturalLanguageTemplate getRuleEditUsageNaturalLanguageTemplate(String typeId, String languageCode) {
534
535 NaturalLanguageTemplate template =
536 this.ruleManagementService.findNaturalLanguageTemplateByLanguageCodeTypeIdAndNluId(languageCode,
537 typeId,
538 this.getRuleEditUsage().getId());
539 if (template == null) {
540 System.out.println("could not find template for " + typeId + " with language " + languageCode + " and for rule edit usage");
541 }
542 assertNotNull(template);
543 assertEquals(languageCode, template.getLanguageCode());
544 assertEquals(typeId, template.getTypeId());
545 assertEquals(getRuleEditUsage().getId(), template.getNaturalLanguageUsageId());
546 return template;
547 }
548
549 private void checkTypeNamesAnyOrder(Set<String> expected, List<KrmsTypeDefinition> types) {
550 List<String> unexpected = new ArrayList<String>();
551 for (KrmsTypeDefinition type : types) {
552 if (!expected.remove(type.getName())) {
553 unexpected.add(type.getName());
554 }
555 }
556 if (!expected.isEmpty() || !unexpected.isEmpty()) {
557 fail(expected.size() + " types expected that were not found " + expected
558 + " and "
559 + unexpected.size() + " types were found but not expected " + unexpected);
560 }
561 }
562
563 private void checkTypeNamesOrdered(Set<String> expected, List<KrmsTypeDefinition> types) {
564 List<String> expectedOrdered = new ArrayList(expected);
565 this.checkTypeNamesAnyOrder(expected, types);
566 for (int i = 0; i < types.size(); i++) {
567 if (!expectedOrdered.get(i).equals(types.get(i).getName())) {
568 fail("Expected " + i + "th position to have " + expectedOrdered.get(i) + " but found " + types.get(i).getName());
569 }
570 }
571 }
572
573 private CluInfo getCurrentCluInfoByVersionIndId(String id, ContextInfo contextInfo) {
574 VersionDisplayInfo versionDisplayInfo = null;
575 try {
576 versionDisplayInfo = this.cluService.getCurrentVersion(CluServiceConstants.CLU_NAMESPACE_URI, id, contextInfo);
577 } catch (Exception ex) {
578 throw new IllegalArgumentException("Unexpected", ex);
579 }
580 try {
581 return this.cluService.getClu(versionDisplayInfo.getId(), contextInfo);
582 } catch (Exception ex) {
583 throw new IllegalArgumentException("Unexpected", ex);
584 }
585 }
586 }