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