Source code

001/*
002 * Copyright 2011 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.osedu.org/licenses/ECL-2.0
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        // CREATE
227        if (agendaDefinition.getId() != null) {
228            AgendaDefinition orig = this.getAgenda(agendaDefinition.getId());
229            if (orig != null) {
230                throw new RiceIllegalArgumentException(agendaDefinition.getId() + "." + agendaDefinition.getName());
231            }
232        }
233        AgendaDefinition.Builder copy = AgendaDefinition.Builder.create(agendaDefinition);
234        if (copy.getId() == null) {
235            copy.setId(UUID.randomUUID().toString());
236        }
237        copy.setVersionNumber(0l);
238        agendaDefinition = copy.build();
239        agendaMap.put(agendaDefinition.getId(), agendaDefinition);
240        return agendaDefinition;
241    }
242
243    @Override
244    public AgendaDefinition getAgenda(String id)
245            throws RiceIllegalArgumentException {
246        // GET_BY_ID
247        if (!this.agendaMap.containsKey(id)) {
248            throw new RiceIllegalArgumentException(id);
249        }
250        return this.agendaMap.get(id);
251    }
252
253    @Override
254    public List<AgendaDefinition> getAgendasByType(String typeId)
255            throws RiceIllegalArgumentException {
256        // GET_IDS_BY_TYPE
257        List<AgendaDefinition> list = new ArrayList<AgendaDefinition>();
258        for (AgendaDefinition info : agendaMap.values()) {
259            if (typeId.equals(info.getTypeId())) {
260                list.add(info);
261            }
262        }
263        return list;
264    }
265
266    @Override
267    public List<AgendaDefinition> getAgendasByContext(String contextId)
268            throws RiceIllegalArgumentException {
269        List<AgendaDefinition> list = new ArrayList<AgendaDefinition>();
270        for (AgendaDefinition info : this.agendaMap.values()) {
271            if (info.getContextId().equals(contextId)) {
272                list.add(info);
273            }
274        }
275        return list;
276    }
277
278    @Override
279    public List<AgendaDefinition> getAgendasByTypeAndContext(String typeId, String contextId)
280            throws RiceIllegalArgumentException {
281        List<AgendaDefinition> list = new ArrayList<AgendaDefinition>();
282        for (AgendaDefinition info : this.agendaMap.values()) {
283            if (info.getContextId().equals(contextId)) {
284                if (info.getTypeId().equals(typeId)) {
285                    list.add(info);
286                }
287            }
288        }
289        return list;
290    }
291
292    @Override
293    public void updateAgenda(AgendaDefinition agendaDefinition)
294            throws RiceIllegalArgumentException {
295        // UPDATE
296        AgendaDefinition.Builder copy = AgendaDefinition.Builder.create(agendaDefinition);
297        AgendaDefinition old = this.getAgenda(agendaDefinition.getId());
298        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
299            throw new RiceIllegalStateException("" + old.getVersionNumber());
300        }
301        copy.setVersionNumber(copy.getVersionNumber() + 1);
302        agendaDefinition = copy.build();
303        this.agendaMap.put(agendaDefinition.getId(), agendaDefinition);
304        return;
305    }
306
307    @Override
308    public void deleteAgenda(String id)
309            throws RiceIllegalArgumentException {
310        // DELETE
311        if (this.agendaMap.remove(id) == null) {
312            throw new RiceIllegalArgumentException(id);
313        }
314        return;
315    }
316
317    @Override
318    public AgendaItemDefinition createAgendaItem(AgendaItemDefinition agendaItemDefinition)
319            throws RiceIllegalArgumentException {
320        // CREATE
321        AgendaItemDefinition.Builder copy = AgendaItemDefinition.Builder.create(agendaItemDefinition);
322        if (copy.getId() == null) {
323            copy.setId(UUID.randomUUID().toString());
324        }
325        agendaItemDefinition = copy.build();
326        agendaItemMap.put(agendaItemDefinition.getId(), agendaItemDefinition);
327        return agendaItemDefinition;
328    }
329
330    @Override
331    public AgendaItemDefinition getAgendaItem(String id)
332            throws RiceIllegalArgumentException {
333        // GET_BY_ID
334        if (!this.agendaItemMap.containsKey(id)) {
335            throw new RiceIllegalArgumentException(id);
336        }
337        return this.agendaItemMap.get(id);
338    }
339
340    @Override
341    public List<AgendaItemDefinition> getAgendaItemsByType(String typeId)
342            throws RiceIllegalArgumentException {
343        // GET_IDS_BY_TYPE
344        List<AgendaDefinition> agendas = this.getAgendasByType(typeId);
345        List<AgendaItemDefinition> list = new ArrayList<AgendaItemDefinition>();
346        for (AgendaDefinition agenda : agendas) {
347            for (AgendaItemDefinition info : agendaItemMap.values()) {
348                if (agenda.getId().equals(info.getAgendaId())) {
349                    list.add(info);
350                }
351            }
352        }
353        return list;
354    }
355
356    @Override
357    public List<AgendaItemDefinition> getAgendaItemsByContext(String contextId)
358            throws RiceIllegalArgumentException {
359        List<AgendaDefinition> agendas = this.getAgendasByContext(contextId);
360        List<AgendaItemDefinition> list = new ArrayList<AgendaItemDefinition>();
361        for (AgendaDefinition agenda : agendas) {
362            for (AgendaItemDefinition info : agendaItemMap.values()) {
363                if (agenda.getId().equals(info.getAgendaId())) {
364                    list.add(info);
365                }
366            }
367        }
368        return list;
369    }
370
371    @Override
372    public List<AgendaItemDefinition> getAgendaItemsByTypeAndContext(String typeId, String contextId)
373            throws RiceIllegalArgumentException {
374        List<AgendaDefinition> agendas = this.getAgendasByContext(contextId);
375        List<AgendaItemDefinition> list = new ArrayList<AgendaItemDefinition>();
376        for (AgendaDefinition agenda : agendas) {
377            if (agenda.getTypeId().equals(typeId)) {
378                for (AgendaItemDefinition info : agendaItemMap.values()) {
379                    if (agenda.getId().equals(info.getAgendaId())) {
380                        list.add(info);
381                    }
382                }
383            }
384        }
385        return list;
386    }
387
388    @Override
389    public void updateAgendaItem(AgendaItemDefinition agendaItemDefinition)
390            throws RiceIllegalArgumentException {
391        // UPDATE
392        AgendaItemDefinition.Builder copy = AgendaItemDefinition.Builder.create(agendaItemDefinition);
393        AgendaItemDefinition old = this.getAgendaItem(agendaItemDefinition.getId());
394        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
395            throw new RiceIllegalStateException("" + old.getVersionNumber());
396        }
397        copy.setVersionNumber(copy.getVersionNumber() + 1);
398        agendaItemDefinition = copy.build();
399        this.agendaItemMap.put(agendaItemDefinition.getId(), agendaItemDefinition);
400        return;
401    }
402
403    @Override
404    public void deleteAgendaItem(String id)
405            throws RiceIllegalArgumentException {
406        // DELETE
407        if (this.agendaItemMap.remove(id) == null) {
408            throw new RiceIllegalArgumentException(id);
409        }
410        return;
411    }
412
413    @Override
414    public RuleDefinition createRule(RuleDefinition ruleDefinition)
415            throws RiceIllegalArgumentException {
416        // CREATE
417        if (ruleDefinition.getId() != null) {
418            RuleDefinition orig = this.getRule(ruleDefinition.getId());
419            if (orig != null) {
420                throw new RiceIllegalArgumentException(ruleDefinition.getId());
421            }
422        }
423        RuleDefinition.Builder copy = RuleDefinition.Builder.create(ruleDefinition);
424        if (copy.getId() == null) {
425            copy.setId(UUID.randomUUID().toString());
426        }
427        ruleDefinition = copy.build();
428        ruleMap.put(ruleDefinition.getId(), ruleDefinition);
429        return ruleDefinition;
430    }
431
432    @Override
433    public RuleDefinition getRule(String ruleId) {
434        // GET_BY_ID
435        if (!this.ruleMap.containsKey(ruleId)) {
436            throw new RiceIllegalArgumentException(ruleId);
437        }
438        return this.ruleMap.get(ruleId);
439    }
440
441    @Override
442    public List<RuleDefinition> getRules(List<String> ruleIds) {
443        List<RuleDefinition> list = new ArrayList<RuleDefinition>();
444        for (String id : ruleIds) {
445            list.add(this.getRule(id));
446        }
447        return list;
448    }
449
450    @Override
451    public void updateRule(RuleDefinition ruleDefinition)
452            throws RiceIllegalArgumentException {
453        // UPDATE
454        RuleDefinition.Builder copy = RuleDefinition.Builder.create(ruleDefinition);
455        RuleDefinition old = this.getRule(ruleDefinition.getId());
456        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
457            throw new RiceIllegalStateException("" + old.getVersionNumber());
458        }
459        copy.setVersionNumber(copy.getVersionNumber() + 1);
460        ruleDefinition = copy.build();
461        this.ruleMap.put(ruleDefinition.getId(), ruleDefinition);
462        return;
463    }
464
465    @Override
466    public void deleteRule(String id)
467            throws RiceIllegalArgumentException {
468        // DELETE
469        if (this.ruleMap.remove(id) == null) {
470            throw new RiceIllegalArgumentException(id);
471        }
472        return;
473    }
474
475    @Override
476    public ActionDefinition createAction(ActionDefinition actionDefinition)
477            throws RiceIllegalArgumentException {
478        // CREATE
479        ActionDefinition orig = this.getAction(actionDefinition.getId());
480        if (orig != null) {
481            throw new RiceIllegalArgumentException(actionDefinition.getId());
482        }
483        ActionDefinition.Builder copy = ActionDefinition.Builder.create(actionDefinition);
484        if (copy.getId() == null) {
485            copy.setId(UUID.randomUUID().toString());
486        }
487        actionDefinition = copy.build();
488        actionMap.put(actionDefinition.getId(), actionDefinition);
489        return actionDefinition;
490    }
491
492    @Override
493    public ActionDefinition getAction(String actionId) {
494        // GET_BY_ID
495        if (!this.actionMap.containsKey(actionId)) {
496            throw new RiceIllegalArgumentException(actionId);
497        }
498        return this.actionMap.get(actionId);
499    }
500
501    @Override
502    public List<ActionDefinition> getActions(List<String> actionIds) {
503        List<ActionDefinition> list = new ArrayList<ActionDefinition>();
504        for (String id : actionIds) {
505            list.add(this.getAction(id));
506        }
507        return list;
508    }
509
510    @Override
511    public void updateAction(ActionDefinition actionDefinition)
512            throws RiceIllegalArgumentException {
513        // UPDATE
514        ActionDefinition.Builder copy = ActionDefinition.Builder.create(actionDefinition);
515        ActionDefinition old = this.getAction(actionDefinition.getId());
516        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
517            throw new RiceIllegalStateException("" + old.getVersionNumber());
518        }
519        copy.setVersionNumber(copy.getVersionNumber() + 1);
520        actionDefinition = copy.build();
521        this.actionMap.put(actionDefinition.getId(), actionDefinition);
522        return;
523    }
524
525    @Override
526    public void deleteAction(String id)
527            throws RiceIllegalArgumentException {
528        // DELETE
529        if (this.actionMap.remove(id) == null) {
530            throw new RiceIllegalArgumentException(id);
531        }
532        return;
533    }
534
535    @Override
536    public PropositionDefinition createProposition(PropositionDefinition propositionDefinition)
537            throws RiceIllegalArgumentException {
538        // CREATE
539        if (propositionDefinition.getId() != null) {
540            PropositionDefinition orig = this.getProposition(propositionDefinition.getId());
541            if (orig != null) {
542                throw new RiceIllegalArgumentException(propositionDefinition.getId());
543            }
544        }
545        PropositionDefinition.Builder copy = PropositionDefinition.Builder.create(propositionDefinition);
546        if (copy.getId() == null) {
547            copy.setId(UUID.randomUUID().toString());
548        }
549        for (PropositionParameter.Builder paramBldr : copy.getParameters()) {
550            if (paramBldr.getId() == null) {
551                paramBldr.setId(UUID.randomUUID().toString());
552            }
553            if (paramBldr.getPropId() == null) {
554                paramBldr.setPropId(copy.getId());
555            }
556            if (paramBldr.getTermValue() != null) {
557                TermDefinition termValue = paramBldr.getTermValue();
558                // no id means it does not exist yet
559                if (termValue.getId() == null) {
560                    termValue = this.termRepositoryService.createTerm(termValue);
561                    paramBldr.setTermValue(termValue);
562                }
563                if (paramBldr.getValue() == null) {
564                    paramBldr.setValue(termValue.getId());
565                }
566            }
567        }
568        propositionDefinition = copy.build();
569        propositionMap.put(propositionDefinition.getId(), propositionDefinition);
570        return propositionDefinition;
571    }
572
573    @Override
574    public PropositionDefinition getProposition(String id)
575            throws RiceIllegalArgumentException {
576        // GET_BY_ID
577        if (!this.propositionMap.containsKey(id)) {
578            throw new RiceIllegalArgumentException(id);
579        }
580        return this.propositionMap.get(id);
581    }
582
583    @Override
584    public Set<PropositionDefinition> getPropositionsByType(String typeId)
585            throws RiceIllegalArgumentException {
586        // GET_IDS_BY_TYPE
587        Set<PropositionDefinition> set = new LinkedHashSet<PropositionDefinition>();
588        for (PropositionDefinition info : propositionMap.values()) {
589            if (typeId.equals(info.getTypeId())) {
590                set.add(info);
591            }
592        }
593        return set;
594    }
595
596    @Override
597    public Set<PropositionDefinition> getPropositionsByRule(String ruleId)
598            throws RiceIllegalArgumentException {
599        Set<PropositionDefinition> set = new LinkedHashSet<PropositionDefinition>();
600        for (PropositionDefinition info : this.propositionMap.values()) {
601            if (info.getRuleId().equals(ruleId)) {
602                set.add(info);
603            }
604        }
605        return set;
606    }
607
608    @Override
609    public void updateProposition(PropositionDefinition propositionDefinition)
610            throws RiceIllegalArgumentException {
611        if (this.propositionMap.containsKey(propositionDefinition.getId())) {
612            throw new RiceIllegalArgumentException (propositionDefinition.getId() + "not found");
613        }
614        // UPDATE
615        PropositionDefinition.Builder copy = PropositionDefinition.Builder.create(propositionDefinition);
616        PropositionDefinition old = this.getProposition(propositionDefinition.getId());
617        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
618            throw new RiceIllegalStateException("" + old.getVersionNumber());
619        }
620        copy.setVersionNumber(copy.getVersionNumber() + 1);
621        for (PropositionParameter.Builder paramBldr : copy.getParameters()) {
622            if (paramBldr.getId() == null) {
623                paramBldr.setId(UUID.randomUUID().toString());
624            }
625            if (paramBldr.getPropId() == null) {
626                paramBldr.setPropId(copy.getId());
627            }
628            if (paramBldr.getTermValue() != null) {
629                TermDefinition termValue = paramBldr.getTermValue();
630                // no id means it does not exist yet
631                if (termValue.getId() == null) {
632                    termValue = this.termRepositoryService.createTerm(termValue);
633                    paramBldr.setTermValue(termValue);
634                }
635                if (paramBldr.getValue() == null) {
636                    paramBldr.setValue(termValue.getId());
637                }
638            }
639        }
640        propositionDefinition = copy.build();
641        this.propositionMap.put(propositionDefinition.getId(), propositionDefinition);
642        return;
643    }
644
645    @Override
646    public void deleteProposition(String id)
647            throws RiceIllegalArgumentException {
648        // DELETE
649        if (this.propositionMap.remove(id) == null) {
650            throw new RiceIllegalArgumentException(id);
651        }
652        return;
653    }
654
655    @Override
656    public NaturalLanguageUsage createNaturalLanguageUsage(NaturalLanguageUsage naturalLanguageUsage)
657            throws RiceIllegalArgumentException {
658        // CREATE
659        try {
660            NaturalLanguageUsage orig = this.getNaturalLanguageUsage(naturalLanguageUsage.getId());
661            if (orig != null) {
662                throw new RiceIllegalArgumentException(naturalLanguageUsage.getId());
663            }
664        } catch (RiceIllegalArgumentException ex) {
665//            same as returning null
666        }
667        NaturalLanguageUsage.Builder copy = NaturalLanguageUsage.Builder.create(naturalLanguageUsage);
668        if (copy.getId() == null) {
669            copy.setId(UUID.randomUUID().toString());
670        }
671        naturalLanguageUsage = copy.build();
672        naturalLanguageUsageMap.put(naturalLanguageUsage.getId(), naturalLanguageUsage);
673        return naturalLanguageUsage;
674    }
675
676    @Override
677    public NaturalLanguageUsage getNaturalLanguageUsage(String id)
678            throws RiceIllegalArgumentException {
679        // GET_BY_ID
680        if (!this.naturalLanguageUsageMap.containsKey(id)) {
681            throw new RiceIllegalArgumentException(id);
682        }
683        return this.naturalLanguageUsageMap.get(id);
684    }
685
686    @Override
687    public void updateNaturalLanguageUsage(NaturalLanguageUsage naturalLanguageUsage)
688            throws RiceIllegalArgumentException {
689        // UPDATE
690        NaturalLanguageUsage.Builder copy = NaturalLanguageUsage.Builder.create(naturalLanguageUsage);
691        NaturalLanguageUsage old = this.getNaturalLanguageUsage(naturalLanguageUsage.getId());
692        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
693            throw new RiceIllegalStateException("" + old.getVersionNumber());
694        }
695        copy.setVersionNumber(copy.getVersionNumber() + 1);
696        naturalLanguageUsage = copy.build();
697        this.naturalLanguageUsageMap.put(naturalLanguageUsage.getId(), naturalLanguageUsage);
698        return;
699    }
700
701    @Override
702    public void deleteNaturalLanguageUsage(String naturalLanguageUsageId)
703            throws RiceIllegalArgumentException {
704        // DELETE
705        if (this.naturalLanguageUsageMap.remove(naturalLanguageUsageId) == null) {
706            throw new RiceIllegalArgumentException(naturalLanguageUsageId);
707        }
708        return;
709    }
710
711    ////
712    //// natural language translations
713    ////
714    @Override
715    public String translateNaturalLanguageForObject(String naturalLanguageUsageId,
716            String typeId,
717            String krmsObjectId,
718            String languageCode)
719            throws RiceIllegalArgumentException {
720        TranslationUtility util = new TranslationUtility(this, this.templater);
721        return util.translateNaturalLanguageForObject(naturalLanguageUsageId, typeId, krmsObjectId, languageCode);
722    }
723
724    @Override
725    public String translateNaturalLanguageForProposition(String naturalLanguageUsageId,
726            PropositionDefinition proposition, String languageCode)
727            throws RiceIllegalArgumentException {
728        TranslationUtility util = new TranslationUtility(this, this.templater);
729        return util.translateNaturalLanguageForProposition(naturalLanguageUsageId, proposition, languageCode);
730    }
731
732    @Override
733    public NaturalLanguageTree translateNaturalLanguageTreeForProposition(String naturalLanguageUsageId,
734            PropositionDefinition propositionDefinintion,
735            String languageCode) throws RiceIllegalArgumentException {
736        TranslationUtility util = new TranslationUtility(this, this.templater);
737        return util.translateNaturalLanguageTreeForProposition(naturalLanguageUsageId, propositionDefinintion, languageCode);
738    }
739
740    @Override
741    public List<NaturalLanguageUsage> getNaturalLanguageUsagesByNamespace(String namespace) throws RiceIllegalArgumentException {
742        List<NaturalLanguageUsage> list = new ArrayList<NaturalLanguageUsage>();
743        for (NaturalLanguageUsage info : naturalLanguageUsageMap.values()) {
744            if (namespace.equals(info.getNamespace())) {
745                list.add(info);
746            }
747        }
748        return list;
749    }
750
751    @Override
752    public NaturalLanguageUsage getNaturalLanguageUsageByNameAndNamespace(String name, String namespace) throws RiceIllegalArgumentException {
753        for (NaturalLanguageUsage info : naturalLanguageUsageMap.values()) {
754            if (namespace.equals(info.getNamespace())) {
755                if (name.equals(info.getName())) {
756                    return info;
757                }
758            }
759        }
760        return null;
761    }
762
763    @Override
764    public ContextDefinition selectContext(ContextSelectionCriteria contextSelectionCriteria) throws RiceIllegalArgumentException {
765        throw new UnsupportedOperationException("Not supported yet.");
766    }
767
768    @Override
769    public AgendaTreeDefinition getAgendaTree(String agendaId) throws RiceIllegalArgumentException {
770        throw new UnsupportedOperationException("Not supported yet.");
771    }
772
773    @Override
774    public List<AgendaTreeDefinition> getAgendaTrees(List<String> agendaIds) throws RiceIllegalArgumentException {
775        throw new UnsupportedOperationException("Not supported yet.");
776    }
777
778    @Override
779    public ContextDefinition createContext(ContextDefinition contextDefinition)
780            throws RiceIllegalArgumentException {
781        // CREATE
782        ContextDefinition orig = this.getContextByNameAndNamespace(contextDefinition.getName(), contextDefinition.getNamespace());
783        if (orig != null) {
784            throw new RiceIllegalArgumentException(contextDefinition.getNamespace() + "." + contextDefinition.getName());
785        }
786        ContextDefinition.Builder copy = ContextDefinition.Builder.create(contextDefinition);
787        if (copy.getId() == null) {
788            copy.setId(UUID.randomUUID().toString());
789        }
790        contextDefinition = copy.build();
791        contextMap.put(contextDefinition.getId(), contextDefinition);
792        return contextDefinition;
793    }
794
795    @Override
796    public ContextDefinition findCreateContext(ContextDefinition contextDefinition) throws RiceIllegalArgumentException {
797        ContextDefinition orig = this.getContextByNameAndNamespace(contextDefinition.getName(), contextDefinition.getNamespace());
798        if (orig != null) {
799            return orig;
800        }
801        return this.createContext(contextDefinition);
802    }
803
804    @Override
805    public void updateContext(ContextDefinition contextDefinition)
806            throws RiceIllegalArgumentException {
807        // UPDATE
808        ContextDefinition.Builder copy = ContextDefinition.Builder.create(contextDefinition);
809        ContextDefinition old = this.getContext(contextDefinition.getId());
810        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
811            throw new RiceIllegalStateException("" + old.getVersionNumber());
812        }
813        copy.setVersionNumber(copy.getVersionNumber() + 1);
814        contextDefinition = copy.build();
815        this.contextMap.put(contextDefinition.getId(), contextDefinition);
816        return;
817    }
818
819    @Override
820    public void deleteContext(String id)
821            throws RiceIllegalArgumentException {
822        // DELETE
823        if (this.contextMap.remove(id) == null) {
824            throw new RiceIllegalArgumentException(id);
825        }
826        return;
827    }
828
829    @Override
830    public ContextDefinition getContext(String id)
831            throws RiceIllegalArgumentException {
832        // GET_BY_ID
833        if (!this.contextMap.containsKey(id)) {
834            throw new RiceIllegalArgumentException(id);
835        }
836        return this.contextMap.get(id);
837    }
838
839    @Override
840    public ContextDefinition getContextByNameAndNamespace(String name, String namespace)
841            throws RiceIllegalArgumentException {
842        if (name == null || name.trim().isEmpty()) {
843            throw new RiceIllegalArgumentException("name is null or empty");
844        }
845        if (namespace == null || namespace.trim().isEmpty()) {
846            throw new RiceIllegalArgumentException("name is null or empty");
847        }
848        // RICE_GET_BY_NAMESPACE_AND_NAME
849        for (ContextDefinition info : contextMap.values()) {
850            if (name.equals(info.getName())) {
851                if (namespace.equals(info.getNamespace())) {
852                    return ContextDefinition.Builder.create(info).build();
853                }
854            }
855        }
856        return null;
857    }
858
859    @Override
860    public NaturalLanguageTemplate createNaturalLanguageTemplate(NaturalLanguageTemplate naturalLanguageTemplate)
861            throws RiceIllegalArgumentException {
862        // CREATE
863        try {
864            NaturalLanguageTemplate orig = this.getNaturalLanguageTemplate(naturalLanguageTemplate.getId());
865            if (orig != null) {
866                throw new RiceIllegalArgumentException(naturalLanguageTemplate.getId());
867            }
868        } catch (RiceIllegalArgumentException ex) {
869            // same as getting a null
870        }
871        NaturalLanguageTemplate.Builder copy = NaturalLanguageTemplate.Builder.create(naturalLanguageTemplate);
872        if (copy.getId() == null) {
873            copy.setId(UUID.randomUUID().toString());
874        }
875        naturalLanguageTemplate = copy.build();
876        naturalLanguageTemplateMap.put(naturalLanguageTemplate.getId(), naturalLanguageTemplate);
877        return naturalLanguageTemplate;
878    }
879
880    @Override
881    public NaturalLanguageTemplate getNaturalLanguageTemplate(String naturalLanguageTemplateId)
882            throws RiceIllegalArgumentException {
883        // GET_BY_ID
884        if (!this.naturalLanguageTemplateMap.containsKey(naturalLanguageTemplateId)) {
885            throw new RiceIllegalArgumentException(naturalLanguageTemplateId);
886        }
887        return this.naturalLanguageTemplateMap.get(naturalLanguageTemplateId);
888    }
889
890    @Override
891    public void updateNaturalLanguageTemplate(NaturalLanguageTemplate naturalLanguageTemplate)
892            throws RiceIllegalArgumentException {
893        // UPDATE
894        NaturalLanguageTemplate.Builder copy = NaturalLanguageTemplate.Builder.create(naturalLanguageTemplate);
895        NaturalLanguageTemplate old = this.getNaturalLanguageTemplate(naturalLanguageTemplate.getId());
896        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
897            throw new RiceIllegalStateException("" + old.getVersionNumber());
898        }
899        copy.setVersionNumber(copy.getVersionNumber() + 1);
900        naturalLanguageTemplate = copy.build();
901        this.naturalLanguageTemplateMap.put(naturalLanguageTemplate.getId(), naturalLanguageTemplate);
902        return;
903    }
904
905    @Override
906    public void deleteNaturalLanguageTemplate(String naturalLanguageTemplateId)
907            throws RiceIllegalArgumentException {
908        // DELETE
909        if (this.naturalLanguageTemplateMap.remove(naturalLanguageTemplateId) == null) {
910            throw new RiceIllegalArgumentException(naturalLanguageTemplateId);
911        }
912        return;
913    }
914
915    @Override
916    public List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByLanguageCode(String languageCode)
917            throws RiceIllegalArgumentException {
918        List<NaturalLanguageTemplate> list = new ArrayList<NaturalLanguageTemplate>();
919        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
920            if (nlt.getLanguageCode().equals(languageCode)) {
921                list.add(nlt);
922            }
923        }
924        return list;
925    }
926
927    @Override
928    public NaturalLanguageTemplate findNaturalLanguageTemplateByLanguageCodeTypeIdAndNluId(String languageCode, String typeId, String naturalLanguageUsageId)
929            throws RiceIllegalArgumentException {
930        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
931            if (nlt.getLanguageCode().equals(languageCode)) {
932                if (nlt.getTypeId().equals(typeId)) {
933                    if (nlt.getNaturalLanguageUsageId().equals(naturalLanguageUsageId)) {
934                        return nlt;
935                    }
936                }
937            }
938        }
939        return null;
940    }
941
942    @Override
943    public List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByNaturalLanguageUsage(String naturalLanguageUsageId)
944            throws RiceIllegalArgumentException {
945        List<NaturalLanguageTemplate> list = new ArrayList<NaturalLanguageTemplate>();
946        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
947            if (nlt.getNaturalLanguageUsageId().equals(naturalLanguageUsageId)) {
948                list.add(nlt);
949            }
950        }
951        return list;
952    }
953
954    @Override
955    public List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByType(String typeId)
956            throws RiceIllegalArgumentException {
957        List<NaturalLanguageTemplate> list = new ArrayList<NaturalLanguageTemplate>();
958        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
959            if (nlt.getTypeId().equals(typeId)) {
960                list.add(nlt);
961            }
962        }
963        return list;
964    }
965
966    @Override
967    public List<NaturalLanguageTemplate> findNaturalLanguageTemplatesByTemplate(String template)
968            throws RiceIllegalArgumentException {
969        List<NaturalLanguageTemplate> list = new ArrayList<NaturalLanguageTemplate>();
970        for (NaturalLanguageTemplate nlt : this.naturalLanguageTemplateMap.values()) {
971            if (nlt.getTemplate().equals(template)) {
972                list.add(nlt);
973            }
974        }
975        return list;
976    }
977
978    @Override
979    public List<String> findContextIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
980        CriteriaMatcherInMemory<ContextDefinition> instance = new CriteriaMatcherInMemory<ContextDefinition>();
981        instance.setCriteria(queryByCriteria);
982        Collection<ContextDefinition> selected = instance.findMatching(this.contextMap.values());
983        List<String> list = new ArrayList<String>();
984        for (ContextDefinition sel : selected) {
985            list.add(sel.getId());
986        }
987        return list;
988    }
989
990    @Override
991    public List<String> findAgendaIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
992        CriteriaMatcherInMemory<AgendaDefinition> instance = new CriteriaMatcherInMemory<AgendaDefinition>();
993        instance.setCriteria(queryByCriteria);
994        Collection<AgendaDefinition> selected = instance.findMatching(this.agendaMap.values());
995        List<String> list = new ArrayList<String>();
996        for (AgendaDefinition sel : selected) {
997            list.add(sel.getId());
998        }
999        return list;
1000    }
1001
1002    @Override
1003    public List<String> findRuleIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
1004        CriteriaMatcherInMemory<RuleDefinition> instance = new CriteriaMatcherInMemory<RuleDefinition>();
1005        instance.setCriteria(queryByCriteria);
1006        Collection<RuleDefinition> selected = instance.findMatching(this.ruleMap.values());
1007        List<String> list = new ArrayList<String>();
1008        for (RuleDefinition sel : selected) {
1009            list.add(sel.getId());
1010        }
1011        return list;
1012    }
1013
1014    @Override
1015    public List<String> findActionIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
1016        CriteriaMatcherInMemory<ActionDefinition> instance = new CriteriaMatcherInMemory<ActionDefinition>();
1017        instance.setCriteria(queryByCriteria);
1018        Collection<ActionDefinition> selected = instance.findMatching(this.actionMap.values());
1019        List<String> list = new ArrayList<String>();
1020        for (ActionDefinition sel : selected) {
1021            list.add(sel.getId());
1022        }
1023        return list;
1024    }
1025
1026    @Override
1027    public List<String> findPropositionIds(QueryByCriteria queryByCriteria) throws RiceIllegalArgumentException {
1028        CriteriaMatcherInMemory<PropositionDefinition> instance = new CriteriaMatcherInMemory<PropositionDefinition>();
1029        instance.setCriteria(queryByCriteria);
1030        Collection<PropositionDefinition> selected = instance.findMatching(this.propositionMap.values());
1031        List<String> list = new ArrayList<String>();
1032        for (PropositionDefinition sel : selected) {
1033            list.add(sel.getId());
1034        }
1035        return list;
1036    }
1037}