/**
* This is a helper method extracts and validates the information contained in the schema stub for
* this schema.
*
* @param schemaStub The schema stub to extract information from and validate.
* @throws JSONException This exception is thrown if there is an error processing the provided
* JSON schemaStub.
*/
private void setSchemaStub(String schemaStub) throws JSONException {
JSONObject jo = new JSONObject(schemaStub);
SchemaUtils.checkValidKeysEx(jo, VALID_KEYS);
JSONObject tempTime = jo.getJSONObject(FIELD_TIME);
SchemaUtils.checkValidKeys(jo, VALID_TIME_KEYS);
this.from = tempTime.getLong(FIELD_TIME_FROM);
this.to = tempTime.getLong(FIELD_TIME_TO);
}
@Override
public void checkSchema(ResourceSchema schema) throws IOException {
SchemaUtils.claim(
schema,
0,
DataType.INTEGER,
DataType.CHARARRAY,
DataType.UNKNOWN); // the part name (usually will be int, but generally accept any type)
ResourceSchema.ResourceFieldSchema bag = SchemaUtils.claim(schema, 1, DataType.BAG); // the bag
ResourceSchema.ResourceFieldSchema tuple =
SchemaUtils.claim(bag, 0, DataType.TUPLE); // the tuple of (id, vector)
SchemaUtils.claim(tuple, 0, DataType.INTEGER); // the id
tuple = SchemaUtils.claim(tuple, 1, DataType.TUPLE); // the vector
Env.setProperty(
GroupedVectorStore.class, "vector.type", VectorUtils.typeOfVector(tuple.getSchema()));
}
public Element exec(Element params, ServiceContext context) throws Exception {
GeonetContext gc = (GeonetContext) context.getHandlerContext(Geonet.CONTEXT_NAME);
SchemaManager scm = gc.getBean(SchemaManager.class);
String schema = Util.getParam(params, Params.SCHEMA);
String urlStr, uuid, fname;
uuid = "";
URL url = null;
// -- try the file name argument then the url then the uuid of a metadata
// -- record to which a schema is attached
fname = Util.getParam(params, Params.FNAME, "");
if ("".equals(fname)) {
urlStr = Util.getParam(params, Params.URL, "");
if ("".equals(urlStr)) {
uuid = Util.getParam(params, Params.UUID, "");
if ("".equals(uuid)) {
throw new IllegalArgumentException("One of fname, url or uuid must be supplied");
}
} else {
try {
url = new URL(urlStr);
} catch (MalformedURLException mu) {
throw new OperationAbortedEx("URL " + urlStr + " is malformed: " + mu.getMessage());
}
}
}
// -- test if schema to be updated exists, if not then chuck a fit and exit
if (!scm.existsSchema(schema)) {
throw new OperationAbortedEx("Schema doesn't exist");
}
SchemaUtils su = new SchemaUtils();
return su.updateSchema(context, schema, fname, url, uuid, scm);
}
@Override
public String getSchemaJSON() {
if (!changed && schemaJSON != null) {
return schemaJSON;
}
if (schemaKeys == null) {
schema.remove(Schema.FIELD_SCHEMA_KEYS);
} else {
try {
schema.put(Schema.FIELD_SCHEMA_KEYS, SchemaUtils.createJSONObject(schemaKeys));
} catch (JSONException ex) {
throw new RuntimeException(ex);
}
}
schemaJSON = schema.toString();
return schemaJSON;
}
/**
* This is a helper method to initialize the schema.
*
* @throws JSONException This exception is thrown if there is an error parsing the JSON which
* specified this schema.
*/
private void initialize() throws JSONException {
schema = new JSONObject(schemaJSON);
Preconditions.checkState(
schema.length() == NUM_KEYS_FIRST_LEVEL,
"Expected "
+ NUM_KEYS_FIRST_LEVEL
+ " keys in the first level but found "
+ schema.length());
if (schemaKeys != null) {
schema.put(Schema.FIELD_SCHEMA_KEYS, SchemaUtils.createJSONObject(schemaKeys));
}
valueToType = Maps.newHashMap();
JSONArray values = schema.getJSONArray(FIELD_VALUES);
Preconditions.checkState(values.length() > 0, "The schema does not specify any values.");
for (int index = 0; index < values.length(); index++) {
JSONObject value = values.getJSONObject(index);
String name = value.getString(FIELD_VALUES_NAME);
String typeName = value.getString(FIELD_VALUES_TYPE);
Type type = Type.NAME_TO_TYPE.get(typeName);
valueToType.put(name, type);
Preconditions.checkArgument(type != null, typeName + " is not a valid type.");
}
valueToType = Collections.unmodifiableMap(valueToType);
valuesDescriptor = new FieldsDescriptor(valueToType);
try {
schema.put(FIELD_SCHEMA_TYPE, SCHEMA_TYPE);
schema.put(FIELD_SCHEMA_VERSION, SCHEMA_VERSION);
} catch (JSONException e) {
throw new RuntimeException(e);
}
schemaJSON = this.schema.toString();
}
@Override
public String getSchemaJSON() {
if (!changed && schemaJSON != null) {
// If there are no changes, return the pre computed JSON
return schemaJSON;
}
if (changedSchemaKeys) {
// If the schema keys change, recompute the schema keys portion of the JSON
changedSchemaKeys = false;
if (schemaKeys == null) {
schema.remove(Schema.FIELD_SCHEMA_KEYS);
} else {
try {
schema.put(Schema.FIELD_SCHEMA_KEYS, SchemaUtils.createJSONObject(schemaKeys));
} catch (JSONException ex) {
throw new RuntimeException(ex);
}
}
}
if (changedFromTo) {
// If the from to times have changed then recompute the time portion of the schema.
changedFromTo = false;
Preconditions.checkState(
!(from == null ^ to == null),
"Either both from and to should be set or both should be not set.");
if (from != null) {
Preconditions.checkState(
to >= from, "to {} must be greater than or equal to from {}.", to, from);
}
if (from == null) {
time.remove(FIELD_TIME_FROM);
time.remove(FIELD_TIME_TO);
} else {
try {
time.put(FIELD_TIME_FROM, from);
time.put(FIELD_TIME_TO, to);
} catch (JSONException ex) {
throw new RuntimeException(ex);
}
}
}
if (this.areEnumsUpdated) {
// If the enums have been updated, recompute the key portion of the schema.
for (int keyIndex = 0; keyIndex < keys.length(); keyIndex++) {
JSONObject keyData;
String name;
try {
keyData = keys.getJSONObject(keyIndex);
name = keyData.getString(DimensionalConfigurationSchema.FIELD_KEYS_NAME);
} catch (JSONException ex) {
throw new RuntimeException(ex);
}
List<Object> enumVals = currentEnumVals.get(name);
if (enumVals == null || enumVals.isEmpty()) {
keyData.remove(DimensionalConfigurationSchema.FIELD_KEYS_ENUMVALUES);
continue;
}
JSONArray newEnumValues = new JSONArray();
for (Object enumVal : enumVals) {
newEnumValues.put(enumVal);
}
try {
keyData.put(DimensionalConfigurationSchema.FIELD_KEYS_ENUMVALUES, newEnumValues);
} catch (JSONException ex) {
throw new RuntimeException(ex);
}
}
this.areEnumsUpdated = false;
}
// Rebuild the schema JSON string.
schemaJSON = schema.toString();
return schemaJSON;
}
/**
* Initializes the schema JSON and schema metadata.
*
* @throws JSONException This exception is thrown when there is an exception building the schema
* for the AppData dimensions schema.
*/
private void initialize() throws JSONException {
schema = new JSONObject();
if (schemaKeys != null) {
schema.put(Schema.FIELD_SCHEMA_KEYS, SchemaUtils.createJSONObject(schemaKeys));
}
schema.put(SnapshotSchema.FIELD_SCHEMA_TYPE, DimensionalSchema.SCHEMA_TYPE);
schema.put(SnapshotSchema.FIELD_SCHEMA_VERSION, DimensionalSchema.SCHEMA_VERSION);
if (!configurationSchema.getTags().isEmpty()) {
schema.put(FIELD_TAGS, new JSONArray(configurationSchema.getTags()));
}
// time
time = new JSONObject();
schema.put(FIELD_TIME, time);
JSONArray bucketsArray = new JSONArray(configurationSchema.getBucketsString());
time.put(FIELD_TIME_BUCKETS, bucketsArray);
time.put(FIELD_SLIDING_AGGREGATE_SUPPORTED, true);
// keys
keys = new JSONArray(configurationSchema.getKeysString());
for (int keyIndex = 0; keyIndex < keys.length(); keyIndex++) {
JSONObject keyJo = keys.getJSONObject(keyIndex);
String keyName = keyJo.getString(DimensionalConfigurationSchema.FIELD_KEYS_NAME);
List<String> tags = configurationSchema.getKeyToTags().get(keyName);
if (!tags.isEmpty()) {
keyJo.put(FIELD_TAGS, new JSONArray(tags));
}
}
schema.put(DimensionalConfigurationSchema.FIELD_KEYS, keys);
// values
JSONArray values = new JSONArray();
schema.put(SnapshotSchema.FIELD_VALUES, values);
FieldsDescriptor inputValuesDescriptor = configurationSchema.getInputValuesDescriptor();
Map<String, Map<String, Type>> allValueToAggregator =
configurationSchema.getSchemaAllValueToAggregatorToType();
for (Map.Entry<String, Map<String, Type>> entry : allValueToAggregator.entrySet()) {
String valueName = entry.getKey();
for (Map.Entry<String, Type> entryAggType : entry.getValue().entrySet()) {
String aggregatorName = entryAggType.getKey();
Type outputValueType = entryAggType.getValue();
JSONObject value = new JSONObject();
String combinedName =
valueName + DimensionalConfigurationSchema.ADDITIONAL_VALUE_SEPERATOR + aggregatorName;
value.put(SnapshotSchema.FIELD_VALUES_NAME, combinedName);
value.put(SnapshotSchema.FIELD_VALUES_TYPE, outputValueType.getName());
List<String> tags = configurationSchema.getValueToTags().get(valueName);
if (!tags.isEmpty()) {
value.put(FIELD_TAGS, new JSONArray(tags));
}
values.put(value);
}
}
JSONArray dimensions = new JSONArray();
for (int combinationID = 0;
combinationID < configurationSchema.getDimensionsDescriptorIDToKeys().size();
combinationID++) {
Fields fields = configurationSchema.getDimensionsDescriptorIDToKeys().get(combinationID);
Map<String, Set<String>> fieldToAggregatorAdditionalValues =
configurationSchema
.getDimensionsDescriptorIDToFieldToAggregatorAdditionalValues()
.get(combinationID);
JSONObject combination = new JSONObject();
JSONArray combinationArray = new JSONArray();
for (String field : fields.getFields()) {
combinationArray.put(field);
}
combination.put(
DimensionalConfigurationSchema.FIELD_DIMENSIONS_COMBINATIONS, combinationArray);
if (!fieldToAggregatorAdditionalValues.isEmpty()) {
JSONArray additionalValueArray = new JSONArray();
for (Map.Entry<String, Set<String>> entry : fieldToAggregatorAdditionalValues.entrySet()) {
String valueName = entry.getKey();
for (String aggregatorName : entry.getValue()) {
JSONObject additionalValueObject = new JSONObject();
String combinedName =
valueName
+ DimensionalConfigurationSchema.ADDITIONAL_VALUE_SEPERATOR
+ aggregatorName;
Type inputValueType = inputValuesDescriptor.getType(valueName);
if (!configurationSchema.getAggregatorRegistry().isAggregator(aggregatorName)) {
if (aggregatorName == null) {
LOG.error("{} is not a valid aggregator.", aggregatorName);
}
}
Type outputValueType;
if (configurationSchema
.getAggregatorRegistry()
.isIncrementalAggregator(aggregatorName)) {
IncrementalAggregator aggregator =
configurationSchema
.getAggregatorRegistry()
.getNameToIncrementalAggregator()
.get(aggregatorName);
outputValueType = aggregator.getOutputType(inputValueType);
} else {
outputValueType =
configurationSchema
.getAggregatorRegistry()
.getNameToOTFAggregators()
.get(aggregatorName)
.getOutputType();
}
additionalValueObject.put(
DimensionalConfigurationSchema.FIELD_VALUES_NAME, combinedName);
additionalValueObject.put(
DimensionalConfigurationSchema.FIELD_VALUES_TYPE, outputValueType.getName());
additionalValueArray.put(additionalValueObject);
}
}
combination.put(
DimensionalConfigurationSchema.FIELD_DIMENSIONS_ADDITIONAL_VALUES,
additionalValueArray);
}
dimensions.put(combination);
}
schema.put(DimensionalConfigurationSchema.FIELD_DIMENSIONS, dimensions);
this.schemaJSON = this.schema.toString();
}
public SampleXmlUtil(boolean soapEnc) {
_soapEnc = soapEnc;
excludedTypes.addAll(SchemaUtils.getExcludedTypes());
}
private String normalize(final ByteSequence value) {
return SchemaUtils.normalizeStringAttributeValue(value, TRIM, CASE_FOLD).toString();
}
