@Override public FieldType resolveType(EvalContext context) { return value.getTypeClass().createType(); } }
@Override public String toString() { return "FormField{" + "id=" + id + ", label=" + label + ", type=" + type.getTypeClass().getId() + '}'; }
final FieldValueParser stringConverter = converterFactory.createStringConverter(entry.getKey().createType()); final Object convertedValue = stringConverter.convert(value);
public void setType(FieldTypeClass type) { set(IndicatorDTO.TYPE_PROPERTY, type.getId()); }
@Override public FormField create() { FormField formField = new FormField(ResourceId.generateFieldId(typeClass)); formField.setType(typeClass.createType()); formField.setLabel(label); return formField; } }
private FieldTypeClass parseFieldTypeClass(SourceRow row) { String type = formFieldType.get(row); for (FieldTypeClass fieldTypeClass : TypeRegistry.get().getTypeClasses()) { if(fieldTypeClass.getId().equalsIgnoreCase(type)) { return fieldTypeClass; } } return QuantityType.TYPE_CLASS; }
fieldValue = typeClass.createType().parseJsonValue(Json.parse(textValue)); } catch (JsonException e) { LOGGER.severe("Failed to parse indicator " + indicatorId + " with type " + typeClass +
@Override public FieldType resolveResultType(List<FieldType> argumentTypes) { //must be unary or binary function if(argumentTypes.size() == 1) { if(argumentTypes.get(0) instanceof QuantityType) { QuantityType t = (QuantityType) argumentTypes.get(0); return new QuantityType().setUnits(t.getUnits()); } else { throw new InvalidTypeException("Not Real Valued Argument"); } } else if(argumentTypes.size() == 2) { if(argumentTypes.get(0) instanceof QuantityType && argumentTypes.get(1) instanceof QuantityType) { QuantityType t1 = (QuantityType) argumentTypes.get(0); QuantityType t2 = (QuantityType) argumentTypes.get(1); return new QuantityType().setUnits(applyUnits(t1.getUnits(), t2.getUnits())); } else { throw new InvalidTypeException("Cannot compare types " + argumentTypes.get(0).getTypeClass().getId() + " and " + argumentTypes.get(1).getTypeClass().getId()); } } else { throw new FormulaSyntaxException("The " + getLabel() + "() function expects exactly 1 or 2 argument(s)."); } }
private FieldType parseFieldType(SourceRow row) { FieldTypeClass fieldTypeClass = parseFieldTypeClass(row); if(fieldTypeClass == QuantityType.TYPE_CLASS) { return new QuantityType(fieldUnits.get(row)); } else if(fieldTypeClass == ReferenceType.TYPE_CLASS) { return new ReferenceType() .setCardinality(Cardinality.SINGLE) .setRange(parseRange(references.get(row))); } else if(fieldTypeClass == CalculatedFieldType.TYPE_CLASS) { return new CalculatedFieldType(fieldExpression.get(row)); } else { return fieldTypeClass.createType(); } }
private static FieldValue validateType(FormField field, FieldValue updatedValue) { Preconditions.checkNotNull(field); if(updatedValue != null) { if ( !field.getType().isUpdatable()) { throw new InvalidUpdateException( format("Field %s ('%s') is a field of type '%s' and its value cannot be set. Found %s", field.getId(), field.getLabel(), field.getType().getTypeClass().getId(), updatedValue)); } if (!field.getType().getTypeClass().equals(updatedValue.getTypeClass())) { throw new InvalidUpdateException( format("Updated value for field %s ('%s') has invalid type. Expected %s, found %s.", field.getId(), field.getLabel(), field.getType().getTypeClass().getId(), updatedValue.getTypeClass().getId())); } } return updatedValue; }
@Override public FormField asFormField() { FormField field = new FormField(CuidAdapter.indicatorField(getId())); field.setLabel(getName()); field.setDescription(getDescription()); field.setRelevanceConditionExpression(getRelevanceExpression()); field.setRequired(isMandatory()); field.setVisible(isVisible()); String code = getNameInExpression(); if (!Strings.isNullOrEmpty(code)) { field.setCode(code); } if (isCalculated()) { field.setType(new CalculatedFieldType(getExpression())); } else if (Strings.isNullOrEmpty(getTypeId()) || getTypeId().equals(QuantityType.TYPE_CLASS.getId())) { String units = getUnits(); if (units == null) { units = ""; } field.setType(new QuantityType() .setUnits(units) .setAggregation(getAggregation())); } else { field.setType(getType().createType()); } return field; }
private String computeSerialNumberPrefix( FormClass formClass, SerialNumberType type, TypedFormRecord effectiveRecord) { if(!type.hasPrefix()) { return null; } try { FormEvalContext evalContext = new FormEvalContext(formClass); evalContext.setInstance(effectiveRecord); FormulaNode formula = FormulaParser.parse(type.getPrefixFormula()); FieldValue prefixValue = formula.evaluate(evalContext); if(prefixValue instanceof TextValue) { return ((TextValue) prefixValue).asString(); } else { throw new IllegalStateException("Prefix " + type.getPrefixFormula() + " resolves to type " + prefixValue.getTypeClass().getId()); } } catch (Exception e) { LOGGER.log(Level.SEVERE, "Failed to compute prefix for serial number", e); return null; } }
field.setType(((ParametrizedFieldTypeClass) typeClass).deserializeType(typeParameters)); } else { field.setType(typeClass.createType());
public static ConstantNode valueOf(FieldValue value) { if(value instanceof TextValue) { return new ConstantNode(((TextValue) value).asString()); } else if(value instanceof BooleanFieldValue) { return new ConstantNode(value == BooleanFieldValue.TRUE); } else if(value instanceof Quantity) { return new ConstantNode(value, new QuantityType()); } else if (value instanceof EnumValue) { return new ConstantNode(value, new EnumType()); } else { throw new IllegalArgumentException(value.getTypeClass().getId()); } }
private void dump(String indent, FormElementContainer container) { for(FormElement element : container.getElements()) { if(element instanceof FormSection) { System.out.println(indent + element.getLabel()); dump(indent + " ", ((FormSection) element)); } else { FormField field = ((FormField) element); System.out.println(String.format("%s[%s] %s : %s", indent, field.getCode(), field.getLabel(), field.getType().getTypeClass().getId())); } } }
@Override public JsonValue toJsonObject() { JsonValue object = createObject(); object.put("id", id.asString()); object.put("code", code); object.put("label", label); object.put("description", description); object.put("relevanceCondition", relevanceConditionExpression); object.put("visible", visible); object.put("required", required); object.put("type", type.getTypeClass().getId()); if(key) { object.put("key", true); } if(!superProperties.isEmpty()) { JsonValue superPropertiesArray = Json.createArray(); for (ResourceId superProperty : superProperties) { superPropertiesArray.add(Json.createFromNullable(superProperty.asString())); } object.put("superProperties", superPropertiesArray); } if(type instanceof ParametrizedFieldType) { object.put("typeParameters", ((ParametrizedFieldType) type).getParametersAsJson()); } return object; }
private void insertIndicatorRow(FormField formField, int sortOrder) { SqlInsert insert = SqlInsert.insertInto("indicator"); insert.value("indicatorId", CuidAdapter.getLegacyIdFromCuid(formField.getId())); insert.value("activityId", activityId); insert.value("name", formField.getLabel()); insert.value("nameInExpression", formField.getCode()); insert.value("description", formField.getDescription()); if(formField.getType() instanceof QuantityType) { insert.value("aggregation",((QuantityType) formField.getType()).getAggregation().ordinal()); } else { insert.value("aggregation",0); } insert.value("sortOrder", sortOrder); insert.value("type", formField.getType().getTypeClass().getId()); insert.value("mandatory", formField.isRequired()); if(formField.getType() instanceof QuantityType) { QuantityType quantityType = (QuantityType) formField.getType(); insert.value("units", quantityType.getUnits()); } if(formField.getType() instanceof CalculatedFieldType) { CalculatedFieldType type = (CalculatedFieldType) formField.getType(); insert.value("calculatedAutomatically", true); insert.value("expression", type.getExpression()); } insert.execute(executor); }