@Override public String entityName(String entityName) { return Strings.upperFirst(entityName); }
@Override public String getFieldNameForNewValue(String fieldName) { return "new" + Strings.upperFirst(fieldName); }
private String nameToTitle(String name) { StringBuilder buf = new StringBuilder(name); for (int i = 1; i < buf.length() - 1; i++) { char p = buf.charAt(i - 1); if ( (Character.isLowerCase(p) || Character.isDigit(p)) && Character.isUpperCase(buf.charAt(i)) && Character.isLowerCase(buf.charAt(i + 1)) ) { buf.insert(i++, ' '); } } return Strings.upperFirst(buf.toString()); }
@Override public String getLocalFieldName(String referencedEntityName, String referencedFieldName) { return Strings.lowerFirst(referencedEntityName) + Strings.upperFirst(referencedFieldName); }
public static String nameToTitle(String name) { if(name.indexOf('-') < 0 && name.indexOf('_') < 0) { name = Strings.lowerUnderscore(name); } String[] parts = Strings.split(name, '_', '-'); StringBuilder s = new StringBuilder(); for(int i=0;i<parts.length;i++) { if(i > 0) { s.append(' '); } if(i == 0) { s.append(Strings.upperFirst(parts[i])); }else { s.append(parts[i]); } } return s.toString(); }
private ReflectMethod findGetter(){ String fieldName = field.getName().startsWith("_") ? field.getName().substring(1) : field.getName(); String nameToFind = "get" + Character.toUpperCase(fieldName.charAt(0)) + (fieldName.length() > 1 ? fieldName.substring(1) : ""); Class<?> fieldType = Primitives.wrap(field.getType()); ReflectMethod m = findGetter(fieldType,nameToFind); if(null == m && Classes.isBoolean(fieldType)){ if(fieldName.startsWith("is") && fieldName.length() > 2){ if(Boolean.class.equals(field.getType())){ nameToFind = "get" + Strings.upperFirst(fieldName.substring(2)); if(null != (m = findGetter(fieldType, nameToFind))){ return m; } } nameToFind = fieldName; }else{ nameToFind = "is" + Character.toUpperCase(fieldName.charAt(0)) + (fieldName.length() > 1 ? fieldName.substring(1) : ""); } m = findGetter(fieldType,nameToFind); } return m; }
public PatternValidator(String name, java.util.regex.Pattern pattern){ Args.notEmpty(name,"name"); Args.notNull(pattern,"pattern"); this.name = name; this.pattern = pattern; this.errorCode = "invalid" + Strings.upperFirst(name); }
String id = name + "With" + Strings.upperFirst(method); if (trySetUniqueOperationId(m, op, id)) { return true; if(!name.toLowerCase().contains(tag.toLowerCase())) { String id = name + Strings.upperFirst(tag); id = id + "With" + Strings.upperFirst(method); if(trySetUniqueOperationId(m, op, id)) { return true;
public PatternValidator(Pattern constraint, Class<?> valueType) { super(constraint, valueType); this.name = constraint.name(); if(!Strings.isEmpty(constraint.regexp())){ this.pattern = compile(constraint); }else{ this.pattern = MD.getMPattern(name).getPattern(); } this.errorCode = "invalid" + Strings.upperFirst(name); }
protected void verifyManyToOneJoinFields(MappingConfigContext context, EntityMappingBuilder emb, EntityMappingBuilder targetEmb, List<FieldMappingBuilder> referencedFields, RelationMappingBuilder rmb) { List<JoinFieldMappingBuilder> joinFields = rmb.getJoinFields(); if(joinFields.size() != referencedFields.size()) { throw new MetadataException("The size of 'JoinField' must equals to size of key fields in target entity '" + targetEmb.getEntityName() + "'"); } for(JoinFieldMappingBuilder jf : joinFields) { if(Strings.isEmpty(jf.getReferencedFieldName())){ if(referencedFields.size() == 1) { jf.setReferencedFieldName(referencedFields.get(0).getFieldName()); }else { //guess the referenced name String referencedFieldName = null; for(FieldMappingBuilder ref : referencedFields){ if(jf.getLocalFieldName().endsWith(Strings.upperFirst(ref.getFieldName()))){ referencedFieldName = ref.getFieldName(); break; } } if(null == referencedFieldName){ throw new MetadataException("Cannot determinate the referenced field name of join field '" + jf.getLocalFieldName() + "' in entity '" + emb.getEntityName() + "'"); } jf.setReferencedFieldName(referencedFieldName); } } } }
public MetaModel read(Resource file) { String content = file.getContent().trim(); if (content.length() == 0) { return null; } String name = Strings.upperFirst(Paths.getFileNameWithoutExtension(file.getFilename())); JsonObject o = JSON.parse(file.getContent()).asJsonObject(); if(o.asMap().isEmpty()) { return null; } MetaModel model = JSON.convert(o.asMap(), MetaModel.class); if (!Strings.isEmpty(model.getClassName())) { Class<?> c = Classes.tryForName(model.getClassName()); if (null == c) { throw new IllegalStateException("Model class '" + model.getClassName() + "' not found!"); } MType type = MTypes.getMType(c); if (!type.isComplexType()) { throw new IllegalStateException("The model class '" + model.getClassName() + "' must be complex type!"); } MetaUtils.tryCopyModel(type.asComplexType(), model); } MApiModelBuilder am = nonValidateSwaggerReader.readModel(name, o.asMap(), new SwaggerTypeEx()); MetaUtils.tryCopyModel(am, model); validator.validate("Model(" + model.getName() + ")", model); return model; }
protected MetaParameterSet readParamSet(Resource resource) { OperationParser parser = new OperationParser(resource.getContent()).parseComment(); if(parser.isIgnore()) { return null; } String name = Strings.upperFirst(Paths.getFileNameWithoutExtension(resource.getFilename())); MetaParameterSet ps = new MetaParameterSet(); withSource(ps, resource); ps.setName(name); ps.setClassNames(parser.getMappingClassNames()); for(String className : ps.getClassNames()) { Class<?> cls = Classes.tryForName(className); if (null == cls) { throw new IllegalStateException("Invalid mapping class name '" + className + "'"); } } MetaOperation op = parser.getOperation(); if(null != op) { ps.setItems(op.getParameters()); } return ps; }
public void readResponseSet(MetaApi api, Resource resource) { String name = Strings.upperFirst(Paths.getFileNameWithoutExtension(resource.getFilename())); MetaResponseSet rs = new MetaResponseSet(); withSource(rs, resource); rs.setName(name); OperationParser parser = new OperationParser(resource.getContent()).parseComment(); if(parser.isIgnore()) { return; } MetaOperation op = parser.getOperation(); if(null != op) { rs.setItems(op.getResponses()); } api.addResponseSet(rs); }
String setByStringMethodName = "set" + Strings.upperFirst(bp.getName()) + "ByString"; ReflectMethod setByStringMethod = bt.getReflectClass().getMethod(setByStringMethodName, new Class<?>[]{String.class});
public void read(MetaApi api, Resource resource) { String content = resource.getContent(); if(Strings.isEmpty(content)) { return; } String filenameWithoutExt = Paths.getFileNameWithoutExtension(resource.getFilename()); MetaOptionSet os = JSON.decode(content, MetaOptionSet.class); if(Strings.isEmpty(os.getName())) { os.setName(Strings.upperFirst(filenameWithoutExt)); } withSource(os, resource); validator.validate(os); MetaOptionSet exists = api.getOptionSet(os.getName()); if(exists != null) { if(!exists.isReadFromMetaInf()) { log.error("Option Set {} exist, skip file:{}",os.getName(),os.getSource()); return; }else { log.info("Override the exists option set '{}' by {}", os.getName(), os.getSource()); } } api.addOptionSet(os); }