import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public ConceptScheme(OEClientReadOnly oeClient, JsonObject jsonObject) {
	logger.debug("Concept - entry: {}", jsonObject);
	this.uri = jsonObject.get("@id").getAsString().value();

	JsonValue jsonValue = jsonObject.get("@type");
	if (jsonValue != null) {
		JsonArray jsonTypes = jsonValue.getAsArray();
		for (int i = 0; i < jsonTypes.size(); i++) {
			this.types.add(jsonTypes.get(i).getAsString().value());
		}
	}

	JsonArray jsonPrefLabels = jsonObject.get("skosxl:prefLabel").getAsArray();
	for (int i = 0; i < jsonPrefLabels.size(); i++) {
		JsonObject jsonPrefLabel = jsonPrefLabels.get(i).getAsObject();

		String prefLabelUri = jsonPrefLabel.get("@id").getAsString().value();
		JsonObject jsonLiteral = jsonPrefLabel.get("meta:displayName").getAsObject();
		String prefLabelValue = jsonLiteral.get("@value").getAsString().value();
		String prefLabelLangCode = jsonLiteral.get("@language").getAsString().value();

		prefLabels.add(new Label(prefLabelUri, prefLabelLangCode, prefLabelValue));
	}
	logger.info("Concept - exit: {}", this.uri);

}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public RelationshipType(OEClientReadOnly oeClient, JsonObject jsonObject) {
	logger.debug("RelationshipType - entry: {}", jsonObject);
	this.oeClient = oeClient;
	this.uri = getAsString(jsonObject, "@id");

	labels = new HashSet<Label>();
	JsonArray jsonLabelValues = getAsArray(jsonObject, "rdfs:label");
	for (int i = 0; i < jsonLabelValues.size(); i++) {
		JsonObject jsonLabel = jsonLabelValues.get(i).getAsObject();
		String nameLabelValue = getAsString(jsonLabel, "@value");
		String nameLabelLangCode = getAsString(jsonLabel, "@language");

		labels.add(new Label(nameLabelLangCode, nameLabelValue));
	}

	parentPropertyUris = new HashSet<String>();
	JsonArray parentProperties = getAsArray(jsonObject, "rdfs:subPropertyOf");
	for (int i = 0; i < parentProperties.size(); i++) {
		JsonObject parentProperty = parentProperties.get(i).getAsObject();
		parentPropertyUris.add(getAsString(parentProperty, "@id"));
	}

	logger.info("RelationshipType - exit: {} {}", this.uri, this.labels);
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public ConceptClass(OEClientReadOnly oeClient, JsonObject jsonObject) {
	logger.debug("ConceptClass - entry: {}", jsonObject);
	this.oeClient = oeClient;
	this.uri = getAsString(jsonObject, "@id");

	labels = new HashSet<Label>();
	JsonArray jsonLabelValues = getAsArray(jsonObject, "rdfs:label");
	for (int i = 0; i < jsonLabelValues.size(); i++) {
		JsonObject jsonLabel = jsonLabelValues.get(i).getAsObject();
		String nameLabelValue = getAsString(jsonLabel, "@value");
		String nameLabelLangCode = getAsString(jsonLabel, "@language");

		labels.add(new Label(nameLabelLangCode, nameLabelValue));
	}

	parentClassUris = new HashSet<String>();
	JsonArray parentClasses = getAsArray(jsonObject, "rdfs:subClassOf");
	for (int i = 0; i < parentClasses.size(); i++) {
		JsonObject parentClass = parentClasses.get(i).getAsObject();
		parentClassUris.add(getAsString(parentClass, "@id"));
	}

	logger.info("ConceptClass - exit: {} {}", this.uri, this.labels);
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
/**
 * Display the window with the automatically generated form that allows the user to set a method's parameters.
 *
 * @param callerClass Class to get class loader from, to use for loading the window's FXML file
 * @param injector    Injector to use when loading FXML, so that the model etc. are injected automatically.
 * @param method      Method that the window should display configuration options for.
 */
public static void displayModal(Class callerClass, Injector injector, IDocumentation method, ListProperty<JPair<String, Object>> paramsProperty) {
    Parent root;
    FXMLLoader loader = new FXMLLoader(
            callerClass.getClassLoader().getResource("wizard-fxml/DynamicConfiguration.fxml"),
            null,
            new JavaFXBuilderFactory(),
            injector::getInstance
    );

    try {
        root = loader.load();
    } catch (IOException e) {
        e.printStackTrace();
        return;
    }

    root.getProperties().put("controller", loader.getController());

    Object controller = loader.getController();
    if (controller instanceof DynamicConfigurationController) {
        // Cast the controller instance since we know it's safe here
        DynamicConfigurationController popupController = (DynamicConfigurationController) controller;

        // Give the configuration options to the controller
        JsonArray params = method.getParameterConfiguration();
        popupController.setParameters(params, paramsProperty);

        // Create the popup
        Stage dialog = new Stage();
        dialog.setScene(new Scene(root));
        dialog.setTitle("JedAI - Parameter Configuration");
        dialog.initModality(Modality.APPLICATION_MODAL);

        dialog.show();
    } else {
        // This shouldn't ever happen.
        System.err.println("Error when showing the parameter customization popup (Wrong controller instance?)");
    }
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public Collection<Model> getAllModels() throws OEClientException {
	logger.info("getAllModels entry");
	
	String url = getApiURL() + "/sys/sys:Model/rdf:instance";
	logger.info("getAllModels URL: {}", url);
	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", "meta:displayName,meta:graphUri");

	Invocation.Builder invocationBuilder = getInvocationBuilder(url, queryParameters);

	Date startDate = new Date();
	logger.info("getAllModels making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("getAllModels call complete: {}", startDate.getTime());

	logger.info("getAllModels - status: {}", response.getStatus());

	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isInfoEnabled()) logger.info("getAllModels: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		JsonArray jsonArray = jsonResponse.get("@graph").getAsArray();
		Collection<Model> models = new ArrayList<Model>();
		Iterator<JsonValue> jsonValueIterator = jsonArray.iterator();
		while (jsonValueIterator.hasNext()) {
			JsonObject modelObject = jsonValueIterator.next().getAsObject();
			models.add(new Model(modelObject));
		}
		return models;
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
private Collection<RelationshipType> getRelationshipTypes(String parentType) throws OEClientException {
	logger.info("getRelationshipTypes entry: {}", parentType);

	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", "rdfs:label,owl:inverseOf,rdfs:subPropertyOf,owl:inverseOf/rdfs:label,owl:inverseOf/rdfs:subPropertyOf");
	Invocation.Builder invocationBuilder = getInvocationBuilder(getModelURL() + "/" + parentType +"/meta:transitiveSubProperty", queryParameters);

	Date startDate = new Date();
	logger.info("getRelationshipTypes making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("getRelationshipTypes call complete: {}", startDate.getTime());

	logger.info("getRelationshipTypes - status: {}", response.getStatus());
	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isInfoEnabled()) logger.info("getConceptClasses: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		JsonArray jsonArray = jsonResponse.get("@graph").getAsArray();
		Collection<RelationshipType> relationshipTypes = new HashSet<RelationshipType>();
		Iterator<JsonValue> jsonValueIterator = jsonArray.iterator();
		while (jsonValueIterator.hasNext()) {
			relationshipTypes.add(new RelationshipType(this, jsonValueIterator.next().getAsObject()));
		}
		return relationshipTypes;
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
/**
 * Return all concept classes
 * @return - a collection containing all concept classes
 * @throws OEClientException - an error has occurred contacting the server
 */
public Collection<ConceptClass> getConceptClasses(int limit) throws OEClientException {
	logger.info("getConceptClasses entry");

	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", "rdfs:label,rdfs:subClassOf");
	queryParameters.put("limit", Integer.toString(limit));
	Invocation.Builder invocationBuilder = getInvocationBuilder(getModelURL() + "/skos:Concept/meta:transitiveSubClass", queryParameters);

	Date startDate = new Date();
	logger.info("getConceptClasses making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("getConceptClasses call complete: {}", startDate.getTime());

	logger.info("getConceptClasses - status: {}", response.getStatus());
	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isInfoEnabled()) logger.info("getConceptClasses: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		JsonArray jsonArray = jsonResponse.get("@graph").getAsArray();
		Collection<ConceptClass> conceptClasses = new HashSet<ConceptClass>();
		Iterator<JsonValue> jsonValueIterator = jsonArray.iterator();
		while (jsonValueIterator.hasNext()) {
			conceptClasses.add(new ConceptClass(this, jsonValueIterator.next().getAsObject()));
		}
		return conceptClasses;
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public Concept(OEClientReadOnly oeClient, JsonObject jsonObject) {
	logger.debug("Concept - entry: {}", jsonObject);
	this.uri = getAsString(jsonObject, "@id");

	JsonValue jsonValue = jsonObject.get("@type");
	if (jsonValue != null) {
		JsonArray jsonTypes = jsonValue.getAsArray();
		for (int i = 0; i < jsonTypes.size(); i++) {
			this.types.add(jsonTypes.get(i).getAsString().value());
		}
	}

	JsonArray jsonPrefLabels = getAsArray(jsonObject, "skosxl:prefLabel");
	if (jsonPrefLabels != null) {
		for (int i = 0; i < jsonPrefLabels.size(); i++) {
			JsonObject jsonPrefLabel = jsonPrefLabels.get(i).getAsObject();

			String prefLabelUri = getAsString(jsonPrefLabel, "@id");
			JsonArray jsonLiteralForms = getAsArray(jsonPrefLabel, "skosxl:literalForm");
			if (jsonLiteralForms != null) {
				for (int j = 0; j < jsonLiteralForms.size(); j++) {
					JsonObject jsonLiteralForm = jsonLiteralForms.get(j).getAsObject();
					String prefLabelValue = getAsString(jsonLiteralForm, "@value");
					String prefLabelLangCode = getAsString(jsonLiteralForm, "@language");

					Label label = new Label(prefLabelUri, prefLabelLangCode, prefLabelValue);
					prefLabels.add(label);
					addByLanguageAndValue(prefLabelsByLanguageAndValue, label.getLanguageCode(), label.getValue(), label);
				}
			}
		}
	}
	logger.info("Concept - exit: {}", this.uri);
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public void populateRelatedConceptUris(String relationhipUri, JsonObject jsonObject) {
	Collection<String> relatedConceptURIs = new HashSet<String>();
	JsonArray jsonRelateds = getAsArray(jsonObject, relationhipUri);
	if (jsonRelateds != null) {
		for (int i = 0; i < jsonRelateds.size(); i++) {
			JsonObject jsonNarrower = jsonRelateds.get(i).getAsObject();
			relatedConceptURIs.add(getAsString(jsonNarrower, "@id"));
		}
	}
	relatedConceptUrisByRelationship.put(relationhipUri, relatedConceptURIs);
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public void populateMetadata(String metadataTypeUri, JsonObject jsonObject) {
	Collection<MetadataValue> metadataValues = new HashSet<MetadataValue>();
	JsonArray jsonRelateds = getAsArray(jsonObject, metadataTypeUri);
	if (jsonRelateds != null) {
		for (int i = 0; i < jsonRelateds.size(); i++) {
			JsonObject jsonMetadata = jsonRelateds.get(i).getAsObject();
			metadataValues.add(new MetadataValue(getAsString(jsonMetadata, "@language"), getAsString(jsonMetadata, "@value")));
		}
	}
	metadataValuesByMetadataTypeUri.put(metadataTypeUri, metadataValues);
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public ChangeSet(JsonValue jsonValue) {
	logger.debug("ChangeSet - entry: {}", jsonValue);
	if (jsonValue == null) return;
	JsonArray jsonArray = jsonValue.getAsArray();
	for (int i = 0; i < jsonArray.size(); i++) {
		triples.add(new Triple(jsonArray.get(i).getAsObject()));
	}
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
/**
 * createTask - create a task within the current model
 * @param task 
 *          - the task to be created
 */
public void createTask(Task task) {
	logger.info("createTask entry: {}", task.getLabel());

	String url = getModelSysURL() + "/meta:hasTask";
	logger.info("createTask URL: {}", url);
	Invocation.Builder invocationBuilder = getInvocationBuilder(url);

	JsonObject taskObject = new JsonObject();

	JsonArray taskTypeList = new JsonArray();
	taskTypeList.add("sys:Task");
	taskObject.put("@type", taskTypeList);

	JsonObject labelObject = new JsonObject();
	labelObject.put("@value", task.getLabel().getValue());
	labelObject.put("@language", task.getLabel().getLanguageCode());
	taskObject.put("rdfs:label", labelObject);

	String taskPayload = taskObject.toString();

	Date startDate = new Date();
	logger.info("createTask making call  : {} {}", taskPayload, startDate.getTime());
	Response response = invocationBuilder.post(Entity.entity(taskPayload, "application/ld+json"));
	logger.info("createTask call complete: {}", startDate.getTime());

	/*
	 * Possible response codes are: - 201 in case of success - 409 in case
	 * of constraint violation (if e. g. concept scheme already exists)
	 */
	logger.info("createTask status: {}", response.getStatus());
	if (logger.isDebugEnabled()) {
		logger.debug("createTask response: {}", response.readEntity(String.class));
	}
	
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
/**
 * createConceptScheme - create a concept as a topConcept of a Concept
 * Scheme
 *
 * @param conceptScheme
 *            - the concept scheme to create, the labels of this concept
 *            will be created
 */
public void createConceptScheme(ConceptScheme conceptScheme) {
	logger.info("createConceptScheme entry: {}", conceptScheme.getUri());

	Invocation.Builder invocationBuilder = getInvocationBuilder(getModelURL());

	JsonObject conceptSchemeDetails = new JsonObject();

	JsonArray conceptSchemeTypeList = new JsonArray();
	conceptSchemeTypeList.add("skos:ConceptScheme");
	conceptSchemeDetails.put("@type", conceptSchemeTypeList);

	JsonArray newconceptSchemeLabelDataList = new JsonArray();
	for (Label label : conceptScheme.getPrefLabels()) {
		JsonObject newconceptSchemeLabelData = new JsonObject();
		newconceptSchemeLabelData.put("@value", label.getValue());
		newconceptSchemeLabelData.put("@language", label.getLanguageCode());
		newconceptSchemeLabelDataList.add(newconceptSchemeLabelData);
	}

	conceptSchemeDetails.put("rdfs:label", newconceptSchemeLabelDataList);
	conceptSchemeDetails.put("@id", conceptScheme.getUri());

	String conceptSchemePayload = conceptSchemeDetails.toString();

	Date startDate = new Date();
	logger.info("createConceptScheme making call  : {}", startDate.getTime());
	Response response = invocationBuilder.post(Entity.entity(conceptSchemePayload, "application/ld+json"));
	logger.info("createConceptScheme call complete: {}", startDate.getTime());

	/*
	 * Possible response codes are: - 201 in case of success - 409 in case
	 * of constraint violation (if e. g. concept scheme already exists)
	 */
	logger.info("createConceptScheme status: {}", response.getStatus());
	if (logger.isDebugEnabled()) {
		logger.debug("createConceptScheme response: {}", response.readEntity(String.class));
	}
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
@Override
public List<Id> listDatasets() {
    JsonObject obj = rpc(DeltaConst.OP_LIST_DS, emptyObject);
    JsonArray array = obj.get(DeltaConst.F_ARRAY).getAsArray();
    List<Id> x = array.stream()
        .map(jv->Id.fromString(jv.getAsString().value()))
        .collect(Collectors.toList()) ;
    return x ;
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
@Override
public List<DataSourceDescription> listDescriptions() {
    JsonObject obj = rpc(DeltaConst.OP_LIST_DSD, emptyObject);
    JsonArray array = obj.get(DeltaConst.F_ARRAY).getAsArray();
    List<DataSourceDescription> x = array.stream()
        .map(jv->getDataSourceDescription(jv.getAsObject()))
        .collect(Collectors.toList()) ;
    return x ;
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
@Override
public List<PatchLogInfo> listPatchLogInfo() {
    JsonObject obj = rpc(DeltaConst.OP_LIST_LOG_INFO, emptyObject);
    JsonArray array = obj.get(DeltaConst.F_ARRAY).getAsArray();
    List<PatchLogInfo> x = array.stream()
        .map(jv->PatchLogInfo.fromJson(jv.getAsObject()))
        .collect(Collectors.toList()) ;
    return x ;
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public static Template templateFrom(JsonValue json, DataContext dc) {
    if (json.isArray()) {
        JsonArray templates = json.getAsArray();
        Template firstTemplate = null;
        for (Iterator<JsonValue> i = templates.iterator(); i.hasNext();) {
            JsonValue j = i.next();
            if (j.isObject()) {
                Template t = templateFrom(j.getAsObject(), dc);
                if (firstTemplate == null) {
                    firstTemplate = t;
                }
                if (t.getName() != null) {
                    dc.registerTemplate(t);
                }
            }
        }
        return firstTemplate;
    } else if (json.isObject()) {
        JsonObject jo = json.getAsObject();
        if (ResourceMapTemplate.isSpec(jo)) {
            return new ResourceMapTemplate(jo, dc);
        } else if (ParameterizedTemplate.isSpec(jo)) {
            return new ParameterizedTemplate(jo, dc);
        } else if (HierarchyTemplate.isSpec(jo)) {
            return new HierarchyTemplate(jo, dc);
        } else if (CompositeTemplate.isSpec(jo)) {
            return new CompositeTemplate(jo, dc);
        } else {
            return null;
        }
    } else if (json.isString()) {
        return new TemplateRef( json.getAsString().value(), dc);
    } else {
        
        throw new EpiException("Templates must be specified as a JSON object or an array of objects");
    }
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
/**
 * Set the parameters to show in the configuration window, and create UI elements for the user to set them.
 *
 * @param jsonParamDescriptions Parameters as specified by the JedAI library
 */
public void setParameters(JsonArray jsonParamDescriptions, ListProperty<JPair<String, Object>> parametersProperty) {
    this.jsonParamDescriptions = jsonParamDescriptions;
    this.parametersProperty = parametersProperty;

    // Determine if there are, and we should use previously set values for the parameters
    ObservableList<JPair<String, Object>> prevParams = parametersProperty.get();

    boolean usePrevParams = false;
    if (prevParams != null && !prevParams.isEmpty() && prevParams.size() == jsonParamDescriptions.size()) {
        // We can use the previously set parameters for this
        usePrevParams = true;
    }

    // If the method is parameter-free, display it
    if (this.jsonParamDescriptions.isEmpty()) {
        configureParamsLabel.setText("This is a parameter-free method!");
    } else {
        // Generate the form to configure the method
        int gridRows = 0;
        for (JsonValue jsonParam : this.jsonParamDescriptions) {
            if (jsonParam.isObject()) {
                JsonObject jsonParamObj = jsonParam.getAsObject();

                // If we have previous values for the parameters, modify the JSON object's default value
                if (usePrevParams) {
                    // Save original default value to another parameter, in order to be able to display it
                    JsonValue originalDefault = jsonParamObj.get("defaultValue");
                    if (originalDefault != null) {
                        jsonParamObj.put("defaultValueOriginal", originalDefault);
                    }

                    // Put as the new defaultValue the previous one
                    jsonParamObj.put("defaultValue", prevParams.get(gridRows).getRight().toString());
                }

                // Create controls for setting this parameter
                addParameterControls(jsonParamObj, gridRows++);
            } else if (jsonParam.isArray()) {
                throw new UnsupportedOperationException("Cannot handle JSON array yet (?)");
            }
        }
    }
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
/**
 * getAllTasks
 * @return all the tasks present for this model
 * @throws OEClientException - an error has occurred contacting the server
 */
public Collection<Task> getAllTasks() throws OEClientException {
	logger.info("getAllTasks entry");

	String url = getModelSysURL();
	logger.info("getAllTasks URL: {}", url);

	Map<String, String> queryParameters = new HashMap<String, String>();
	queryParameters.put("properties", "meta:hasTask/(meta:graphUri|meta:displayName)");
	queryParameters.put("filters", "subject_hasTask(notExists rdf:type sem:ORTTask)");

	Invocation.Builder invocationBuilder = getInvocationBuilder(url, queryParameters);

	Date startDate = new Date();
	logger.info("getAllTasks making call  : {}", startDate.getTime());
	Response response = invocationBuilder.get();
	logger.info("getAllTasks call complete: {}", startDate.getTime());

	logger.info("getAllTasks - status: {}", response.getStatus());

	if (response.getStatus() == 200) {
		String stringResponse = response.readEntity(String.class);
		if (logger.isInfoEnabled()) logger.info("getAllTasks: jsonResponse {}", stringResponse);
		JsonObject jsonResponse = JSON.parse(stringResponse);
		JsonArray jsonArray = jsonResponse.get("@graph").getAsArray();
		Collection<Task> tasks = new ArrayList<Task>();
		Iterator<JsonValue> jsonValueIterator = jsonArray.iterator();
		while (jsonValueIterator.hasNext()) {
			JsonObject modelData = jsonValueIterator.next().getAsObject();
			JsonArray taskArray = modelData.get("meta:hasTask").getAsArray();
			Iterator<JsonValue> jsonTaskIterator = taskArray.iterator();
			while (jsonTaskIterator.hasNext()) {
				tasks.add(new Task(jsonTaskIterator.next().getAsObject()));
			}
		}
		return tasks;
	} else {
		throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
	}
	
}
 

import org.apache.jena.atlas.json.JsonArray; //导入依赖的package包/类
public Collection<ChangeRecord> getChangesSince(Date date) throws OEClientException {

			StringBuilder stringBuilder = new StringBuilder(baseURL);
			if (!baseURL.endsWith("/")) stringBuilder.append("/");
			stringBuilder.append("api/");
			stringBuilder.append("t/");
			stringBuilder.append(token);
			stringBuilder.append("/tch");
			stringBuilder.append(modelUri);
			stringBuilder.append("/teamwork:Change/rdf:instance");
			
			String url = stringBuilder.toString();
			logger.debug("getChangesSince: '{}'", url);

			Map<String, String> queryParameters = new HashMap<String, String>();
			queryParameters.put("properties", "?triple/(teamwork:subject|teamwork:predicate|teamwork:object),sem:committed");
			queryParameters.put("filters", String.format("subject(sem:committed >= \"%s\"^^xsd:dateTime)", date.toInstant().toString()));
			queryParameters.put("sort", "sem:committed");
			
			Invocation.Builder invocationBuilder = getInvocationBuilder(url, queryParameters);

			Date startDate = new Date();
			logger.info("getChangesSince making call  : {}", startDate.getTime());
			Response response = invocationBuilder.get();
			logger.info("getChangesSince call complete: {}", startDate.getTime());

			logger.info("getChangesSince - status: {}", response.getStatus());

 			if (response.getStatus() == 200) {
 				String stringResponse = response.readEntity(String.class);
 				if (logger.isInfoEnabled()) logger.info("getChangesSince: jsonResponse {}", stringResponse);
 				JsonObject jsonResponse = JSON.parse(stringResponse);
 				JsonArray jsonArray = jsonResponse.get("@graph").getAsArray();
 				Collection<ChangeRecord> changeRecords = new ArrayList<ChangeRecord>();
 				Iterator<JsonValue> jsonValueIterator = jsonArray.iterator();
 				while (jsonValueIterator.hasNext()) {
 					changeRecords.add(new ChangeRecord(this, jsonValueIterator.next().getAsObject()));
 				}
 				return changeRecords;
 			} else {
 				throw new OEClientException(String.format("Error(%d) %s from server", response.getStatus(), response.getStatusInfo().toString()));
 			}
	}