protected void checkNotExist(Class<?> entityClass) throws ObjectExistsException { if(null != entityClass){ if(classToEntityMappings.containsKey(entityClass)){ throw new ObjectExistsException("Entity class '" + entityClass.getName() + "' aleady exists"); } } } }
@Override public void registerDataSource(String name, RestDataSource ds) throws ObjectExistsException { synchronized (this) { if(allDataSources.containsKey(name)) { throw new ObjectExistsException("DataSource '" + name + "' already exists!"); } allDataSources.put(name, ds); } }
@Override public void registerContext(OrmContext context, String alias) throws ObjectExistsException { String key = alias.toLowerCase(); if(contexts.containsKey(key)) { throw new ObjectExistsException("Orm context '" + alias + "' already exists!"); } contexts.put(key, context); }
public <T> void command(String name, Class<T> type, boolean required, Function<T,Object> handler) { if(commands.containsKey(name)) { throw new ObjectExistsException(("Command '" + name + "' already exists!")); } commands.put(name, new CliCommand(type, required, handler)); }
public void addOperation(Operation op) { String key = op.getName().toLowerCase(); if(operations.containsKey(key)) { throw new ObjectExistsException("The operation '" + op.getName() + "' of model '" + name + "' already exists!"); } operations.put(key, op); } }
@Override public void addDomainAlias(String name, String alias) { Domain domain = tryGetDomain(name); if(null == domain) { throw new ObjectNotFoundException("The domain '" + name + "' not exists!"); } String key = alias.toLowerCase(); if(domainAliases.containsKey(key)) { throw new ObjectExistsException("The alias '" + alias + "' already exists!"); } domainAliases.put(key, domain); }
public void addModel(Model model) { String key = model.getName().toLowerCase(); if(models.containsKey(key)) { throw new ObjectExistsException("The configuration of model '" + model.getName() + "' already exists!"); } models.put(key, model); }
public <T> void command(String name, Class<T> type, boolean required, Consumer<T> handler) { if(commands.containsKey(name)) { throw new ObjectExistsException(("Command '" + name + "' already exists!")); } commands.put(name, new CliCommand(type, required, (params) -> { handler.accept((T)params); return null; })); }
@Override public void addSqlCommand(String key,SqlCommand cmd) throws ObjectExistsException { Args.notEmpty(key,"command key"); Args.notNull(cmd,"sql command"); synchronized (_sqlLock) { if(keyToSqlCommands.containsKey(key)){ throw new ObjectExistsException("sql command '" + key + "' aleady exists"); } keyToSqlCommands.put(key, cmd); } }
@Override public void registerCache(String name, Cache<?, ?> cache) throws ObjectExistsException { Args.notEmpty(name,"cache name"); Args.notNull(cache,"cache"); if(caches.containsKey(name)){ throw new ObjectExistsException("The cache '" + name + "' already exists"); } caches.put(name, cache); }
@Override public void addSqlFragment(String key, SqlFragment fragment) throws ObjectExistsException { Args.notEmpty(key,"fragment key"); Args.notNull(fragment,"sql fragment"); if(fragmentsMap.containsKey(key)){ throw new ObjectExistsException("The sql fragment '" + key + "' already exists"); } fragmentsMap.put(key, fragment); }
@Override public void addDomain(Domain domain, boolean override) throws ObjectExistsException { String key = domain.getName().toLowerCase(); if(!override) { Domain existsDomain = domains.get(key); //domain without kind can override exists domain with kind if (null != existsDomain) { throw new ObjectExistsException("The to be added domain '" + domain.getName() + "' already exists, check the source : " + domain.getSource()); } } domains.put(key, domain); }
public void addField(MetaField field) throws ObjectExistsException { if(fields.containsKey(field.getName())) { throw new ObjectExistsException("Field '" + field.getName() + "' already exists in entity '" + name + "'"); } fields.put(field.getName(), field); }
public void addEntity(MetaEntity entity) throws ObjectExistsException { if (entities.containsKey(entity.getName())) { throw new ObjectExistsException("Entity '" + entity.getName() + "' already exists in api '" + name + "'"); } entities.put(entity.getName(), entity); }
public void addRelation(MetaRelation relation) throws ObjectExistsException { if(relations.containsKey(relation.getName())) { throw new ObjectExistsException("Relation '" + relation.getName() + "' already exists in entity '" + name + "'"); } relations.put(relation.getName(), relation); }
@Override public void addListener(DataSourceListener listener) { if(listeners.contains(listener)){ throw new ObjectExistsException("The listener already exists"); } listeners.add(listener); }
public EntityMappingBuilder addRelationProperty(RelationPropertyBuilder p) { if (null != getRelationProperty(p.getName())) { throw new ObjectExistsException("The relation property '" + p.getName() + "' already exists in entity '" + entity() + "'"); } relationProperties.add(p); return this; }
public EntityMappingBuilder addKey(UniqueKeyBuilder key) { if (null != getKey(key.getName())) { throw new ObjectExistsException("Unique key '" + key.getName() + "' already exists in entity '" + entity() + "'"); } keys.add(key); return this; }
protected void checkDuplicate(ApiConfig c) { String key = c.getName().toLowerCase(); if(apis.containsKey(key)) { throw new ObjectExistsException("The api '" + c.getName() + "' already exists"); } apis.values().forEach(api -> { if(Strings.equalsIgnoreCase(api.getBasePath(),c.getBasePath())){ throw new ApiConfigException("Found duplicated api config with base path: " + c.getBasePath() + " in " + api.getConfig().getSource() + " and " + c.getSource()); } }); }
public EntityMappingBuilder addRelationMapping(RelationMappingBuilder relationMapping) { //check exists if (!Strings.isEmpty(relationMapping.getName()) && null != getRelationMapping(relationMapping.getName())) { throw new ObjectExistsException("The relation '" + relationMapping.getName() + "' already exists in entity '" + entity() + "'"); } relationMappings.add(relationMapping); return this; }