public static ModelInfoReqResponses.CompareValueResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
string layerId = jobj["layerId"].ToString();
string valueId = jobj["valueId"].ToString();
string compareValue = jobj["compareValue"].ToString();
if (!versionedModel.getCurrent().layerDict.layers.ContainsKey(layerId))
{
return(new ModelInfoReqResponses.CompareValueResponseLayerNonexistentError());
}
if (!versionedModel.getCurrent().layerDict.layers[layerId].getValueNames().Contains(valueId))
{
return(new ModelInfoReqResponses.CompareValueResponseFieldNonexistentError());
}
bool isEqual = ModelUtilsNS.ModelUtils.compareFieldValue(
versionedModel.getCurrent(),
layerId,
valueId,
compareValue
);
return(new ModelInfoReqResponses.CompareValueResponseNoError(isEqual));
}
public static ModelInfoReqResponses.ValidateLayerFieldsResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
Dictionary <string, string> fieldValues = new Dictionary <string, string>();
foreach (var fieldEntry in (jobj["fieldValues"] as JObject).Properties())
{
fieldValues[fieldEntry.Name] = fieldEntry.Value.ToString();
}
string layerId = jobj["layerId"].ToString();
if (!versionedModel.getCurrent().layerDict.layers.ContainsKey(layerId))
{
return(new ModelInfoReqResponses.ValidateLayerFieldsResponseLayerNonexistentError());
}
Layers.Layer layer = versionedModel.getCurrent().layerDict.layers[layerId];
foreach (var fieldEntry in fieldValues)
{
if (!layer.getValueNames().Contains(fieldEntry.Key))
{
return(new ModelInfoReqResponses.ValidateLayerFieldsResponseFieldNonexistent(fieldEntry.Key));
}
}
var validated = ModelUtilsNS.ModelUtils.validateLayerFields(
versionedModel.getCurrent(),
layerId,
fieldValues
);
return(new ModelInfoReqResponses.ValidateLayerFieldsResponseNoError(validated.errors, validated.warnings));
}
public static ModelInfoReqResponses.ValidateValueResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
string layerId = jobj["layerId"].ToString();
string valueId = jobj["valueId"].ToString();
string newValue = jobj["newValue"].ToString();
if (!versionedModel.getCurrent().layerDict.layers.ContainsKey(layerId))
{
return(new ModelInfoReqResponses.ValidateValueResponseLayerNonexistentError());
}
if (!versionedModel.getCurrent().layerDict.layers[layerId].getValueNames().Contains(valueId))
{
return(new ModelInfoReqResponses.ValidateValueResponseFieldNonexistError(valueId));
}
if (versionedModel.getCurrent().layerDict.layers[layerId].getValueIsReadonly(valueId))
{
return(new ModelInfoReqResponses.ValidateValueResponseNoError("Field is read-only"));
}
// string may be null
string validated = ModelUtilsNS.ModelUtils.validateFieldValue(
versionedModel.getCurrent(),
layerId,
valueId,
newValue
);
return(new ModelInfoReqResponses.ValidateValueResponseNoError(validated));
}
public static ModelInfoReqResponses.EdgesBetweenVerticesResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
var modelContainer = versionedModel.getCurrent();
List <string> vertexIds = new List <string>();
foreach (var vertexId in (jobj["vertexIds"] as JArray).Children())
{
vertexIds.Add(vertexId.ToString());
}
List <string> edgeIds = ModelUtilsNS.ModelUtils.getEdgesBetweenVertices(
modelContainer,
vertexIds
);
var edges = new Dictionary <string, ResponseJson.EdgeData>();
foreach (string edgeId in edgeIds)
{
GraphUtilsNS.GraphUtils.getEdgeJsonData(modelContainer.graph.edges[edgeId]);
edges[edgeId] = GraphUtilsNS.GraphUtils.getEdgeJsonData(modelContainer.graph.edges[edgeId]);;
}
return(new ModelInfoReqResponses.EdgesBetweenVerticesResponseVerticesExist(edges));
}
public static ModelInfoReqResponses.ValidateEdgeResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
string edgeId = jobj["edgeId"].ToString();
string sourceVertexId = jobj["sourceVertexId"].ToString();
string sourcePortId = jobj["sourcePortId"].ToString();
string targetVertexId = jobj["targetVertexId"].ToString();
string targetPortId = jobj["targetPortId"].ToString();
string possibleProblemReason = ModelUtilsNS.ModelUtils.validateEdge(
versionedModel.getCurrent(),
edgeId,
sourceVertexId,
sourcePortId,
targetVertexId,
targetPortId
);
if (possibleProblemReason == null)
{
return(new ModelInfoReqResponses.ValidateEdgeResponseValid());
}
else
{
return(new ModelInfoReqResponses.ValidateEdgeResponseInvalid(possibleProblemReason));
}
}
public static void addLayer(
VersionedModelClassNS.VersionedModelClass versionedModel,
string layerId,
string layerType,
float x,
float y
)
{
ModelClassNS.ModelClass modelClass = versionedModel.getCurrent();
Layers.Layer layer = Layers.Layer.getNewLayerByType(layerType);
NetworkContainersNS.Vertex newVertex = new NetworkContainersNS.Vertex {
label = layerType + " Layer",
xLocation = x,
yLocation = y,
ports = new Dictionary <string, NetworkContainersNS.NetworkPort>()
};
List <string> inputPortNames = new List <string>();
List <string> outputPortNames = new List <string>();
foreach (string portName in layer.getPortNames())
{
if (layer.getValueIsReadonly(layer.getValueNameOfPort(portName)))
{
outputPortNames.Add(portName);
}
else
{
inputPortNames.Add(portName);
}
}
for (int i = 0; i < inputPortNames.Count; i++)
{
// System.Console.Error.WriteLine(((float)(i + 1)) / ((float)(inputPortNames.Count + 1)));
newVertex.ports[inputPortNames[i]] = new NetworkContainersNS.NetworkPort {
side = NetworkContainersNS.SideType.Top,
position = ((float)(i + 1)) / ((float)(inputPortNames.Count + 1)),
type = NetworkContainersNS.PortType.Input,
};
}
for (int i = 0; i < outputPortNames.Count; i++)
{
newVertex.ports[outputPortNames[i]] = new NetworkContainersNS.NetworkPort {
side = NetworkContainersNS.SideType.Bottom,
position = ((float)(i + 1)) / ((float)(outputPortNames.Count + 1)),
type = NetworkContainersNS.PortType.Output,
};
}
modelClass.graph.vertices[layerId] = newVertex;
modelClass.layerDict.layers[layerId] = layer;
modelClass.edgesByVertex[layerId] = new ModelClassNS.VertexEdgesInfo();
}
public static ModelInfoReqResponses.GetUniqueVertexIdsResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
var modelContainer = versionedModel.getCurrent();
int count = int.Parse(jobj["count"].ToString());
List <string> vertexIds = ModelUtilsNS.ModelUtils.getUniqueVertexIds(modelContainer, count);
return(new ModelInfoReqResponses.GetUniqueVertexIdsResponse(vertexIds));
}
public static ModelInfoReqResponses.GetGraphDataResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
var modelContainer = versionedModel.getCurrent();
ResponseJson.GraphData graphData = ModelUtilsNS.ModelUtils.getResponseJsonData(modelContainer);
ModelInfoReqResponses.GetGraphDataResponse response = new ModelInfoReqResponses.GetGraphDataResponse(graphData);
return(response);
}
public static ModelInfoReqResponses.GetPortInfoResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
string vertexId = jobj["vertexId"].ToString();
string portId = jobj["portId"].ToString();
if (!versionedModel.getCurrent().graph.vertices.ContainsKey(vertexId))
{
return(new ModelInfoReqResponses.GetPortInfoResponseCouldNotFindPort());
}
if (!versionedModel.getCurrent().graph.vertices[vertexId].ports.ContainsKey(portId))
{
return(new ModelInfoReqResponses.GetPortInfoResponseCouldNotFindPort());
}
Layers.Layer layer = versionedModel.getCurrent().layerDict.layers[vertexId];
string valueName = layer.getValueNameOfPort(portId);
string fieldValue = layer.getValueString(valueName);
return(new ModelInfoReqResponses.GetPortInfoResponseCouldFindPort(fieldValue));
}
public static ModelInfoReqResponses.ValueIsReadonlyResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
string layerId = jobj["layerId"].ToString();
string valueId = jobj["valueId"].ToString();
if (ModelUtilsNS.ModelUtils.isLayerValueOccupied(
versionedModel.getCurrent(),
layerId,
valueId
))
{
return(new ModelInfoReqResponses.ValueIsReadonlyResponseIsReadonly(ModelInfoReqResponses.ReadonlyReason.port_is_occupied));
}
if (!ModelUtilsNS.ModelUtils.isLayerFieldParameter(versionedModel.getCurrent(), layerId, valueId))
{
return(new ModelInfoReqResponses.ValueIsReadonlyResponseIsReadonly(ModelInfoReqResponses.ReadonlyReason.value_is_not_modifiable));
}
return(new ModelInfoReqResponses.ValueIsReadonlyResponseNotReadonly());
}
public static ModelInfoReqResponses.GetLayerInfoResponse dispatch(
VersionedModelClassNS.VersionedModelClass versionedModel,
JObject jobj
)
{
string layerId = jobj["layerId"].ToString();
if (!versionedModel.getCurrent().layerDict.layers.ContainsKey(layerId))
{
return(new ModelInfoReqResponses.GetLayerInfoResponseLayerDoesNotExist());
}
ResponseJson.LayerData layerData = ModelUtilsNS.ModelUtils.getLayerJsonData(versionedModel.getCurrent(), layerId);
return(new ModelInfoReqResponses.GetLayerInfoResponseLayerExists(layerData));
}
public static void dispatch(JObject jobj, ExternalMessageSender.RequestResponder reqResponder, VersionedModelClassNS.VersionedModelClass versionedModel)
{
string type = jobj["type"].ToString();
if (type == "request_model_changes")
{
versionedModel.recordModel();
ModelChangeReqResponseNS.ModelChangeReqResponse reqResponse = ModelChangeRequest.dispatch(versionedModel.getCurrent(), jobj);
reqResponder.sendModelChangeReqResponse(reqResponse);
ExternalMessageSender.DataChangedNotifier.notifyDataChanged(ModelUtilsNS.ModelUtils.getResponseJsonData(versionedModel.getCurrent()));
}
else if (type == "request_versioning_change")
{
ModelVersioningReqResponses.ModelVersioningReqResponse reqResponse = VersioningChangeRequest.dispatch(jobj, versionedModel);
reqResponder.sendVersioningChangeReqResponse(reqResponse);
ExternalMessageSender.DataChangedNotifier.notifyDataChanged(ModelUtilsNS.ModelUtils.getResponseJsonData(versionedModel.getCurrent()));
}
else if (type == "request_model_info")
{
ModelInfoReqResponses.ModelInfoReqResponse reqResponse = ModelInfoRequest.dispatch(jobj, reqResponder, versionedModel);
reqResponder.sendModelInfoReqResponse(reqResponse);
}
else
{
throw new InvalidModelReqType(type);
}
}