public void TestFindWithNullPropertiesQuery()
{
var findWithPropertiesEntity = new FindWithPropertiesEntity {
Name = "bot_#foobar", Age = 20
};
Backendless.Persistence.Save(findWithPropertiesEntity);
List <String> properties = null;
var dataQuery = new BackendlessDataQuery(properties);
BackendlessCollection <FindWithPropertiesEntity> backendlessCollection =
Backendless.Persistence.Of <FindWithPropertiesEntity>().Find(dataQuery);
Assert.IsTrue(backendlessCollection.TotalObjects > 0, "Server found wrong number of objects");
Assert.IsTrue(backendlessCollection.GetCurrentPage().Count > 0, "Server returned wrong number of objects");
foreach (FindWithPropertiesEntity entity in backendlessCollection.GetCurrentPage())
{
Assert.IsTrue(entity.Age > 0, "Server result contained wrong age field value");
Assert.IsNotNull(entity.Name, "Server result contained non null field");
Assert.IsNotNull(entity.ObjectId, "Server result contained non null field");
Assert.IsNotNull(entity.Created, "Server result contained non null field");
}
}
public BackendlessCollection <SearchMatchesResult> RelativeFind(BackendlessGeoQuery geoQuery)
{
if (geoQuery == null)
{
throw new ArgumentNullException(ExceptionMessage.NULL_GEO_QUERY);
}
if (geoQuery.RelativeFindMetadata.Count == 0 || geoQuery.RelativeFindPercentThreshold == 0)
{
throw new ArgumentException(ExceptionMessage.INCONSISTENT_GEO_RELATIVE);
}
Invoker.Api api = Invoker.Api.UNKNOWN;
string query = GetGetPointsQuery(geoQuery, out api);
BackendlessCollection <SearchMatchesResult> result = null;
Dictionary <string, BackendlessCollection <SearchMatchesResult> > r = Invoker.InvokeSync <Dictionary <string, BackendlessCollection <SearchMatchesResult> > >(Invoker.Api.GEOSERVICE_RELATIVEFIND, new Object[] { null, query });
if (r != null && r.ContainsKey(COLLECTION))
{
result = (BackendlessCollection <SearchMatchesResult>)r[COLLECTION];
result.Query = geoQuery;
}
return(result);
}
public void RelativeFind(BackendlessGeoQuery geoQuery, AsyncCallback <BackendlessCollection <SearchMatchesResult> > callback)
{
try
{
if (geoQuery == null)
{
throw new ArgumentNullException(ExceptionMessage.NULL_GEO_QUERY);
}
if (geoQuery.RelativeFindMetadata.Count == 0 || geoQuery.RelativeFindPercentThreshold == 0)
{
throw new ArgumentException(ExceptionMessage.INCONSISTENT_GEO_RELATIVE);
}
Invoker.Api api = Invoker.Api.UNKNOWN;
string query = GetGetPointsQuery(geoQuery, out api);
var responder = new AsyncCallback <Dictionary <string, BackendlessCollection <SearchMatchesResult> > >(r =>
{
BackendlessCollection <SearchMatchesResult> result = null;
if (r != null && r.ContainsKey(COLLECTION))
{
result = (BackendlessCollection <SearchMatchesResult>)r[COLLECTION];
result.Query = geoQuery;
}
if (callback != null)
{
callback.ResponseHandler.Invoke(result);
}
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
Invoker.InvokeAsync <Dictionary <string, BackendlessCollection <SearchMatchesResult> > >(Invoker.Api.GEOSERVICE_RELATIVEFIND, new Object[] { null, query }, responder);
}
catch (System.Exception ex)
{
if (callback != null)
{
callback.ErrorHandler.Invoke(new BackendlessFault(ex));
}
else
{
throw;
}
}
}
public void AssertArgumentAndResultCollections <T>(List <T> entities, BackendlessCollection <T> backendlessCollection)
{
Assert.AreEqual(entities.Count, backendlessCollection.TotalObjects, "Server found wrong number of objects");
Assert.AreEqual(entities.Count, backendlessCollection.GetCurrentPage().Count,
"Server returned wrong number of objects");
foreach (T entity in entities)
{
Assert.IsTrue(backendlessCollection.GetCurrentPage().Contains(entity),
"Server result didn't contain expected entity");
}
}
public void GetPoints(BackendlessGeoQuery geoQuery, AsyncCallback <BackendlessCollection <GeoPoint> > callback)
{
try
{
checkGeoQuery(geoQuery);
Invoker.Api api = Invoker.Api.UNKNOWN;
string query = GetGetPointsQuery(geoQuery, out api);
var responder = new AsyncCallback <Dictionary <string, BackendlessCollection <GeoPoint> > >(r =>
{
BackendlessCollection <GeoPoint> result = null;
if (r != null && r.ContainsKey(COLLECTION))
{
result = (BackendlessCollection <GeoPoint>)r[COLLECTION];
result.Query = geoQuery;
}
if (callback != null)
{
callback.ResponseHandler.Invoke(result);
}
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
Invoker.InvokeAsync <Dictionary <string, BackendlessCollection <GeoPoint> > >(api, new Object[] { null, query }, responder);
}
catch (System.Exception ex)
{
if (callback != null)
{
callback.ErrorHandler.Invoke(new BackendlessFault(ex));
}
else
{
throw;
}
}
}
public BackendlessCollection <GeoPoint> GetPoints(BackendlessGeoQuery geoQuery)
{
checkGeoQuery(geoQuery);
Invoker.Api api = Invoker.Api.UNKNOWN;
string query = GetGetPointsQuery(geoQuery, out api);
BackendlessCollection <GeoPoint> result = null;
Dictionary <string, BackendlessCollection <GeoPoint> > r = Invoker.InvokeSync <Dictionary <string, BackendlessCollection <GeoPoint> > >(api, new Object[] { null, query });
if (r != null && r.ContainsKey(COLLECTION))
{
result = (BackendlessCollection <GeoPoint>)r[COLLECTION];
result.Query = geoQuery;
}
return(result);
}
public void GetCollectionAndCheck(double startingLat, double startingLong, int maxPoints, double offset,
Dictionary <string, string> meta, BackendlessGeoQuery geoQuery)
{
int counter = maxPoints;
if (geoQuery.Categories.Count == 0 && GetDefinedCategories() != null)
{
geoQuery.Categories = GetDefinedCategories();
}
BackendlessCollection <GeoPoint> geoPointBackendlessCollection = Backendless.Geo.GetPoints(geoQuery);
Assert.IsNotNull(geoPointBackendlessCollection, "Server returned a null collection");
foreach (GeoPoint geoPoint in geoPointBackendlessCollection.GetCurrentPage())
{
if (meta == null || meta.Count == 0)
{
Assert.IsTrue(geoPoint.Metadata.Count == 0, "Server returned points with unexpected metadata");
}
else
{
foreach (KeyValuePair <string, string> keyValuePair in meta)
{
Assert.IsTrue(geoPoint.Metadata.ContainsKey(keyValuePair.Key), "Server returned points with unexpected metadata");
Assert.IsTrue(geoPoint.Metadata[keyValuePair.Key].Equals(keyValuePair.Value), "Server returned points with unexpected metadata");
}
}
Assert.AreEqual(startingLat, geoPoint.Latitude, 0.0000000001d,
"Server returned points from unexpected latitude range");
Assert.IsTrue(geoPoint.Longitude >= startingLong && geoPoint.Longitude <= (startingLong + offset),
"Server returned points from unexpected longtitude range");
counter--;
}
Assert.AreEqual(counter, 0, "Server found wrong total points count");
}
public void TestFindWithWhereEntities()
{
var entities = new List <FindWithWhereEntity>();
for (int i = 0; i < 10; i++)
{
var findWithWhereEntity = new FindWithWhereEntity();
findWithWhereEntity.Name = "bot_#" + i;
findWithWhereEntity.Age = 20 + i;
Backendless.Persistence.Save(findWithWhereEntity);
if (i < 5)
{
entities.Add(findWithWhereEntity);
}
}
BackendlessDataQuery dataQuery = new BackendlessDataQuery("Age < 25");
BackendlessCollection <FindWithWhereEntity> backendlessCollection =
Backendless.Persistence.Of <FindWithWhereEntity>().Find(dataQuery);
AssertArgumentAndResultCollections(entities, backendlessCollection);
}
