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.Arrays;
020import java.util.Collections;
021import java.util.LinkedHashMap;
022import java.util.List;
023import java.util.Map;
024import java.util.UUID;
025import org.kuali.rice.core.api.exception.RiceIllegalArgumentException;
026import org.kuali.rice.core.api.exception.RiceIllegalStateException;
027import org.kuali.rice.krms.api.repository.type.KrmsAttributeDefinition;
028import org.kuali.rice.krms.api.repository.type.KrmsTypeDefinition;
029import org.kuali.rice.krms.api.repository.type.KrmsTypeRepositoryService;
030import static org.kuali.rice.krms.api.repository.type.KrmsTypeRepositoryService.PROPOSITION_PARAMETER_SERVICE_NAMES;
031import static org.kuali.rice.krms.api.repository.type.KrmsTypeRepositoryService.PROPOSITION_SERVICE_NAMES;
032import org.kuali.rice.krms.api.repository.typerelation.RelationshipType;
033import org.kuali.rice.krms.api.repository.typerelation.TypeTypeRelation;
034import org.kuali.rice.krms.impl.repository.TypeTypeRelationSequenceComparator;
035
036public class KrmsTypeRepositoryServiceMockImpl implements KrmsTypeRepositoryService {
037    // cache variable 
038    // The LinkedHashMap is just so the values come back in a predictable order
039
040    private Map<String, KrmsTypeDefinition> krmsTypeMap = new LinkedHashMap<String, KrmsTypeDefinition>();
041    private Map<String, KrmsAttributeDefinition> krmsAttributeDefinitionMap = new LinkedHashMap<String, KrmsAttributeDefinition>();
042    private Map<String, TypeTypeRelation> typeTypeRelationMap = new LinkedHashMap<String, TypeTypeRelation>();
043
044    public void clear() {
045        this.krmsTypeMap.clear();
046        this.krmsAttributeDefinitionMap.clear();
047        this.typeTypeRelationMap.clear();
048    }
049
050    @Override
051    public KrmsTypeDefinition createKrmsType(KrmsTypeDefinition krmsType)
052            throws RiceIllegalArgumentException, RiceIllegalStateException {
053        // CREATE
054        KrmsTypeDefinition orig = this.getTypeByName(krmsType.getNamespace(), krmsType.getName());
055        if (orig != null) {
056            throw new RiceIllegalArgumentException(krmsType.getNamespace() + "." + krmsType.getName() + " already exists");
057        }
058        KrmsTypeDefinition.Builder copy = KrmsTypeDefinition.Builder.create(krmsType);
059        if (copy.getId() == null) {
060            copy.setId(UUID.randomUUID().toString());
061        }
062        krmsType = copy.build();
063        krmsTypeMap.put(krmsType.getId(), krmsType);
064        return krmsType;
065    }
066
067    @Override
068    public KrmsTypeDefinition updateKrmsType(KrmsTypeDefinition krmsType)
069            throws RiceIllegalArgumentException, RiceIllegalStateException {
070        // UPDATE
071        KrmsTypeDefinition.Builder copy = KrmsTypeDefinition.Builder.create(krmsType);
072        KrmsTypeDefinition old = this.getTypeById(krmsType.getId());
073        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
074            throw new RiceIllegalStateException("" + old.getVersionNumber());
075        }
076        copy.setVersionNumber(copy.getVersionNumber() + 1);
077        krmsType = copy.build();
078        this.krmsTypeMap.put(krmsType.getId(), krmsType);
079        return krmsType;
080    }
081
082    @Override
083    public KrmsTypeDefinition getTypeById(String id)
084            throws RiceIllegalArgumentException {
085        // GET_BY_ID
086        if (!this.krmsTypeMap.containsKey(id)) {
087            throw new RiceIllegalArgumentException(id);
088        }
089        return this.krmsTypeMap.get(id);
090    }
091
092    @Override
093    public KrmsTypeDefinition getTypeByName(String namespaceCode, String name)
094            throws RiceIllegalArgumentException, RiceIllegalStateException {
095        for (KrmsTypeDefinition type : this.krmsTypeMap.values()) {
096            if (type.getName().equals(name)) {
097                if (type.getNamespace().equals(namespaceCode)) {
098                    return type;
099                }
100            }
101        }
102        return null;
103    }
104
105    @Override
106    public List<KrmsTypeDefinition> findAllTypesByNamespace(String namespaceCode)
107            throws RiceIllegalArgumentException {
108        List<KrmsTypeDefinition> list = new ArrayList<KrmsTypeDefinition>();
109        for (KrmsTypeDefinition type : this.krmsTypeMap.values()) {
110            if (type.getNamespace().equals(namespaceCode)) {
111                list.add(type);
112            }
113        }
114        return list;
115    }
116
117    @Override
118    public List<KrmsTypeDefinition> findAllTypes() {
119        return new ArrayList<KrmsTypeDefinition>(this.krmsTypeMap.values());
120    }
121
122    @Override
123    public KrmsTypeDefinition getAgendaTypeByAgendaTypeIdAndContextId(String agendaTypeId, String contextId)
124            throws RiceIllegalArgumentException {
125        // UNKNOWN
126        throw new RiceIllegalArgumentException("getAgendaTypeByAgendaTypeIdAndContextId is being deprecated");
127    }
128
129    @Override
130    public List<KrmsTypeDefinition> findAllAgendaTypesByContextId(String contextId)
131            throws RiceIllegalArgumentException {
132        // UNKNOWN
133        throw new RiceIllegalArgumentException("findAllAgendaTypesByContextId is being deprecated");
134    }
135
136    @Override
137    public List<KrmsTypeDefinition> findAllRuleTypesByContextId(String contextId)
138            throws RiceIllegalArgumentException {
139        // UNKNOWN
140        throw new RiceIllegalArgumentException("findAllRuleTypesByContextId is being deprecated");
141    }
142
143    @Override
144    public KrmsTypeDefinition getRuleTypeByRuleTypeIdAndContextId(String ruleTypeId, String contextId)
145            throws RiceIllegalArgumentException {
146        // UNKNOWN
147        throw new RiceIllegalArgumentException("getRuleTypeByRuleTypeIdAndContextId is being deprecated");
148    }
149
150    @Override
151    public List<KrmsTypeDefinition> findAllActionTypesByContextId(String contextId)
152            throws RiceIllegalArgumentException {
153        // UNKNOWN
154        throw new RiceIllegalArgumentException("findAllActionTypesByContextId is being deprecated");
155    }
156
157    @Override
158    public KrmsTypeDefinition getActionTypeByActionTypeIdAndContextId(String actionTypeId, String contextId)
159            throws RiceIllegalArgumentException {
160        // UNKNOWN
161        throw new RiceIllegalArgumentException("getActionTypeByActionTypeIdAndContextId is being deprecated");
162    }
163
164    @Override
165    public KrmsAttributeDefinition getAttributeDefinitionById(String attributeDefinitionId)
166            throws RiceIllegalArgumentException {
167        // GET_BY_ID
168        if (!this.krmsAttributeDefinitionMap.containsKey(attributeDefinitionId)) {
169            throw new RiceIllegalArgumentException(attributeDefinitionId);
170        }
171        return this.krmsAttributeDefinitionMap.get(attributeDefinitionId);
172    }
173
174    @Override
175    public KrmsAttributeDefinition getAttributeDefinitionByName(String namespaceCode, String name)
176            throws RiceIllegalArgumentException {
177        for (KrmsAttributeDefinition info : this.krmsAttributeDefinitionMap.values()) {
178            if (info.getNamespace().equals(namespaceCode)) {
179                if (info.getName().equals(name)) {
180                    return info;
181                }
182            }
183        }
184        return null;
185    }
186
187    @Override
188    public TypeTypeRelation createTypeTypeRelation(TypeTypeRelation typeTypeRelation)
189            throws RiceIllegalArgumentException {
190        // CREATE
191        try {
192            TypeTypeRelation orig = this.getTypeTypeRelation(typeTypeRelation.getId());
193            if (orig != null) {
194                throw new RiceIllegalArgumentException(typeTypeRelation.getId() + " already exists");
195            }
196        } catch (RiceIllegalArgumentException ex) {
197            // throws exception if not found so same as returning null
198        }
199        TypeTypeRelation.Builder copy = TypeTypeRelation.Builder.create(typeTypeRelation);
200        if (copy.getId() == null) {
201            copy.setId(UUID.randomUUID().toString());
202        }
203        typeTypeRelation = copy.build();
204        typeTypeRelationMap.put(typeTypeRelation.getId(), typeTypeRelation);
205        return typeTypeRelation;
206    }
207
208    @Override
209    public TypeTypeRelation getTypeTypeRelation(String typeTypeRelationId)
210            throws RiceIllegalArgumentException {
211        // GET_BY_ID
212        if (!this.typeTypeRelationMap.containsKey(typeTypeRelationId)) {
213            throw new RiceIllegalArgumentException(typeTypeRelationId);
214        }
215        return this.typeTypeRelationMap.get(typeTypeRelationId);
216    }
217
218    @Override
219    public void updateTypeTypeRelation(TypeTypeRelation typeTypeRelation)
220            throws RiceIllegalArgumentException {
221        // UPDATE
222        TypeTypeRelation.Builder copy = TypeTypeRelation.Builder.create(typeTypeRelation);
223        TypeTypeRelation old = this.getTypeTypeRelation(typeTypeRelation.getId());
224        if (!old.getVersionNumber().equals(copy.getVersionNumber())) {
225            throw new RiceIllegalStateException("" + old.getVersionNumber());
226        }
227        copy.setVersionNumber(copy.getVersionNumber() + 1);
228        typeTypeRelation = copy.build();
229        this.typeTypeRelationMap.put(typeTypeRelation.getId(), typeTypeRelation);
230        return;
231    }
232
233    @Override
234    public void deleteTypeTypeRelation(String typeTypeRelationId)
235            throws RiceIllegalArgumentException {
236        // DELETE
237        if (this.typeTypeRelationMap.remove(typeTypeRelationId) == null) {
238            throw new RiceIllegalArgumentException(typeTypeRelationId);
239        }
240        return;
241    }
242
243    @Override
244    public List<TypeTypeRelation> findTypeTypeRelationsByFromType(String fromTypeId)
245            throws RiceIllegalArgumentException {
246        List<TypeTypeRelation> list = new ArrayList<TypeTypeRelation>();
247        for (TypeTypeRelation rel : this.typeTypeRelationMap.values()) {
248            if (rel.getFromTypeId().equals(fromTypeId)) {
249                list.add(rel);
250            }
251        }
252        return list;
253    }
254
255    @Override
256    public List<TypeTypeRelation> findTypeTypeRelationsByToType(String toTypeId)
257            throws RiceIllegalArgumentException {
258        List<TypeTypeRelation> list = new ArrayList<TypeTypeRelation>();
259        for (TypeTypeRelation rel : this.typeTypeRelationMap.values()) {
260            if (rel.getToTypeId().equals(toTypeId)) {
261                list.add(rel);
262            }
263        }
264        return list;
265    }
266
267    @Override
268    public List<TypeTypeRelation> findTypeTypeRelationsByRelationshipType(RelationshipType relationshipType)
269            throws RiceIllegalArgumentException {
270        List<TypeTypeRelation> list = new ArrayList<TypeTypeRelation>();
271        for (TypeTypeRelation rel : this.typeTypeRelationMap.values()) {
272            if (rel.getRelationshipType().equals(relationshipType)) {
273                list.add(rel);
274            }
275        }
276        return list;
277    }
278
279    @Override
280    public List<KrmsTypeDefinition> findAllTypesByServiceName(String serviceName)
281            throws RiceIllegalArgumentException {
282        return _findAllTypesByServiceNames (Arrays.asList(serviceName));
283    }
284
285
286    private List<KrmsTypeDefinition> _findAllTypesByServiceNames(List<String> serviceNames)
287            throws RiceIllegalArgumentException {
288        List<KrmsTypeDefinition> list = new ArrayList<KrmsTypeDefinition>();
289        for (KrmsTypeDefinition info : this.krmsTypeMap.values()) {
290            if (serviceNames.contains(info.getServiceName())) {
291                list.add(info);
292            }
293        }
294        return list;
295    }
296    
297    
298    @Override
299    public List<KrmsTypeDefinition> findAllContextTypes() throws RiceIllegalArgumentException {
300        return this.findAllTypesByServiceName(CONTEXT_SERVICE_NAME);
301    }
302
303    @Override
304    public List<KrmsTypeDefinition> findAllAgendaTypes() throws RiceIllegalArgumentException {
305        return this.findAllTypesByServiceName(AGENDA_SERVICE_NAME);
306    }
307
308    @Override
309    public List<KrmsTypeDefinition> findAllRuleTypes() throws RiceIllegalArgumentException {
310        return this.findAllTypesByServiceName(RULE_SERVICE_NAME);
311    }
312
313    @Override
314    public List<KrmsTypeDefinition> findAllPropositionTypes() throws RiceIllegalArgumentException {
315        return this._findAllTypesByServiceNames(Arrays.asList(PROPOSITION_SERVICE_NAMES));
316    }
317
318    @Override
319    public List<KrmsTypeDefinition> findAllPropositionParameterTypes() throws RiceIllegalArgumentException {
320        return this._findAllTypesByServiceNames(Arrays.asList(PROPOSITION_PARAMETER_SERVICE_NAMES));
321    }
322
323    @Override
324    public List<KrmsTypeDefinition> findAgendaTypesForContextType(String contextTypeId) throws RiceIllegalArgumentException {
325        return this._findTypesForType(contextTypeId, Arrays.asList(CONTEXT_SERVICE_NAME), Arrays.asList(AGENDA_SERVICE_NAME));
326    }
327
328    private List<KrmsTypeDefinition> _findTypesForType(String typeId, List<String> fromServiceNames, List<String> toServiceNames)
329            throws RiceIllegalArgumentException {
330        KrmsTypeDefinition fromType = this.getTypeById(typeId);
331        if (fromType == null) {
332            throw new RiceIllegalArgumentException(typeId + " does not exist");
333        }
334        if (!fromServiceNames.contains(fromType.getServiceName())) {
335            throw new RiceIllegalArgumentException(typeId + "'s serviceTypeName is " + fromType.getServiceName() + " expected " + fromServiceNames);
336        }
337        List<TypeTypeRelation> rels = this.findTypeTypeRelationsByFromType(typeId);
338        Collections.sort(rels, new TypeTypeRelationSequenceComparator ());
339        List<KrmsTypeDefinition> list = new ArrayList<KrmsTypeDefinition>(rels.size());
340        for (TypeTypeRelation rel : rels) {
341            KrmsTypeDefinition info = this.getTypeById(rel.getToTypeId());
342            if (toServiceNames.contains(info.getServiceName())) {
343                list.add(info);
344            }
345        }
346        return list;
347    }
348    
349
350    @Override
351    public List<KrmsTypeDefinition> findAgendaTypesForAgendaType(String agendaTypeId) throws RiceIllegalArgumentException {
352        return this._findTypesForType(agendaTypeId, Arrays.asList(AGENDA_SERVICE_NAME), Arrays.asList(AGENDA_SERVICE_NAME));
353    }
354
355    @Override
356    public List<KrmsTypeDefinition> findRuleTypesForAgendaType(String agendaTypeId) throws RiceIllegalArgumentException {
357        return this._findTypesForType(agendaTypeId, Arrays.asList(AGENDA_SERVICE_NAME), Arrays.asList(RULE_SERVICE_NAME));
358    }
359
360    @Override
361    public List<KrmsTypeDefinition> findPropositionTypesForRuleType(String ruleTypeId) throws RiceIllegalArgumentException {
362        return this._findTypesForType(ruleTypeId, Arrays.asList(RULE_SERVICE_NAME), Arrays.asList(PROPOSITION_SERVICE_NAMES));
363    }
364
365    @Override
366    public List<KrmsTypeDefinition> findPropositionParameterTypesForPropositionType(String propositionTypeId)
367            throws RiceIllegalArgumentException {
368        return this._findTypesForType(propositionTypeId, Arrays.asList (PROPOSITION_SERVICE_NAMES), Arrays.asList(PROPOSITION_PARAMETER_SERVICE_NAMES));
369    }
370    
371    @Override
372    public List<KrmsTypeDefinition> findTermParameterTypesForTermPropositionParameterType(String termPropositionParameterTypeId)
373            throws RiceIllegalArgumentException {
374        return this._findTypesForType(termPropositionParameterTypeId, Arrays.asList (TERM_PROPOSITION_PARAMETER_SERVICE_NAME), Arrays.asList(TERM_PARAMETER_SERVICE_NAME));
375    }
376}