public static async ValueTask <DataModelValue> GetContent(IValueEvaluator?contentBodyEvaluator,
IObjectEvaluator?contentExpressionEvaluator,
IExecutionContext executionContext,
CancellationToken token)
{
if (executionContext is null)
{
throw new ArgumentNullException(nameof(executionContext));
}
if (contentExpressionEvaluator is not null)
{
var obj = await contentExpressionEvaluator.EvaluateObject(executionContext, token).ConfigureAwait(false);
return(DataModelValue.FromObject(obj).AsConstant());
}
if (contentBodyEvaluator is IObjectEvaluator objectEvaluator)
{
var obj = await objectEvaluator.EvaluateObject(executionContext, token).ConfigureAwait(false);
return(DataModelValue.FromObject(obj).AsConstant());
}
if (contentBodyEvaluator is IStringEvaluator stringEvaluator)
{
var str = await stringEvaluator.EvaluateString(executionContext, token).ConfigureAwait(false);
return(new DataModelValue(str));
}
return(default);
public override HttpContent?TryCreateHttpContent(WebRequest webRequest,
string?contentType,
DataModelList parameters,
DataModelValue value)
{
if (!ContentTypeEquals(contentType, MediaTypeApplicationFormUrlEncoded))
{
return(default);
public void LocalNameShouldBeEmpty_IfTypeIsList()
{
// arrange
var v = DataModelValue.FromObject(new { key = "value" });
// act
var value = new DataModelXPathNavigator(v);
// assert
Assert.AreEqual(expected: "", value.LocalName);
}
public HttpClientJsonHandlerHttpContent(DataModelValue value, string contentType)
{
if (string.IsNullOrEmpty(contentType))
{
throw new ArgumentException(Resources.Exception_ValueCannotBeNullOrEmpty, nameof(contentType));
}
_value = value;
Headers.ContentType = new MediaTypeHeaderValue(contentType);
}
public void SimpleStringShouldBeConvertedToString_IfRootIsString()
{
// arrange
var v = DataModelValue.FromString("StrVal");
// act
var value = new DataModelXPathNavigator(v).Evaluate("string(.)");
// assert
Assert.AreEqual(expected: "StrVal", value);
}
public void NumberShouldBeConvertedToDouble_IfRootIsString()
{
// arrange
var v = DataModelValue.FromString("5.5");
// act
var value = new DataModelXPathNavigator(v).Evaluate("sum(.)");
// assert
Assert.AreEqual(expected: 5.5, value);
}
public void ConditionShouldBeConvertedToBoolean_IfRootIsString()
{
// arrange
var v = DataModelValue.FromString("5.5");
// act
var value = new DataModelXPathNavigator(v).Evaluate("sum(.) > 1.0");
// assert
Assert.AreEqual(expected: true, value);
}
public void ValueOfObjectPropertyShouldBeAvailableThroughValue_IfRootIsObject()
{
// arrange
var v = DataModelValue.FromObject(new { prop = "value" });
// act
var value = new DataModelXPathNavigator(v).Evaluate("string(prop)");
// assert
Assert.AreEqual(expected: "value", value);
}
public void LocalNameShouldBeText_IfTypeIsNumeric()
{
// arrange
var v = DataModelValue.FromObject(55);
// act
var value = new DataModelXPathNavigator(v);
// assert
Assert.AreEqual(expected: "#text", value.LocalName);
}
public void ValuesOfObjectPropertiesShouldBeConcatenatedThroughValue_IfRootIsComplexObject()
{
// arrange
var v = DataModelValue.FromObject(new { prop = "1", obj = new { prop1 = "1", prop2 = "1" } });
// act
var value = new DataModelXPathNavigator(v).Evaluate("string(.)");
// assert
Assert.AreEqual(expected: "111", value);
}
public void LocalNameShouldBePropName_IfTypeIsList()
{
// arrange
var v = DataModelValue.FromObject(new { key = "value" });
// act
var value = new DataModelXPathNavigator(v);
value.MoveToFirstChild();
// assert
Assert.AreEqual(expected: "key", value.LocalName);
}
public ValueTask Assign(IExecutionContext executionContext, DataModelValue value, CancellationToken token)
{
if (executionContext is null)
{
throw new ArgumentNullException(nameof(executionContext));
}
Infra.Assert(!_dispatcher._locationEvaluators.IsDefault);
var locationEvaluator = _dispatcher._locationEvaluators[_index];
return(locationEvaluator.SetValue(value, executionContext, token));
}
public void CanSelectSubNode_IfRootIsComplexObject()
{
// arrange
var v = DataModelValue.FromObject(new
{
/*prop = "value", */ obj = new { prop1 = "val1", prop2 = "target" }
});
// act
var value = new DataModelXPathNavigator(v).Evaluate("string(obj/prop2)");
// assert
Assert.AreEqual(expected: "target", value);
}
private async ValueTask <DataModelValue> Evaluate(IValueEvaluator objectEvaluator, IExecutionContext executionContext, CancellationToken token)
{
switch (_expectedValueType)
{
case ExpectedValueType.String when objectEvaluator is IStringEvaluator evaluator:
return(await evaluator.EvaluateString(executionContext, token).ConfigureAwait(false));
case ExpectedValueType.Integer when objectEvaluator is IIntegerEvaluator evaluator:
return(await evaluator.EvaluateInteger(executionContext, token).ConfigureAwait(false));
case ExpectedValueType.Boolean when objectEvaluator is IBooleanEvaluator evaluator:
return(await evaluator.EvaluateBoolean(executionContext, token).ConfigureAwait(false));
}
var obj = await((IObjectEvaluator)objectEvaluator).EvaluateObject(executionContext, token).ConfigureAwait(false);
return(DataModelValue.FromObject(obj));
}
public virtual async ValueTask Execute(IExecutionContext executionContext, CancellationToken token)
{
if (executionContext is null)
{
throw new ArgumentNullException(nameof(executionContext));
}
var data = default(DataModelValue);
if (ExpressionEvaluator is not null)
{
var obj = await ExpressionEvaluator.EvaluateObject(executionContext, token).ConfigureAwait(false);
data = DataModelValue.FromObject(obj).AsConstant();
}
await executionContext.Log(LogLevel.Info, _log.Label, data, token : token).ConfigureAwait(false);
}
public void TempTest()
{
// arrange
var n = DataModelValue.FromObject(new { child1 = "val1", child2 = "val2" });
var v = DataModelValue.FromObject(new { key = "value" });
var nNav = new DataModelXPathNavigator(n);
var vNav = new DataModelXPathNavigator(v);
vNav.MoveToFirstChild();
// act
vNav.ReplaceChildren(new XPathObject(nNav.Evaluate("child::*") !));
// assert
v.AsList().TryGet(key: "key", caseInsensitive: false, out var v1);
v1.Value.AsList().TryGet(key: "child1", caseInsensitive: false, out var v2);
Assert.AreEqual(expected: "val1", v2.Value.AsString());
}
public virtual async ValueTask <IObject> EvaluateObject(IExecutionContext executionContext, CancellationToken token)
{
if (executionContext is null)
{
throw new ArgumentNullException(nameof(executionContext));
}
if (_parsingException is null && _parsedValue.IsUndefined())
{
_parsedValue = ParseToDataModel(ref _parsingException);
_parsedValue.MakeDeepConstant();
}
if (_parsingException is not null)
{
await executionContext.Log(LogLevel.Warning, exception : _parsingException, token : token).ConfigureAwait(false);
}
return(_parsedValue.CloneAsWritable());
}
public async ValueTask <DataModelValue> Evaluate(IExecutionContext executionContext, CancellationToken token)
{
var obj = await _doneDataEvaluator.EvaluateObject(executionContext, token).ConfigureAwait(false);
return(DataModelValue.FromObject(obj));
}
public string ConvertToText(DataModelValue value)
{
Infra.NotNull(_dataModelHandler);
return(_dataModelHandler.ConvertToText(value));
}
public DebugView(DataModelValue value) => _value = value;
public Dynamic(DataModelValue value) => _value = value;
public ValueTask Log(LogLevel logLevel,
string?message = default,
DataModelValue arguments = default,
Exception?exception = default,
CancellationToken token = default) =>
_logger?.ExecuteLog(_loggerContext, logLevel, message, arguments, exception, token) ?? default;
public override HttpContent?TryCreateHttpContent(WebRequest webRequest,
string?contentType,
DataModelList parameters,
DataModelValue value) =>
ContentTypeEquals(contentType, MediaTypeApplicationJson) ? new HttpClientJsonHandlerHttpContent(value, MediaTypeApplicationJson) : default;
public virtual void PrepareRequest(WebRequest webRequest,
string?contentType,
DataModelList parameters,
DataModelValue value)
{
}
public virtual HttpContent?TryCreateHttpContent(WebRequest webRequest,
string?contentType,
DataModelList parameters,
DataModelValue value) =>
default;
/// <summary>
/// Copies the selected items.
/// </summary>
public void Copy()
{
var selection = SelectedControls;
if (selection.Count == 0)
{
Clipboard.Text = string.Empty;
return;
}
var dataModel = new DataModel();
var dataModelNodes = new List <DataModelNode>(selection.Count);
var dataModelComments = new List <DataModelComment>();
var dataModelBoxes = new List <DataModelBox>(32);
for (int i = 0; i < selection.Count; i++)
{
var node = selection[i] as SurfaceNode;
if (node == null)
{
continue;
}
var dataModelNode = new DataModelNode
{
GroupID = node.GroupArchetype.GroupID,
TypeID = node.Archetype.TypeID,
ID = node.ID,
X = node.Location.X,
Y = node.Location.Y,
};
if (node.Values != null)
{
dataModelNode.Values = new DataModelValue[node.Values.Length];
for (int j = 0; j < node.Values.Length; j++)
{
var value = new DataModelValue
{
Value = node.Values[j],
};
if (value.Value != null && value.Value.GetType().IsEnum)
{
value.EnumTypeName = value.Value.GetType().FullName;
}
dataModelNode.Values[j] = value;
}
}
if (node.Elements != null && node.Elements.Count > 0)
{
for (int j = 0; j < node.Elements.Count; j++)
{
if (node.Elements[j] is Box box && box.Connections.Count > 0)
{
var dataModelBox = new DataModelBox
{
ID = box.ID,
NodeIDs = new uint[box.Connections.Count],
BoxIDs = new int[box.Connections.Count],
};
for (int k = 0; k < box.Connections.Count; k++)
{
var target = box.Connections[k];
dataModelBox.NodeIDs[k] = target.ParentNode.ID;
}
for (int k = 0; k < box.Connections.Count; k++)
{
var target = box.Connections[k];
dataModelBox.BoxIDs[k] = target.ID;
}
dataModelBoxes.Add(dataModelBox);
}
}
if (dataModelBoxes.Count > 0)
{
dataModelNode.Boxes = dataModelBoxes.ToArray();
dataModelBoxes.Clear();
}
}
dataModelNodes.Add(dataModelNode);
}
dataModel.Nodes = dataModelNodes.ToArray();
for (int i = 0; i < selection.Count; i++)
{
var comment = selection[i] as SurfaceComment;
if (comment == null)
{
continue;
}
var dataModelComment = new DataModelComment
{
Title = comment.Title,
Color = comment.Color,
Bounds = comment.Bounds,
};
dataModelComments.Add(dataModelComment);
}
dataModel.Comments = dataModelComments.ToArray();
Clipboard.Text = FlaxEngine.Json.JsonSerializer.Serialize(dataModel);
}
public override void PrepareRequest(WebRequest webRequest,
string?contentType,
DataModelList parameters,
DataModelValue value) =>
AppendAcceptHeader(webRequest, MediaTypeApplicationJson);
