Source code

001/**
002 * Copyright 2005-2016 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package org.kuali.rice.krms.impl.repository.mock;
017
018import java.util.ArrayList;
019import java.util.Collection;
020import java.util.LinkedHashMap;
021import java.util.LinkedHashSet;
022import java.util.List;
023import java.util.Map;
024import java.util.Set;
025import java.util.UUID;
026import org.kuali.rice.core.api.criteria.QueryByCriteria;
027import org.kuali.rice.core.api.exception.RiceIllegalArgumentException;
028import org.kuali.rice.core.api.exception.RiceIllegalStateException;
029import org.kuali.rice.krms.api.repository.NaturalLanguageTree;
030import org.kuali.rice.krms.api.repository.RuleManagementService;
031import org.kuali.rice.krms.api.repository.action.ActionDefinition;
032import org.kuali.rice.krms.api.repository.agenda.AgendaDefinition;
033import org.kuali.rice.krms.api.repository.agenda.AgendaItemDefinition;
034import org.kuali.rice.krms.api.repository.agenda.AgendaTreeDefinition;
035import org.kuali.rice.krms.api.repository.context.ContextDefinition;
036import org.kuali.rice.krms.api.repository.context.ContextSelectionCriteria;
037import org.kuali.rice.krms.api.repository.language.NaturalLanguageTemplate;
038import org.kuali.rice.krms.api.repository.language.NaturalLanguageTemplaterContract;
039import org.kuali.rice.krms.api.repository.language.NaturalLanguageUsage;
040import org.kuali.rice.krms.api.repository.proposition.PropositionDefinition;
041import org.kuali.rice.krms.api.repository.proposition.PropositionParameter;
042import org.kuali.rice.krms.api.repository.reference.ReferenceObjectBinding;
043import org.kuali.rice.krms.api.repository.rule.RuleDefinition;
044import org.kuali.rice.krms.api.repository.term.TermDefinition;
045import org.kuali.rice.krms.api.repository.term.TermRepositoryService;
046import org.kuali.rice.krms.impl.repository.TranslationUtility;
047import org.kuali.rice.krms.impl.repository.language.SimpleNaturalLanguageTemplater;
048
049public class RuleManagementServiceMockImpl implements RuleManagementService {
050
051
052    // cache variable 
053    // The LinkedHashMap is just so the values come back in a predictable order
054
055    private Map<String, ReferenceObjectBinding> referenceObjectBindingMap = new LinkedHashMap<String, ReferenceObjectBinding>();
056    private Map<String, ContextDefinition> contextMap = new LinkedHashMap<String, ContextDefinition>();
057    private Map<String, AgendaDefinition> agendaMap = new LinkedHashMap<String, AgendaDefinition>();
058    private Map<String, AgendaItemDefinition> agendaItemMap = new LinkedHashMap<String, AgendaItemDefinition>();
059    private Map<String, RuleDefinition> ruleMap = new LinkedHashMap<String, RuleDefinition>();
060    private Map<String, ActionDefinition> actionMap = new LinkedHashMap<String, ActionDefinition>();
061    private Map<String, PropositionDefinition> propositionMap = new LinkedHashMap<String, PropositionDefinition>();
062    private Map<String, NaturalLanguageUsage> naturalLanguageUsageMap = new LinkedHashMap<String, NaturalLanguageUsage>();
063    private Map<String, NaturalLanguageTemplate> naturalLanguageTemplateMap = new LinkedHashMap<String, NaturalLanguageTemplate>();
064
065    // supporting services used in this service impl
066    private NaturalLanguageTemplaterContract templater = new SimpleNaturalLanguageTemplater();
067    private TermRepositoryService termRepositoryService;
068
069    public NaturalLanguageTemplaterContract getTemplater() {
070        return templater;
071    }
072
073    public void setTemplater(NaturalLanguageTemplaterContract templater) {
074        this.templater = templater;
075    }
076
077    public TermRepositoryService getTermRepositoryService() {
078        return termRepositoryService;
079    }
080
081    public void setTermRepositoryService(TermRepositoryService termRepositoryService) {
082        this.termRepositoryService = termRepositoryService;
083    }
084
085
086
087    public void clear() {
088        this.referenceObjectBindingMap.clear();
089        this.contextMap.clear();
090        this.agendaMap.clear();
091        this.agendaItemMap.clear();
092        this.ruleMap.clear();
093        this.actionMap.clear();
094        this.propositionMap.clear();
095        this.naturalLanguageUsageMap.clear();
096        this.naturalLanguageTemplateMap.clear();
097    }
098
099    @Override
100    public ReferenceObjectBinding createReferenceObjectBinding(ReferenceObjectBinding referenceObjectDefinition)
101            throws RiceIllegalArgumentException {
102        // CREATE
103        ReferenceObjectBinding orig = this.getReferenceObjectBinding(referenceObjectDefinition.getId());
104        if (orig != null) {
105            throw new RiceIllegalArgumentException(referenceObjectDefinition.getId());
106        }
107        ReferenceObjectBinding.Builder copy = ReferenceObjectBinding.Builder.create(referenceObjectDefinition);
108        if (copy.getId() == null) {
109            copy.setId(UUID.randomUUID().toString());
110        }
111        referenceObjectDefinition = copy.build();
112        referenceObjectBindingMap.put(referenceObjectDefinition.getId(), referenceObjectDefinition);
113        return referenceObjectDefinition;
114    }
115
116    @Override
117    public ReferenceObjectBinding getReferenceObjectBinding(String id)
118            throws RiceIllegalArgumentException {
119        // GET_BY_ID
120        if (!this.referenceObjectBindingMap.containsKey(id)) {
121            throw new RiceIllegalArgumentException(id);
122        }
123        return this.referenceObjectBindingMap.get(id);
124    }
125
126    @Override
127    public List<ReferenceObjectBinding> getReferenceObjectBindings(List<String> ids)
128            throws RiceIllegalArgumentException {
129        // GET_BY_IDS
130        List<ReferenceObjectBinding> list = new ArrayList<ReferenceObjectBinding>();
131        for (String id : ids) {
132            list.add(this.getReferenceObjectBinding(id));
133        }
134        return list;
135    }
136
137    @Override
138    public List<ReferenceObjectBinding> findReferenceObjectBindingsByReferenceDiscriminatorType(String referenceObjectReferenceDiscriminatorType)
139            throws RiceIllegalArgumentException {
140        List<ReferenceObjectBinding> list = new ArrayList<ReferenceObjectBinding>();
141        for (ReferenceObjectBinding info : this.referenceObjectBindingMap.values()) {
142            if (info.getReferenceDiscriminatorType().equals(referenceObjectReferenceDiscriminatorType)) {
143                list.add(info);
144            }
145        }
146        return list;
147    }
148
149    @Override
150    public List<ReferenceObjectBinding> findReferenceObjectBindingsByReferenceObject(String referenceObjectReferenceDiscriminatorType, String referenceObjectId) throws RiceIllegalArgumentException {
151
152        List<ReferenceObjectBinding> list = new ArrayList<ReferenceObjectBinding>();
153        for (ReferenceObjectBinding info : this.referenceObjectBindingMap.values()) {
154            if (info.getReferenceDiscriminatorType().equals(referenceObjectReferenceDiscriminatorType)) {
155                list.add(info);
156            }
157        }
158        return list;
159    }
160
161    @Override
162    public List<ReferenceObjectBinding> findReferenceObjectBindingsByKrmsDiscriminatorType(String referenceObjectKrmsDiscriminatorType)
163            throws RiceIllegalArgumentException {
164        List<ReferenceObjectBinding> list = new ArrayList<ReferenceObjectBinding>();
165        for (ReferenceObjectBinding info : this.referenceObjectBindingMap.values()) {
166            if (info.getKrmsDiscriminatorType().equals(referenceObjectKrmsDiscriminatorType)) {
167                list.add(info);
168            }
169        }
170        return list;
171    }
172
173    @Override
174    public List<ReferenceObjectBinding> findReferenceObjectBindingsByKrmsObject(String krmsObjectId)
175            throws RiceIllegalArgumentException {
176        List<ReferenceObjectBinding> list = new ArrayList<ReferenceObjectBinding>();
177        for (ReferenceObjectBinding info : this.referenceObjectBindingMap.values()) {
178            if (info.getKrmsObjectId().equals(krmsObjectId)) {
179                list.add(info);
180            }
181        }
182        return list;
183    }
184
185    @Override
186    public void updateReferenceObjectBinding(ReferenceObjectBinding referenceObjectBindingDefinition)
187            throws RiceIllegalArgumentException {
188        // UPDATE
189        ReferenceObjectBinding.Builder copy = ReferenceObjectBinding.Builder.create(referenceObjectBindingDefinition);
190        ReferenceObjectBinding old = this.getReferenceObjectBinding(referenceObjectBindingDefinition.getId());
191        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
192            throw new RiceIllegalStateException("" + old.getVersionNumber());
193        }
194        copy.setVersionNumber(copy.getVersionNumber() + 1);
195        referenceObjectBindingDefinition = copy.build();
196        this.referenceObjectBindingMap.put(referenceObjectBindingDefinition.getId(), referenceObjectBindingDefinition);
197        return;
198    }
199
200    @Override
201    public void deleteReferenceObjectBinding(String id)
202            throws RiceIllegalArgumentException {
203        // DELETE
204        if (this.referenceObjectBindingMap.remove(id) == null) {
205            throw new RiceIllegalArgumentException(id);
206        }
207        return;
208    }
209
210    @Override
211    public List<String> findReferenceObjectBindingIds(QueryByCriteria queryByCriteria)
212            throws RiceIllegalArgumentException {
213        CriteriaMatcherInMemory<ReferenceObjectBinding> instance = new CriteriaMatcherInMemory<ReferenceObjectBinding>();
214        instance.setCriteria(queryByCriteria);
215        Collection<ReferenceObjectBinding> selected = instance.findMatching(this.referenceObjectBindingMap.values());
216        List<String> list = new ArrayList<String>();
217        for (ReferenceObjectBinding sel : selected) {
218            list.add(sel.getId());
219        }
220        return list;
221    }
222
223    @Override
224    public AgendaDefinition createAgenda(AgendaDefinition agendaDefinition)
225            throws RiceIllegalArgumentException {
226        if (agendaDefinition.getId() != null) {
227            AgendaDefinition orig = this.getAgenda(agendaDefinition.getId());
228            if (orig != null) {
229                throw new RiceIllegalArgumentException(agendaDefinition.getId() + "." + agendaDefinition.getName());
230            }
231        }
232        AgendaDefinition existing = this.getAgendaByNameAndContextId (agendaDefinition.getName(), agendaDefinition.getContextId());
233        if (existing == null) {
234            throw new RiceIllegalArgumentException (agendaDefinition.getName() + " " + agendaDefinition.getContextId() + " already exists");
235        }
236        AgendaDefinition.Builder copy = AgendaDefinition.Builder.create(agendaDefinition);
237        if (copy.getId() == null) {
238            copy.setId(UUID.randomUUID().toString());
239        }
240        copy.setVersionNumber(0l);
241        agendaDefinition = copy.build();
242        agendaMap.put(agendaDefinition.getId(), agendaDefinition);
243        return agendaDefinition;
244    }
245
246    @Override
247    public AgendaDefinition findCreateAgenda(AgendaDefinition agendaDefinition) throws RiceIllegalArgumentException {
248        AgendaDefinition agenda = this.getAgendaByNameAndContextId(agendaDefinition.getName(), agendaDefinition.getContextId());
249        if (agenda != null) {
250            return agenda;
251        }
252        return this.createAgenda(agendaDefinition);
253    }
254
255    @Override
256    public AgendaDefinition getAgendaByNameAndContextId(String name, String contextId) {
257        for (AgendaDefinition info : this.agendaMap.values()) {
258            if (info.getContextId().equals(contextId)) {
259                if (info.getName().equals(name)) {
260                    return info;
261                }
262            }
263        }
264        return null;
265    }
266
267
268
269    @Override
270    public AgendaDefinition getAgenda(String id)
271            throws RiceIllegalArgumentException {
272        // GET_BY_ID
273        if (!this.agendaMap.containsKey(id)) {
274            throw new RiceIllegalArgumentException(id);
275        }
276        return this.agendaMap.get(id);
277    }
278
279    @Override
280    public List<AgendaDefinition> getAgendasByType(String typeId)
281            throws RiceIllegalArgumentException {
282        // GET_IDS_BY_TYPE
283        List<AgendaDefinition> list = new ArrayList<AgendaDefinition>();
284        for (AgendaDefinition info : agendaMap.values()) {
285            if (typeId.equals(info.getTypeId())) {
286                list.add(info);
287            }
288        }
289        return list;
290    }
291
292    @Override
293    public List<AgendaDefinition> getAgendasByContext(String contextId)
294            throws RiceIllegalArgumentException {
295        List<AgendaDefinition> list = new ArrayList<AgendaDefinition>();
296        for (AgendaDefinition info : this.agendaMap.values()) {
297            if (info.getContextId().equals(contextId)) {
298                list.add(info);
299            }
300        }
301        return list;
302    }
303
304    @Override
305    public List<AgendaDefinition> getAgendasByTypeAndContext(String typeId, String contextId)
306            throws RiceIllegalArgumentException {
307        List<AgendaDefinition> list = new ArrayList<AgendaDefinition>();
308        for (AgendaDefinition info : this.agendaMap.values()) {
309            if (info.getContextId().equals(contextId)) {
310                if (info.getTypeId().equals(typeId)) {
311                    list.add(info);
312                }
313            }
314        }
315        return list;
316    }
317
318    @Override
319    public void updateAgenda(AgendaDefinition agendaDefinition)
320            throws RiceIllegalArgumentException {
321        // UPDATE
322        AgendaDefinition.Builder copy = AgendaDefinition.Builder.create(agendaDefinition);
323        AgendaDefinition old = this.getAgenda(agendaDefinition.getId());
324        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
325            throw new RiceIllegalStateException("" + old.getVersionNumber());
326        }
327        copy.setVersionNumber(copy.getVersionNumber() + 1);
328        agendaDefinition = copy.build();
329        this.agendaMap.put(agendaDefinition.getId(), agendaDefinition);
330        return;
331    }
332
333    @Override
334    public void deleteAgenda(String id)
335            throws RiceIllegalArgumentException {
336        // DELETE
337        if (this.agendaMap.remove(id) == null) {
338            throw new RiceIllegalArgumentException(id);
339        }
340        return;
341    }
342
343    @Override
344    public AgendaItemDefinition createAgendaItem(AgendaItemDefinition agendaItemDefinition)
345            throws RiceIllegalArgumentException {
346        // CREATE
347        AgendaItemDefinition.Builder copy = AgendaItemDefinition.Builder.create(agendaItemDefinition);
348        if (copy.getId() == null) {
349            copy.setId(UUID.randomUUID().toString());
350        }
351        agendaItemDefinition = copy.build();
352        agendaItemMap.put(agendaItemDefinition.getId(), agendaItemDefinition);
353        return agendaItemDefinition;
354    }
355
356    @Override
357    public AgendaItemDefinition getAgendaItem(String id)
358            throws RiceIllegalArgumentException {
359        // GET_BY_ID
360        if (!this.agendaItemMap.containsKey(id)) {
361            throw new RiceIllegalArgumentException(id);
362        }
363        return this.agendaItemMap.get(id);
364    }
365
366    @Override
367    public List<AgendaItemDefinition> getAgendaItemsByType(String typeId)
368            throws RiceIllegalArgumentException {
369        // GET_IDS_BY_TYPE
370        List<AgendaDefinition> agendas = this.getAgendasByType(typeId);
371        List<AgendaItemDefinition> list = new ArrayList<AgendaItemDefinition>();
372        for (AgendaDefinition agenda : agendas) {
373            for (AgendaItemDefinition info : agendaItemMap.values()) {
374                if (agenda.getId().equals(info.getAgendaId())) {
375                    list.add(info);
376                }
377            }
378        }
379        return list;
380    }
381
382    @Override
383    public List<AgendaItemDefinition> getAgendaItemsByContext(String contextId)
384            throws RiceIllegalArgumentException {
385        List<AgendaDefinition> agendas = this.getAgendasByContext(contextId);
386        List<AgendaItemDefinition> list = new ArrayList<AgendaItemDefinition>();
387        for (AgendaDefinition agenda : agendas) {
388            for (AgendaItemDefinition info : agendaItemMap.values()) {
389                if (agenda.getId().equals(info.getAgendaId())) {
390                    list.add(info);
391                }
392            }
393        }
394        return list;
395    }
396
397    @Override
398    public List<AgendaItemDefinition> getAgendaItemsByTypeAndContext(String typeId, String contextId)
399            throws RiceIllegalArgumentException {
400        List<AgendaDefinition> agendas = this.getAgendasByContext(contextId);
401        List<AgendaItemDefinition> list = new ArrayList<AgendaItemDefinition>();
402        for (AgendaDefinition agenda : agendas) {
403            if (agenda.getTypeId().equals(typeId)) {
404                for (AgendaItemDefinition info : agendaItemMap.values()) {
405                    if (agenda.getId().equals(info.getAgendaId())) {
406                        list.add(info);
407                    }
408                }
409            }
410        }
411        return list;
412    }
413
414    @Override
415    public void updateAgendaItem(AgendaItemDefinition agendaItemDefinition)
416            throws RiceIllegalArgumentException {
417        // UPDATE
418        AgendaItemDefinition.Builder copy = AgendaItemDefinition.Builder.create(agendaItemDefinition);
419        AgendaItemDefinition old = this.getAgendaItem(agendaItemDefinition.getId());
420        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
421            throw new RiceIllegalStateException("" + old.getVersionNumber());
422        }
423        copy.setVersionNumber(copy.getVersionNumber() + 1);
424        agendaItemDefinition = copy.build();
425        this.agendaItemMap.put(agendaItemDefinition.getId(), agendaItemDefinition);
426        return;
427    }
428
429    @Override
430    public void deleteAgendaItem(String id)
431            throws RiceIllegalArgumentException {
432        // DELETE
433        if (this.agendaItemMap.remove(id) == null) {
434            throw new RiceIllegalArgumentException(id);
435        }
436        return;
437    }
438
439    @Override
440    public RuleDefinition getRuleByNameAndNamespace(String name, String namespace) {
441        for (RuleDefinition rule : this.ruleMap.values()) {
442            if (rule.getName().equals(name)) {
443                if (rule.getNamespace().equals(namespace)) {
444                    return rule;
445                }
446            }
447        }
448        return null;
449    }
450
451
452
453    @Override
454    public RuleDefinition createRule(RuleDefinition ruleDefinition)
455            throws RiceIllegalArgumentException {
456        // CREATE
457        if (ruleDefinition.getId() != null) {
458            RuleDefinition orig = this.getRule(ruleDefinition.getId());
459            if (orig != null) {
460                throw new RiceIllegalArgumentException(ruleDefinition.getId());
461            }
462        }
463        RuleDefinition.Builder copy = RuleDefinition.Builder.create(ruleDefinition);
464        if (copy.getId() == null) {
465            copy.setId(UUID.randomUUID().toString());
466        }
467        ruleDefinition = copy.build();
468        ruleMap.put(ruleDefinition.getId(), ruleDefinition);
469        return ruleDefinition;
470    }
471
472    @Override
473    public RuleDefinition getRule(String ruleId) {
474        // GET_BY_ID
475        if (!this.ruleMap.containsKey(ruleId)) {
476            throw new RiceIllegalArgumentException(ruleId);
477        }
478        return this.ruleMap.get(ruleId);
479    }
480
481    @Override
482    public List<RuleDefinition> getRules(List<String> ruleIds) {
483        List<RuleDefinition> list = new ArrayList<RuleDefinition>();
484        for (String id : ruleIds) {
485            list.add(this.getRule(id));
486        }
487        return list;
488    }
489
490    @Override
491    public void updateRule(RuleDefinition ruleDefinition)
492            throws RiceIllegalArgumentException {
493        // UPDATE
494        RuleDefinition.Builder copy = RuleDefinition.Builder.create(ruleDefinition);
495        RuleDefinition old = this.getRule(ruleDefinition.getId());
496        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
497            throw new RiceIllegalStateException("" + old.getVersionNumber());
498        }
499        copy.setVersionNumber(copy.getVersionNumber() + 1);
500        ruleDefinition = copy.build();
501        this.ruleMap.put(ruleDefinition.getId(), ruleDefinition);
502        return;
503    }
504
505    @Override
506    public void deleteRule(String id)
507            throws RiceIllegalArgumentException {
508        // DELETE
509        if (this.ruleMap.remove(id) == null) {
510            throw new RiceIllegalArgumentException(id);
511        }
512        return;
513    }
514
515    @Override
516    public ActionDefinition createAction(ActionDefinition actionDefinition)
517            throws RiceIllegalArgumentException {
518        // CREATE
519        ActionDefinition orig = this.getAction(actionDefinition.getId());
520        if (orig != null) {
521            throw new RiceIllegalArgumentException(actionDefinition.getId());
522        }
523        ActionDefinition.Builder copy = ActionDefinition.Builder.create(actionDefinition);
524        if (copy.getId() == null) {
525            copy.setId(UUID.randomUUID().toString());
526        }
527        actionDefinition = copy.build();
528        actionMap.put(actionDefinition.getId(), actionDefinition);
529        return actionDefinition;
530    }
531
532    @Override
533    public ActionDefinition getAction(String actionId) {
534        // GET_BY_ID
535        if (!this.actionMap.containsKey(actionId)) {
536            throw new RiceIllegalArgumentException(actionId);
537        }
538        return this.actionMap.get(actionId);
539    }
540
541    @Override
542    public List<ActionDefinition> getActions(List<String> actionIds) {
543        List<ActionDefinition> list = new ArrayList<ActionDefinition>();
544        for (String id : actionIds) {
545            list.add(this.getAction(id));
546        }
547        return list;
548    }
549
550    @Override
551    public void updateAction(ActionDefinition actionDefinition)
552            throws RiceIllegalArgumentException {
553        // UPDATE
554        ActionDefinition.Builder copy = ActionDefinition.Builder.create(actionDefinition);
555        ActionDefinition old = this.getAction(actionDefinition.getId());
556        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
557            throw new RiceIllegalStateException("" + old.getVersionNumber());
558        }
559        copy.setVersionNumber(copy.getVersionNumber() + 1);
560        actionDefinition = copy.build();
561        this.actionMap.put(actionDefinition.getId(), actionDefinition);
562        return;
563    }
564
565    @Override
566    public void deleteAction(String id)
567            throws RiceIllegalArgumentException {
568        // DELETE
569        if (this.actionMap.remove(id) == null) {
570            throw new RiceIllegalArgumentException(id);
571        }
572        return;
573    }
574
575    @Override
576    public PropositionDefinition createProposition(PropositionDefinition propositionDefinition)
577            throws RiceIllegalArgumentException {
578        // CREATE
579        if (propositionDefinition.getId() != null) {
580            PropositionDefinition orig = this.getProposition(propositionDefinition.getId());
581            if (orig != null) {
582                throw new RiceIllegalArgumentException(propositionDefinition.getId());
583            }
584        }
585        PropositionDefinition.Builder copy = PropositionDefinition.Builder.create(propositionDefinition);
586        if (copy.getId() == null) {
587            copy.setId(UUID.randomUUID().toString());
588        }
589        for (PropositionParameter.Builder paramBldr : copy.getParameters()) {
590            if (paramBldr.getId() == null) {
591                paramBldr.setId(UUID.randomUUID().toString());
592            }
593            if (paramBldr.getPropId() == null) {
594                paramBldr.setPropId(copy.getId());
595            }
596            if (paramBldr.getTermValue() != null) {
597                TermDefinition termValue = paramBldr.getTermValue();
598                // no id means it does not exist yet
599                if (termValue.getId() == null) {
600                    termValue = this.termRepositoryService.createTerm(termValue);
601                    paramBldr.setTermValue(termValue);
602                }
603                if (paramBldr.getValue() == null) {
604                    paramBldr.setValue(termValue.getId());
605                }
606            }
607        }
608        propositionDefinition = copy.build();
609        propositionMap.put(propositionDefinition.getId(), propositionDefinition);
610        return propositionDefinition;
611    }
612
613    @Override
614    public PropositionDefinition getProposition(String id)
615            throws RiceIllegalArgumentException {
616        // GET_BY_ID
617        if (!this.propositionMap.containsKey(id)) {
618            throw new RiceIllegalArgumentException(id);
619        }
620        return this.propositionMap.get(id);
621    }
622
623    @Override
624    public Set<PropositionDefinition> getPropositionsByType(String typeId)
625            throws RiceIllegalArgumentException {
626        // GET_IDS_BY_TYPE
627        Set<PropositionDefinition> set = new LinkedHashSet<PropositionDefinition>();
628        for (PropositionDefinition info : propositionMap.values()) {
629            if (typeId.equals(info.getTypeId())) {
630                set.add(info);
631            }
632        }
633        return set;
634    }
635
636    @Override
637    public Set<PropositionDefinition> getPropositionsByRule(String ruleId)
638            throws RiceIllegalArgumentException {
639        Set<PropositionDefinition> set = new LinkedHashSet<PropositionDefinition>();
640        for (PropositionDefinition info : this.propositionMap.values()) {
641            if (info.getRuleId().equals(ruleId)) {
642                set.add(info);
643            }
644        }
645        return set;
646    }
647
648    @Override
649    public void updateProposition(PropositionDefinition propositionDefinition)
650            throws RiceIllegalArgumentException {
651        if (this.propositionMap.containsKey(propositionDefinition.getId())) {
652            throw new RiceIllegalArgumentException (propositionDefinition.getId() + "not found");
653        }
654        // UPDATE
655        PropositionDefinition.Builder copy = PropositionDefinition.Builder.create(propositionDefinition);
656        PropositionDefinition old = this.getProposition(propositionDefinition.getId());
657        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
658            throw new RiceIllegalStateException("" + old.getVersionNumber());
659        }
660        copy.setVersionNumber(copy.getVersionNumber() + 1);
661        for (PropositionParameter.Builder paramBldr : copy.getParameters()) {
662            if (paramBldr.getId() == null) {
663                paramBldr.setId(UUID.randomUUID().toString());
664            }
665            if (paramBldr.getPropId() == null) {
666                paramBldr.setPropId(copy.getId());
667            }
668            if (paramBldr.getTermValue() != null) {
669                TermDefinition termValue = paramBldr.getTermValue();
670                // no id means it does not exist yet
671                if (termValue.getId() == null) {
672                    termValue = this.termRepositoryService.createTerm(termValue);
673                    paramBldr.setTermValue(termValue);
674                }
675                if (paramBldr.getValue() == null) {
676                    paramBldr.setValue(termValue.getId());
677                }
678            }
679        }
680        propositionDefinition = copy.build();
681        this.propositionMap.put(propositionDefinition.getId(), propositionDefinition);
682        return;
683    }
684
685    @Override
686    public void deleteProposition(String id)
687            throws RiceIllegalArgumentException {
688        // DELETE
689        if (this.propositionMap.remove(id) == null) {
690            throw new RiceIllegalArgumentException(id);
691        }
692        return;
693    }
694
695    @Override
696    public NaturalLanguageUsage createNaturalLanguageUsage(NaturalLanguageUsage naturalLanguageUsage)
697            throws RiceIllegalArgumentException {
698        // CREATE
699        try {
700            NaturalLanguageUsage orig = this.getNaturalLanguageUsage(naturalLanguageUsage.getId());
701            if (orig != null) {
702                throw new RiceIllegalArgumentException(naturalLanguageUsage.getId());
703            }
704        } catch (RiceIllegalArgumentException ex) {
705            //            same as returning null
706        }
707        NaturalLanguageUsage.Builder copy = NaturalLanguageUsage.Builder.create(naturalLanguageUsage);
708        if (copy.getId() == null) {
709            copy.setId(UUID.randomUUID().toString());
710        }
711        naturalLanguageUsage = copy.build();
712        naturalLanguageUsageMap.put(naturalLanguageUsage.getId(), naturalLanguageUsage);
713        return naturalLanguageUsage;
714    }
715
716    @Override
717    public NaturalLanguageUsage getNaturalLanguageUsage(String id)
718            throws RiceIllegalArgumentException {
719        // GET_BY_ID
720        if (!this.naturalLanguageUsageMap.containsKey(id)) {
721            throw new RiceIllegalArgumentException(id);
722        }
723        return this.naturalLanguageUsageMap.get(id);
724    }
725
726    @Override
727    public void updateNaturalLanguageUsage(NaturalLanguageUsage naturalLanguageUsage)
728            throws RiceIllegalArgumentException {
729        // UPDATE
730        NaturalLanguageUsage.Builder copy = NaturalLanguageUsage.Builder.create(naturalLanguageUsage);
731        NaturalLanguageUsage old = this.getNaturalLanguageUsage(naturalLanguageUsage.getId());
732        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
733            throw new RiceIllegalStateException("" + old.getVersionNumber());
734        }
735        copy.setVersionNumber(copy.getVersionNumber() + 1);
736        naturalLanguageUsage = copy.build();
737        this.naturalLanguageUsageMap.put(naturalLanguageUsage.getId(), naturalLanguageUsage);
738        return;
739    }
740
741    @Override
742    public void deleteNaturalLanguageUsage(String naturalLanguageUsageId)
743            throws RiceIllegalArgumentException {
744        // DELETE
745        if (this.naturalLanguageUsageMap.remove(naturalLanguageUsageId) == null) {
746            throw new RiceIllegalArgumentException(naturalLanguageUsageId);
747        }
748        return;
749    }
750
751    ////
752    //// natural language translations
753    ////
754    @Override
755    public String translateNaturalLanguageForObject(String naturalLanguageUsageId,
756            String typeId,
757            String krmsObjectId,
758            String languageCode)
759            throws RiceIllegalArgumentException {
760        TranslationUtility util = new TranslationUtility(this, this.termRepositoryService, this.templater);
761        return util.translateNaturalLanguageForObject(naturalLanguageUsageId, typeId, krmsObjectId, languageCode);
762    }
763
764    @Override
765    public String translateNaturalLanguageForProposition(String naturalLanguageUsageId,
766            PropositionDefinition proposition, String languageCode)
767            throws RiceIllegalArgumentException {
768        TranslationUtility util = new TranslationUtility(this, this.termRepositoryService, this.templater);
769        return util.translateNaturalLanguageForProposition(naturalLanguageUsageId, proposition, languageCode);
770    }
771
772    @Override
773    public NaturalLanguageTree translateNaturalLanguageTreeForProposition(String naturalLanguageUsageId,
774            PropositionDefinition propositionDefinintion,
775            String languageCode) throws RiceIllegalArgumentException {
776        TranslationUtility util = new TranslationUtility(this, this.termRepositoryService, this.templater);
777        return util.translateNaturalLanguageTreeForProposition(naturalLanguageUsageId, propositionDefinintion, languageCode);
778    }
779
780    @Override
781    public List<NaturalLanguageUsage> getNaturalLanguageUsagesByNamespace(String namespace) throws RiceIllegalArgumentException {
782        List<NaturalLanguageUsage> list = new ArrayList<NaturalLanguageUsage>();
783        for (NaturalLanguageUsage info : naturalLanguageUsageMap.values()) {
784            if (namespace.equals(info.getNamespace())) {
785                list.add(info);
786            }
787        }
788        return list;
789    }
790
791    @Override
792    public NaturalLanguageUsage getNaturalLanguageUsageByNameAndNamespace(String name, String namespace) throws RiceIllegalArgumentException {
793        for (NaturalLanguageUsage info : naturalLanguageUsageMap.values()) {
794            if (namespace.equals(info.getNamespace())) {
795                if (name.equals(info.getName())) {
796                    return info;
797                }
798            }
799        }
800        return null;
801    }
802
803    @Override
804    public ContextDefinition selectContext(ContextSelectionCriteria contextSelectionCriteria) throws RiceIllegalArgumentException {
805        throw new UnsupportedOperationException("Not supported yet.");
806    }
807
808    @Override
809    public AgendaTreeDefinition getAgendaTree(String agendaId) throws RiceIllegalArgumentException {
810        throw new UnsupportedOperationException("Not supported yet.");
811    }
812
813    @Override
814    public List<AgendaTreeDefinition> getAgendaTrees(List<String> agendaIds) throws RiceIllegalArgumentException {
815        throw new UnsupportedOperationException("Not supported yet.");
816    }
817
818    @Override
819    public ContextDefinition createContext(ContextDefinition contextDefinition)
820            throws RiceIllegalArgumentException {
821        // CREATE
822        ContextDefinition orig = this.getContextByNameAndNamespace(contextDefinition.getName(), contextDefinition.getNamespace());
823        if (orig != null) {
824            throw new RiceIllegalArgumentException(contextDefinition.getNamespace() + "." + contextDefinition.getName());
825        }
826        ContextDefinition.Builder copy = ContextDefinition.Builder.create(contextDefinition);
827        if (copy.getId() == null) {
828            copy.setId(UUID.randomUUID().toString());
829        }
830        contextDefinition = copy.build();
831        contextMap.put(contextDefinition.getId(), contextDefinition);
832        return contextDefinition;
833    }
834
835    @Override
836    public ContextDefinition findCreateContext(ContextDefinition contextDefinition) throws RiceIllegalArgumentException {
837        ContextDefinition orig = this.getContextByNameAndNamespace(contextDefinition.getName(), contextDefinition.getNamespace());
838        if (orig != null) {
839            return orig;
840        }
841        return this.createContext(contextDefinition);
842    }
843
844    @Override
845    public void updateContext(ContextDefinition contextDefinition)
846            throws RiceIllegalArgumentException {
847        // UPDATE
848        ContextDefinition.Builder copy = ContextDefinition.Builder.create(contextDefinition);
849        ContextDefinition old = this.getContext(contextDefinition.getId());
850        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
851            throw new RiceIllegalStateException("" + old.getVersionNumber());
852        }
853        copy.setVersionNumber(copy.getVersionNumber() + 1);
854        contextDefinition = copy.build();
855        this.contextMap.put(contextDefinition.getId(), contextDefinition);
856        return;
857    }
858
859    @Override
860    public void deleteContext(String id)
861            throws RiceIllegalArgumentException {
862        // DELETE
863        if (this.contextMap.remove(id) == null) {
864            throw new RiceIllegalArgumentException(id);
865        }
866        return;
867    }
868
869    @Override
870    public ContextDefinition getContext(String id)
871            throws RiceIllegalArgumentException {
872        // GET_BY_ID
873        if (!this.contextMap.containsKey(id)) {
874            throw new RiceIllegalArgumentException(id);
875        }
876        return this.contextMap.get(id);
877    }
878
879    @Override
880    public ContextDefinition getContextByNameAndNamespace(String name, String namespace)
881            throws RiceIllegalArgumentException {
882        if (name == null || name.trim().isEmpty()) {
883            throw new RiceIllegalArgumentException("name is null or empty");
884        }
885        if (namespace == null || namespace.trim().isEmpty()) {
886            throw new RiceIllegalArgumentException("name is null or empty");
887        }
888        // RICE_GET_BY_NAMESPACE_AND_NAME
889        for (ContextDefinition info : contextMap.values()) {
890            if (name.equals(info.getName())) {
891                if (namespace.equals(info.getNamespace())) {
892                    return ContextDefinition.Builder.create(info).build();
893                }
894            }
895        }
896        return null;
897    }
898
899    @Override
900    public NaturalLanguageTemplate createNaturalLanguageTemplate(NaturalLanguageTemplate naturalLanguageTemplate)
901            throws RiceIllegalArgumentException {
902        // CREATE
903        try {
904            NaturalLanguageTemplate orig = this.getNaturalLanguageTemplate(naturalLanguageTemplate.getId());
905            if (orig != null) {
906                throw new RiceIllegalArgumentException(naturalLanguageTemplate.getId());
907            }
908        } catch (RiceIllegalArgumentException ex) {
909            // same as getting a null
910        }
911        NaturalLanguageTemplate.Builder copy = NaturalLanguageTemplate.Builder.create(naturalLanguageTemplate);
912        if (copy.getId() == null) {
913            copy.setId(UUID.randomUUID().toString());
914        }
915        naturalLanguageTemplate = copy.build();
916        naturalLanguageTemplateMap.put(naturalLanguageTemplate.getId(), naturalLanguageTemplate);
917        return naturalLanguageTemplate;
918    }
919
920    @Override
921    public NaturalLanguageTemplate getNaturalLanguageTemplate(String naturalLanguageTemplateId)
922            throws RiceIllegalArgumentException {
923        // GET_BY_ID
924        if (!this.naturalLanguageTemplateMap.containsKey(naturalLanguageTemplateId)) {
925            throw new RiceIllegalArgumentException(naturalLanguageTemplateId);
926        }
927        return this.naturalLanguageTemplateMap.get(naturalLanguageTemplateId);
928    }
929
930    @Override
931    public void updateNaturalLanguageTemplate(NaturalLanguageTemplate naturalLanguageTemplate)
932            throws RiceIllegalArgumentException {
933        // UPDATE
934        NaturalLanguageTemplate.Builder copy = NaturalLanguageTemplate.Builder.create(naturalLanguageTemplate);
935        NaturalLanguageTemplate old = this.getNaturalLanguageTemplate(naturalLanguageTemplate.getId());
936        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
937            throw new RiceIllegalStateException("" + old.getVersionNumber());
938        }
939        copy.setVersionNumber(copy.getVersionNumber() + 1);
940        naturalLanguageTemplate = copy.build();
941        this.naturalLanguageTemplateMap.put(naturalLanguageTemplate.getId(), naturalLanguageTemplate);
942        return;
943    }
944
945    @Override
946    public void deleteNaturalLanguageTemplate(String naturalLanguageTemplateId)
947            throws RiceIllegalArgumentException {
948        // DELETE
949        if (this.naturalLanguageTemplateMap.remove(naturalLanguageTemplateId) == null) {
950            throw new RiceIllegalArgumentException(naturalLanguageTemplateId);
951        }
952        return;
953    }
954
955    @Override
956    public List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByLanguageCode(String languageCode)
957            throws RiceIllegalArgumentException {
958        List<NaturalLanguageTemplate> list = new ArrayList<NaturalLanguageTemplate>();
959        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
960            if (nlt.getLanguageCode().equals(languageCode)) {
961                list.add(nlt);
962            }
963        }
964        return list;
965    }
966
967    @Override
968    public NaturalLanguageTemplate findNaturalLanguageTemplateByLanguageCodeTypeIdAndNluId(String languageCode, String typeId, String naturalLanguageUsageId)
969            throws RiceIllegalArgumentException {
970        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
971            if (nlt.getLanguageCode().equals(languageCode)) {
972                if (nlt.getTypeId().equals(typeId)) {
973                    if (nlt.getNaturalLanguageUsageId().equals(naturalLanguageUsageId)) {
974                        return nlt;
975                    }
976                }
977            }
978        }
979        return null;
980    }
981
982    @Override
983    public List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByNaturalLanguageUsage(String naturalLanguageUsageId)
984            throws RiceIllegalArgumentException {
985        List<NaturalLanguageTemplate> list = new ArrayList<NaturalLanguageTemplate>();
986        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
987            if (nlt.getNaturalLanguageUsageId().equals(naturalLanguageUsageId)) {
988                list.add(nlt);
989            }
990        }
991        return list;
992    }
993
994    @Override
995    public List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByType(String typeId)
996            throws RiceIllegalArgumentException {
997        List<NaturalLanguageTemplate> list = new ArrayList<NaturalLanguageTemplate>();
998        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
999            if (nlt.getTypeId().equals(typeId)) {
1000                list.add(nlt);
1001            }
1002        }
1003        return list;
1004    }
1005
1006    @Override
1007    public List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByTemplate(String template)
1008            throws RiceIllegalArgumentException {
1009        List<NaturalLanguageTemplate> list = new ArrayList<NaturalLanguageTemplate>();
1010        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
1011            if (nlt.getTemplate().equals(template)) {
1012                list.add(nlt);
1013            }
1014        }
1015        return list;
1016    }
1017
1018    @Override
1019    public List<String> findContextIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
1020        CriteriaMatcherInMemory<ContextDefinition> instance = new CriteriaMatcherInMemory<ContextDefinition>();
1021        instance.setCriteria(queryByCriteria);
1022        Collection<ContextDefinition> selected = instance.findMatching(this.contextMap.values());
1023        List<String> list = new ArrayList<String>();
1024        for (ContextDefinition sel : selected) {
1025            list.add(sel.getId());
1026        }
1027        return list;
1028    }
1029
1030    @Override
1031    public List<String> findAgendaIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
1032        CriteriaMatcherInMemory<AgendaDefinition> instance = new CriteriaMatcherInMemory<AgendaDefinition>();
1033        instance.setCriteria(queryByCriteria);
1034        Collection<AgendaDefinition> selected = instance.findMatching(this.agendaMap.values());
1035        List<String> list = new ArrayList<String>();
1036        for (AgendaDefinition sel : selected) {
1037            list.add(sel.getId());
1038        }
1039        return list;
1040    }
1041
1042    @Override
1043    public List<String> findRuleIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
1044        CriteriaMatcherInMemory<RuleDefinition> instance = new CriteriaMatcherInMemory<RuleDefinition>();
1045        instance.setCriteria(queryByCriteria);
1046        Collection<RuleDefinition> selected = instance.findMatching(this.ruleMap.values());
1047        List<String> list = new ArrayList<String>();
1048        for (RuleDefinition sel : selected) {
1049            list.add(sel.getId());
1050        }
1051        return list;
1052    }
1053
1054    @Override
1055    public List<String> findActionIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
1056        CriteriaMatcherInMemory<ActionDefinition> instance = new CriteriaMatcherInMemory<ActionDefinition>();
1057        instance.setCriteria(queryByCriteria);
1058        Collection<ActionDefinition> selected = instance.findMatching(this.actionMap.values());
1059        List<String> list = new ArrayList<String>();
1060        for (ActionDefinition sel : selected) {
1061            list.add(sel.getId());
1062        }
1063        return list;
1064    }
1065
1066    @Override
1067    public List<String> findPropositionIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
1068        CriteriaMatcherInMemory<PropositionDefinition> instance = new CriteriaMatcherInMemory<PropositionDefinition>();
1069        instance.setCriteria(queryByCriteria);
1070        Collection<PropositionDefinition> selected = instance.findMatching(this.propositionMap.values());
1071        List<String> list = new ArrayList<String>();
1072        for (PropositionDefinition sel : selected) {
1073            list.add(sel.getId());
1074        }
1075        return list;
1076    }
1077}