protected void parseTag(String expr) { if(Strings.isNotEmpty(expr)){ op.addTag(expr); } }
protected void parseTags(String expr) { if(Strings.isNotEmpty(expr)){ String[] tags = Strings.split(expr,","); for(String tag : tags){ if(Strings.isNotEmpty(tag)){ op.addTag(tag.trim()); } } } }
@Init public void init() { if (Strings.isNotEmpty(hostAndPort)) { pool = createJedisPool(); } if (pool == null && Strings.isNotEmpty(sentinelHostAndPorts) && Strings.isNotEmpty(sentinelMasterName)) { pool = createSentinelPool(); } if(null == pool) { throw new IllegalStateException("The properties 'hostAndPort' or 'sentinelHostAndPorts' must be configured!"); } }
protected Cipher initCipher(String key, String iv, int mode) throws InvalidKeySpecException, InvalidKeyException { try { DESedeKeySpec dks = new DESedeKeySpec(key.getBytes(Charsets.UTF_8)); SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede"); SecretKey securekey = keyFactory.generateSecret(dks); Cipher cipher = Cipher.getInstance(cipherType); if(Strings.isNotEmpty(iv)){ SecureRandom sr = new SecureRandom(); IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes(Charsets.UTF_8)); cipher.init(mode, securekey, ivSpec, sr); }else { cipher.init(mode, securekey); } return cipher; } catch (InvalidAlgorithmParameterException | NoSuchPaddingException | NoSuchAlgorithmException e) { throw new RuntimeException(e); } } }
public static Map<String, String> queryStringToMap(String queryString){ Map<String, String> map = New.hashMap(); if(Strings.isNotEmpty(queryString)){ String[] kvs = Strings.split(queryString,'&'); for(String kvStr : kvs){ int idx = kvStr.indexOf('='); if(idx < 0){ map.put(kvStr.trim(),null); }else if(idx >= kvStr.length()){ String k = kvStr.substring(0,idx); map.put(k,null); }else { String k = kvStr.substring(0,idx); String v = kvStr.substring(idx+1); map.put(k,v); } } } return map; }
private Pool<Jedis> createJedisPool() { String uri; if (Strings.isNotEmpty(password)) { uri = Strings.format("redis://:{0}@{1}", password, hostAndPort); } else { uri = Strings.format("redis://{0}", hostAndPort); } if (database != 1) { uri = uri + "/" + database; } return new JedisPool(checkPoolConfig(), URI.create(uri), timeout); }
@Override public List<String> getCreateColumnSqls(DbSchemaObjectName tableName, DbColumn column) { List<String> sqls = New.arrayList(); StringBuilder sql = new StringBuilder("ALTER TABLE "); sql.append(qualifySchemaObjectName(tableName)); sql.append(" ADD ("); sql.append(getColumnDefinitionForAlterTable(column)); sql.append(")"); sqls.add(sql.toString()); if(Strings.isNotEmpty(column.getComment())){ sqls.addAll(getCommentOnColumnSqls(tableName,column.getName(),column.getComment())); } return sqls; } @Override
@Override public void postLoadConfig(AppConfigContext context) { ApiConfigs configs = context.getExtension(ApiConfigs.class); if (configs != null) { configs.getApis().forEach((k, v) -> { String basePackage = v.config().getBasePackage(); if (Strings.isNotEmpty(basePackage)) { context.getAdditionalPackages().add(basePackage); } }); } }
@Override public void postProcess(ApiMetadataContext context, ApiMetadataBuilder m) { String desc = m.getDescription(); if(Strings.isNotEmpty(desc)) { m.setDescription(docResolver.resolveDesc(desc)); } Map<Class<?>,ClassDoc> docs = new HashMap<>(); //operations m.getPaths().forEach((k, p) -> { p.getOperations().forEach(o -> { processOperation(context, docs, o); }); }); //models m.getModels().forEach((k, model) -> { processModel(context, docs, model); }); }
protected void applyOrderBy(CriteriaQuery query, OrderBy orderBy) { OrderBy.Item[] items = orderBy.items(); StringBuilder s = new StringBuilder(); for (int i = 0; i < items.length; i++) { if (i > 0) { s.append(','); } OrderBy.Item item = items[i]; String name = item.name(); MApiProperty ap = am.tryGetProperty(name); if (null == ap) { throw new BadRequestException("Property '" + name + "' not exists in model '" + am.getName() + "'"); } if (ap.isNotSortableExplicitly()) { throw new BadRequestException("Property '" + name + "' is not sortable!"); } if (Strings.isNotEmpty(query.alias())) { s.append(query.alias() + "." + name); } else { s.append(name); } if (!item.isAscending()) { s.append(" desc"); } } query.orderBy(s.toString()); }
@Override public String resolveUserAgentForwarded(Request request) { if(isProxyRequest(request)){ String host = request.getHeader(X_FORWARDED_HOST); if(Strings.isNotEmpty(host)){ String protocol = resolveProtocol(request); if(Strings.isEmpty(protocol)){ protocol = "http"; } protocol += "://"; return protocol + host + request.getContextPath(); }else{ return host + request.getContextPath(); } }else{ throw new IllegalStateException("this request is not a proxied request"); } }
@Override public String resolveUserAgentForwarded(Request request) { if(isProxyRequest(request)){ String host = request.getHeader(X_FORWARDED_HOST); if(Strings.isNotEmpty(host)){ String protocol = resolveProtocol(request); if(Strings.isEmpty(protocol)){ protocol = "http"; } protocol += "://"; return protocol + host + request.getContextPath(); }else{ return host + request.getContextPath(); } }else{ throw new IllegalStateException("this request is not a proxied request"); } }
@Override public int count(CountOptions options) { String op = "/count"; HttpRequest request = httpClient.request(buildOperationPath(op)) .ajax() .setMethod(Method.GET); if (options != null && Strings.isNotEmpty(options.getFilters())) { request.addQueryParam("filters", options.getFilters()); } Integer val = send(Integer.class, request, getAccessToken()); return val == null ? 0 : val.intValue(); }
return request; if (Strings.isNotEmpty(queryOptions.getSelect())) { request.addQueryParam("select", queryOptions.getSelect()); if (Strings.isNotEmpty(queryOptions.getExpand())) { request.addQueryParam("expand", queryOptions.getExpand()); request.addQueryParam("total", "true"); if (Strings.isNotEmpty(qo.getOrderBy())) { request.addQueryParam("orderBy", qo.getOrderBy()); if (Strings.isNotEmpty(qo.getFilters())) { request.addQueryParam("filters", qo.getFilters()); if (Strings.isNotEmpty(qo.getJoins())) { request.addQueryParam("joins", qo.getJoins());
protected void addOrUpdateWebModule(AppConfigContext context, ApiConfigurator api) { ApiConfig ac = api.config(); String basePackage = ac.getBasePackage(); if (Strings.isNotEmpty(basePackage)) { context.getAdditionalPackages().add(basePackage); String moduleName = ac.getName() + "_api"; DefaultModuleConfig module = new DefaultModuleConfig(); module.setName(moduleName); module.setBasePath(ac.getBasePath()); module.setBasePackage(ac.getBasePackage()); ModuleConfigExtension extension = context.getOrCreateExtension(ModuleConfigExtension.class); extension.setModule(module); } }
protected BeanDefinitionBase findBeanDefinition(BeanReference br){ if(Strings.isNotEmpty(br.getTargetId())){ return findBeanDefinition(br.getTargetId()); } if(Strings.isEmpty(br.getBeanName())) { return findPrimaryBeanDefinition(br.getBeanType()); }else{ return findBeanOrAliasDefinition(br.getBeanType(),br.getBeanName()); } }
protected ValueDefinition readRefElement(LoaderContext context, XmlReader reader) { String refId = reader.resolveAttribute(ID_ATTRIBUTE); String refType = reader.resolveAttribute(TYPE_ATTRIBUTE); String refName = reader.resolveAttribute(NAME_ATTRIBUTE); if (Strings.isAllEmpty(refId, refType, refName)) { throw new BeanDefinitionException("Invalid bean reference in '" + reader.getCurrentLocation() + "'"); } if (Strings.isNotEmpty(refName) && Strings.isEmpty(refType)) { throw new BeanDefinitionException("The referenced type must be exists in '" + reader.getCurrentLocation() + "'"); } return tryCreateBeanReference(context, reader, refId, refType, refName); }
protected Object readModel(OrmContext context,ResultSet rs,ResultSetMapping rsm,Class<? extends Model> modelClass) throws SQLException { Model model = Reflection.newInstance(modelClass); model.init(context, rsm.getPrimaryEntityMapping()); DbDialect dialect = context.getDb().getDialect(); for(int i=0;i<rsm.getColumnCount();i++){ ResultColumnMapping cm = rsm.getColumnMapping(i); FieldMapping fm = cm.getFieldMapping(); String name = null != fm ? fm.getFieldName() : cm.getNormalizedName(); Object value = readColumnValue(dialect, rs, cm, fm, i+1); model.set(name, value); if(Strings.isNotEmpty(cm.getAliasName()) && !name.equals(cm.getAliasName())){ model.set(cm.getAliasName(), value); } } return model; }
if (response.is2xx()) { List<T> list = new ArrayList<>(); if (Strings.isNotEmpty(content) && ContentTypes.APPLICATION_JSON_TYPE.isCompatible(response.getContentType())) { list = (List<T>) decode(targetType, content);
public RestResource build() { DefaultRestResource res = AppContext.factory().inject(new DefaultRestResource(entityMapping)); res.setPreSendHandler(this.preSendHandler); res.setPostSendHandler(this.postSendHandler); if(accessToken!=null){ res.setAccessToken(accessToken); } if (entityMapping != null) { RestDatasourceManager manager = getDataSourceManager(); RestDataSource ds = manager.tryGetDataSource(entityMapping.getRemoteSettings().getDataSource()); String basePath = entityMapping.getRemoteSettings().getEndpoint(); if (ds != null && Strings.isNotEmpty(ds.getEndpoint())) { basePath = ds.getEndpoint(); } if (Strings.isNotEmpty(basePath)) { String url = Paths.suffixWithSlash(basePath) + entityMapping.getRemoteSettings().getRelativePath(); res.setEndpoint(url); } } if (Strings.isNotBlank(endpoint)) { res.setEndpoint(endpoint); } if (Strings.isEmpty(res.getEndpoint())) { throw new RuntimeException("can't build rest resource,when endpoint or entityMapping is empty!"); } res.setEndpoint(formatApiEndPoint(res.getEndpoint())); return res; }