public void TestConvertWithDifferentArraySources()
{
var collection = new TestConverterCollection <AValue, BValue>(new PathFormatterCollection(), configurator =>
{
configurator.If(a => a.Condition)
.Target(b => b.BOuterArray.Each().BInnerArray.Each().FirstValue)
.Set(a => a.AOuterArray.Current().AFirstAFirstInnerArray.Current().Value);
configurator.If(a => !a.Condition)
.Target(b => b.BOuterArray.Each().BInnerArray.Each().FirstValue)
.Set(a => a.AOuterArray.Current().ASecondASecondInnerArray.Current().Value);
});
var converter = collection.GetConverter(MutatorsContext.Empty);
var from = new AValue
{
AOuterArray = new[]
{
new AOuterValue
{
AFirstAFirstInnerArray = new[]
{
new AFirstInnerValue {
Value = "123"
}
},
ASecondASecondInnerArray = new[]
{
new ASecondInnerValue {
Value = "321"
}
},
}
},
Condition = true,
};
Following.Code(() => converter(from))
.Should().Throw <InvalidOperationException>()
.Which.Message.Should().MatchRegex(@"^Method T Current\[T\].* cannot be invoked$");
return;
#pragma warning disable 162
var expected = new BValue
{
BOuterArray = new[]
{
new BOuterValue
{
BInnerArray = new[]
{
new BInnerValue {
FirstValue = "123"
},
},
},
},
};
converter(from).Should().BeEquivalentTo(expected);
#pragma warning restore 162
}
//public float timeAccumulator = 0f;
private AValue Sync(string key, AValue value, bool saveOnlyNoSend = false, bool sendWithoutDiffCheck = false)
{
AValue tmpValue = getValue(key, InputReadingMethod.CanReadSameValueMultipleTimes);
if (hasAuthority())
{
bool isDifferent = false;
if (value.CompareTo(tmpValue) != 0)
{
isDifferent = true;
}
saveValue(key, value);
if (!saveOnlyNoSend)
{
if (isDifferent || sendWithoutDiffCheck)
{
sendUpdate(key, value);
}
}
}
else
{
value = tmpValue;
}
return(value);
}
public void LetTest()
{
AQuery query = _db.Query
.Let("x", AValue.Document <Dummy>(TestDocumentCollectionName, AValue.Field <string>("asd")));
Assert.AreEqual("LET x = DOCUMENT('" + TestDocumentCollectionName + "',asd)", query.GetExpression());
}
private void m0001_Click(object sender, RoutedEventArgs e)
{
AValue.ConfigData.SchemaFilePath = "";
AValue.LoadSchemaData("");
this.SetItemsSource();
this.SetControlEnable(MainWindowState.New);
}
public void ForTest()
{
AQuery query = _db.Query
.For("x", AValue.Field(TestDocumentCollectionName));
Assert.AreEqual("FOR x IN " + TestDocumentCollectionName, query.GetExpression());
}
public void RangeTest()
{
AQuery query = _db.Query
.For("x", AValue.Range(0, 200));
Assert.AreEqual("FOR x IN 0..200", query.GetExpression());
}
public void FieldSuffixTest()
{
AQuery query = _db.Query
.Let("x", AValue <Dummy> .Field <int>(x => x.Foo, ".was"));
Assert.AreEqual("LET x = x.Foo.was", query.GetExpression());
}
public void AttributesTest()
{
AQuery query = _db.Query
.Let("x", AValue.Attributes(AValue <Dummy> .Field(x => x.Foo)));
Assert.AreEqual("LET x = ATTRIBUTES(x.Foo)", query.GetExpression());
}
public void SortTest()
{
AQuery query = _db.Query
.Sort(AValue <Dummy> .Field(x => x.Foo), AqlSort.Direction.Desc);
Assert.AreEqual("SORT x.Foo DESC", query.GetExpression());
}
public void OperationTest()
{
AQuery query = _db.Query
.Let("x", AValue.Op(AValue <Dummy> .Field(x => x.Baz), "/", AValue <Dummy> .Field(x => x.Bar)));
Assert.AreEqual("LET x = (x.Baz / x.Bar)", query.GetExpression());
}
private void Application_Startup(object sender, StartupEventArgs e)
{
AppCenter.Start("3e041512-b1c3-4a20-950f-e157db4e7f24", typeof(Analytics), typeof(Crashes));
AValue.Initialize();
this.InitializeConverter();
}
private ValueDTO CreateDTO(AValue value)
{
return(new ValueDTO()
{
Id = value.Id, Value = value.TheValue
});
}
private void ConnectButton_Click(object sender, RoutedEventArgs e)
{
if (this.ConnectionStringComboBox.SelectedIndex == -1)
{
MessageBox.Show(Properties.Resources.PleaseSelectConnectionString);
return;
}
var ci = this.ConnectionStringComboBox.SelectedValue as ConnectionStringInfo;
if (AValue.CanConnectToDatabase(AValue.SchemaData.DatabaseServer, ci.ConnectionString) == false)
{
MessageBox.Show(Properties.Resources.ConnectionStringInvalid);
return;
}
this.ImportTable();
this.ImportStoredProcedure();
this.ImportUserDefinedTableType();
if (this.TableListBox.Items.Count == 0 &&
this.StoredProcedureListBox.Items.Count == 0 &&
this.UserDefinedTableTypeListBox.Items.Count == 0)
{
MessageBox.Show(Properties.Resources.ThereIsNoObjectDeletedAfterLastProcess);
}
AValue.ConfigData.MoveConnectionStringToFirst(ci);
this.ConnectionStringComboBox.SelectedItem = AValue.ConfigData.ConnectionStrings[0];
}
private void ExecuteButton_Click(object sender, RoutedEventArgs e)
{
if (this.ConnectionStringComboBox.SelectedIndex == -1)
{
MessageBox.Show(Properties.Resources.PleaseSelectConnectionString);
return;
}
var ci = this.ConnectionStringComboBox.SelectedValue as ConnectionStringInfo;
if (AValue.CanConnectToDatabase(AValue.SchemaData.DatabaseServer, ci.ConnectionString) == false)
{
MessageBox.Show(Properties.Resources.ConnectionStringInvalid);
return;
}
var sv = new ImportObjectCommandService(AValue.SchemaData, ci.ConnectionString
, _Tables.Where(el => el.IsChecked).Select(el => el.Item.Name)
, _StoredProcedures.Where(el => el.IsChecked).Select(el => el.Item.Name)
, _UserDefinedTableTypes.Where(el => el.IsChecked).Select(el => el.Item.Name)
);
AValue.ConfigData.MoveConnectionStringToFirst(ci);
this.ConnectionStringComboBox.SelectedItem = AValue.ConfigData.ConnectionStrings[0];
this.Hide();
var w = new ProgressWindow(sv);
w.ShowDialog();
sv.ThrowException();
this.Close();
}
public void FieldTest()
{
AQuery query = _db.Query
.Let("x", AValue <Dummy> .Field(x => x.Bar));
Assert.AreEqual("LET x = x.Bar", query.GetExpression());
}
public void ObjectTest()
{
AQuery query = _db.Query
.Let("x", AValue <Dummy> .Object(
(
x => x.Id,
AValue.Bind("asdf")
),
(
x => x.Foo,
AValue <Dummy> .Field(z => z.Foo)
),
(
x => x.Bar,
AValue.Bind(10)
),
(
x => x.Baz,
AValue <Dummy> .Field(x => x.Bar)
)
));
Assert.AreEqual("LET x = {\"_id\":@var0,\"Foo\":z.Foo,\"Bar\":@var1,\"Baz\":x.Bar}", query.GetExpression());
Assert.AreEqual(typeof(string), query.GetBindedVars()[0].GetType());
Assert.AreEqual(typeof(int), query.GetBindedVars()[1].GetType());
}
public void BetweenTest()
{
AQuery query = _db.Query.Filter(AFilter.Between(AValue <Dummy> .Field(x => x.Bar), AValue.Bind(1), AValue.Bind(50)));
Assert.AreEqual("FILTER (x.Bar >= @var0 AND x.Bar <= @var1)", query.GetExpression());
Assert.AreEqual(1, query.GetBindedVars()[0]);
Assert.AreEqual(50, query.GetBindedVars()[1]);
}
public void SimpleTest()
{
//AQuery query = _db.Query.Filter(FilterBuilder<Dummy>.Eq( x => x.Foo, "asd"));
AQuery query = _db.Query.Filter(AFilter.Eq(AValue <Dummy> .Field(x => x.Foo), AValue.Bind("asd")));
Assert.AreEqual("FILTER x.Foo == @var0", query.GetExpression());
Assert.AreEqual("asd", query.GetBindedVars()[0]);
}
public override void __receiveValue(string key, AValue value, double latestRemoteTimestampOfChange)
{
base.__receiveValue(key, value, latestRemoteTimestampOfChange); //saves the value
if (readingMethod == AuthoritySerializerReadingMethod.ReadOnPeriodicallyAndOnDemand || readingMethod == AuthoritySerializerReadingMethod.ReadOnDemand)
{
OnNonAuthorityDeserialize(latestRemoteTimestampOfChange);
}
}
private void OpenSchemaFile(String filePath)
{
String xml = File.ReadAllText(filePath);
AValue.LoadSchemaData(xml);
AValue.ConfigData.SchemaFilePath = filePath;
this.SetSchemaData();
}
public async Task <Result> Add(AValue value)
{
var id = _nextId;
var valueToInsert = new AValue(id, value.TheValue);
_inMemoryDB[id] = valueToInsert;
return(Result.Ok());
}
void ReleaseDesignerOutlets()
{
if (ALabel != null)
{
ALabel.Dispose();
ALabel = null;
}
if (AValue != null)
{
AValue.Dispose();
AValue = null;
}
if (btnBack != null)
{
btnBack.Dispose();
btnBack = null;
}
if (DataAvgValue != null)
{
DataAvgValue.Dispose();
DataAvgValue = null;
}
if (imgData != null)
{
imgData.Dispose();
imgData = null;
}
if (imgP0 != null)
{
imgP0.Dispose();
imgP0 = null;
}
if (LabelDataAvg != null)
{
LabelDataAvg.Dispose();
LabelDataAvg = null;
}
if (lblData != null)
{
lblData.Dispose();
lblData = null;
}
if (lblDataPower != null)
{
lblDataPower.Dispose();
lblDataPower = null;
}
if (lblP0 != null)
{
lblP0.Dispose();
lblP0 = null;
}
if (PAvgValue != null)
{
PAvgValue.Dispose();
PAvgValue = null;
}
}
protected void Sync(string key, ref bool value, bool saveOnlyNoSend = false, bool sendWithoutDiffCheck = false)
{
AValue res = Sync(key, new BoolValue(value), saveOnlyNoSend, sendWithoutDiffCheck);
if (res != null)
{
value = AValue.to <bool>(res);
}
}
protected void Sync(string key, ref double value, bool saveOnlyNoSend = false, bool sendWithoutDiffCheck = false)
{
AValue res = Sync(key, new DoubleValue(value, "F" + decimalPlaces), saveOnlyNoSend, sendWithoutDiffCheck);
if (res != null)
{
value = AValue.to <double>(res);
}
}
public void FunctionMultipleTest()
{
AQuery query = _db.Query
.Let("x", ANumeric.Coalesce(AValue.Bind(2), AValue.Bind(5)));
Assert.AreEqual("LET x = NOT_NULL(@var0,@var1)", query.GetExpression());
Assert.AreEqual(2, query.GetBindedVars()[0]);
Assert.AreEqual(5, query.GetBindedVars()[1]);
}
public void InTest()
{
//AQuery query = _db.Query.Filter(FilterBuilder<Dummy>.In(x => x.Foo, new[] {"asd", "qwe"}));
AQuery query = _db.Query.Filter(AFilter.In(AValue <Dummy> .Field(x => x.Foo), AValueArray.Bind("asd", "qwe")));
Assert.AreEqual("FILTER x.Foo IN [@var0,@var1]", query.GetExpression());
Assert.AreEqual("asd", query.GetBindedVars()[0]);
Assert.AreEqual("qwe", query.GetBindedVars()[1]);
}
protected void Sync(string key, ref Quaternion value, string format, bool saveOnlyNoSend = false, bool sendWithoutDiffCheck = false)
{
AValue res = Sync(key, new QuaternionValue(value, format), saveOnlyNoSend, sendWithoutDiffCheck);
if (res != null)
{
value = AValue.to <Quaternion>(res);
}
}
public void TypeTest()
{
Type dummyType = typeof(Dummy);
//AQuery query = _db.Query.Filter(FilterBuilder<Dummy>.Eq(x => x.GetType(), dummyType));
AQuery query = _db.Query.Filter(AFilter.Eq(AValue <Dummy> .Field(x => x.GetType()), AValue.Bind(dummyType)));
Assert.AreEqual("FILTER x.$type == @var0", query.GetExpression());
Assert.AreEqual(dummyType.FullName + ", " + dummyType.Assembly.GetName().Name, query.GetBindedVars()[0]);
}
/// <summary>
/// add an odbc parameter, and replace the placeholders
/// </summary>
public void AddOdbcParameters(string APrefix, string AName, string APostfix, TVariant AValue)
{
if (IsVariant)
{
this.FSQLStmt = this.FVariantValue.ToString();
}
int pos = 0;
int parampos = 0;
int parameterIndex = 0;
int wherePos = this.FSQLStmt.ToUpper().IndexOf(" WHERE ");
pos = this.FSQLStmt.IndexOf(APrefix + AName + APostfix, pos);
if (pos == -1)
{
return;
}
if (wherePos > pos)
{
TLogging.Log(this.FSQLStmt);
throw new Exception("AddOdbcParameters: do not replace table names with odbc parameters");
}
while ((pos = this.FSQLStmt.IndexOf(APrefix + AName + APostfix, pos)) != -1)
{
while ((parampos != -1) && (parampos <= pos))
{
parampos = this.FSQLStmt.IndexOf("PARAMETER?", parampos + 1);
if ((parampos != -1) && (parampos <= pos))
{
parameterIndex++;
}
}
pos++;
parampos = pos;
if (APrefix == "{")
{
// force a string. needed for example for cost centre codes
AValue = new TVariant(AValue.ToString(), true);
}
this.FOdbcParameters.Insert(parameterIndex, AValue.ToOdbcParameter(AName));
// we have added now a parameter, so this needs to be counted.
// this is important if there are multiple occurances for the same parameter
parameterIndex++;
}
this.FSQLStmt = this.FSQLStmt.Replace(APrefix + AName + APostfix, "PARAMETER?");
}
private List <string> extractIdsFromArray(AValue array)
{
var ids = new List <string>();
foreach (var el in array.castTo <AArray>().elements)
{
var value = el.castTo <AStruct>().get("Id").castTo <ASimpleValue>().Val;
ids.Add(value);
}
return(ids);
}
