public void TestCollectionGetPage()
{
var getPageEntities = new List <GetPageEntity>();
for (int i = 10; i < 30; i++)
{
var entity = new GetPageEntity {
Name = "name#" + i, Age = 20 + i
};
Backendless.Persistence.Save(entity);
if (i > 19 && i < 30)
{
getPageEntities.Add(entity);
}
Thread.Sleep(1000);
}
var dataQuery = new BackendlessDataQuery(new QueryOptions(10, 0, "Age"));
var collection = Backendless.Persistence.Of <GetPageEntity>().Find(dataQuery).GetPage(10, 10);
Assert.IsNotNull(collection, "Next page returned a null object");
Assert.IsNotNull(collection.GetCurrentPage(), "Next page contained a wrong data size");
Assert.AreEqual(getPageEntities.Count, collection.GetCurrentPage().Count, "Next page returned a wrong size");
foreach (GetPageEntity entity in getPageEntities)
{
Assert.IsTrue(collection.GetCurrentPage().Contains(entity), "Server result didn't contain expected entity");
}
}
public void TestFindWithExtraPropertiesQuery()
{
var findWithPropertiesEntity = new FindWithPropertiesEntity {
Name = "bot_#foobar", Age = 20
};
Backendless.Persistence.Save(findWithPropertiesEntity);
var properties = new List <string> {
"Age"
};
var dataQuery = new BackendlessDataQuery(properties);
var 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.IsNull(entity.Name, "Server result contained non null field");
Assert.IsNull(entity.ObjectId, "Server result contained non null field");
Assert.IsNull(entity.Created, "Server result contained non null field");
}
}
public void Find <T>(DataQueryBuilder dataQueryBuilder, AsyncCallback <IList <T> > callback)
{
var responder = new AsyncCallback <IList <T> >(r =>
{
if (callback != null)
{
callback.ResponseHandler.Invoke(r);
}
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
BackendlessDataQuery dataQuery = dataQueryBuilder != null?dataQueryBuilder.Build() : null;
AddWeborbPropertyMapping <T>();
Invoker.InvokeAsync(PERSISTENCE_MANAGER_SERVER_ALIAS, "find",
new object[] { GetTypeName(typeof(T)), dataQuery },
true,
responder);
}
public Int32 GetObjectCount(DataQueryBuilder dataQueryBuilder)
{
BackendlessDataQuery dataQuery = dataQueryBuilder.Build();
return(Invoker.InvokeSync <Int32>(PERSISTENCE_MANAGER_SERVER_ALIAS, "count", new Object[] { tableName, dataQuery },
true));
}
public IList <Dictionary <String, Object> > GetView(String viewName, BackendlessDataQuery dataQuery)
{
CheckPageSizeAndOffset(dataQuery);
Object[] args = new Object[] { viewName, dataQuery };
return(Invoker.InvokeSync <IList <Dictionary <String, Object> > >(PERSISTENCE_MANAGER_SERVER_ALIAS, "callStoredView", args));
}
public void TestFindWithMissingProperties()
{
RunAndAwait(() =>
{
var findWithPropertiesEntity = new FindWithPropertiesEntityAsync {
Name = "bot_#foobar", Age = 20
};
Backendless.Persistence.Save(findWithPropertiesEntity,
new ResponseCallback <FindWithPropertiesEntityAsync>(this)
{
ResponseHandler = response =>
{
var properties = new List <string> {
"foobar"
};
var dataQuery = new BackendlessDataQuery(properties);
Backendless.Persistence.Of <FindWithPropertiesEntityAsync>()
.Find(dataQuery,
new AsyncCallback
<BackendlessCollection <FindWithPropertiesEntityAsync> >
(collection =>
Assert.Fail("Server didn't throw an exception"),
fault => CheckErrorCode(1006, fault)));
}
});
});
}
public void GetObjectCount(DataQueryBuilder dataQueryBuilder, AsyncCallback <Int32> responder)
{
BackendlessDataQuery dataQuery = dataQueryBuilder.Build();
Invoker.InvokeAsync <Int32>(PERSISTENCE_MANAGER_SERVER_ALIAS, "count", new Object[] { tableName, dataQuery }, true,
responder);
}
public int GetObjectCount <T>(DataQueryBuilder dataQueryBuilder)
{
BackendlessDataQuery dataQuery = dataQueryBuilder.Build();
return(Invoker.InvokeSync <int>(PERSISTENCE_MANAGER_SERVER_ALIAS, "count",
new object[] { GetTypeName(typeof(T)), dataQuery }, true));
}
public void GetView(String viewName, BackendlessDataQuery query, AsyncCallback <Dictionary <String, Object> > responder)
{
CheckPageSizeAndOffset(query);
Object[] args = new Object[] { viewName, query };
Invoker.InvokeAsync(PERSISTENCE_MANAGER_SERVER_ALIAS, "callStoredView", args, responder);
}
public void Find(DataQueryBuilder dataQueryBuilder, AsyncCallback <IList <Dictionary <String, Object> > > callback)
{
var responder = new AsyncCallback <IList <Dictionary <String, Object> > >(
r =>
{
if (callback != null)
{
callback.ResponseHandler.Invoke(r);
}
},
f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
if (dataQueryBuilder == null)
{
dataQueryBuilder = DataQueryBuilder.Create();
}
BackendlessDataQuery dataQuery = dataQueryBuilder.Build();
Object[] args = { tableName, dataQuery };
Invoker.InvokeAsync(PERSISTENCE_MANAGER_SERVER_ALIAS, "find", args, responder);
}
public void TestCollectionGetPage()
{
RunAndAwait(() =>
{
var getPageEntities = new List <GetPageEntityAsync>();
var latch = new CountdownEvent(20);
for (int i = 10; i < 30; i++)
{
var entity = new GetPageEntityAsync {
Name = "name#" + i, Age = 20 + i
};
Backendless.Persistence.Save(entity,
new AsyncCallback <GetPageEntityAsync>(response => latch.Signal(), fault =>
{
for (int j = 0; j < latch.CurrentCount; j++)
{
latch.Signal();
}
}));
if (i > 19 && i < 30)
{
getPageEntities.Add(entity);
}
}
latch.Wait();
var dataQuery = new BackendlessDataQuery(new QueryOptions(10, 0, "Age"));
Backendless.Persistence.Of <GetPageEntityAsync>()
.Find(dataQuery,
new ResponseCallback <BackendlessCollection <GetPageEntityAsync> >(this)
{
ResponseHandler =
response =>
response.GetPage(10, 10,
new ResponseCallback <BackendlessCollection <GetPageEntityAsync> >(this)
{
ResponseHandler = collection =>
{
Assert.IsNotNull(collection, "Next page returned a null object");
Assert.IsNotNull(collection.GetCurrentPage(),
"Next page contained a wrong data size");
Assert.AreEqual(getPageEntities.Count,
collection.GetCurrentPage().Count,
"Next page returned a wrong size");
foreach (GetPageEntityAsync entity in getPageEntities)
{
Assert.IsTrue(
collection.GetCurrentPage().Contains(entity),
"Server result didn't contain expected entity");
}
CountDown();
}
})
});
});
}
public IEnumerable <Users> GetListOfAllUsers()
{
BackendlessDataQuery dataQuery = new BackendlessDataQuery("name LIKE '%'")
{
QueryOptions = new QueryOptions()
};
return(Backendless.Persistence.Of <Users>().Find(dataQuery).Data);
}
public BackendlessCollection <T> Find <T>(BackendlessDataQuery dataQuery)
{
CheckPageSizeAndOffset(dataQuery);
var result = Invoker.InvokeSync <BackendlessCollection <T> >(Invoker.Api.PERSISTENCESERVICE_FIND, new object[] { null, GetTypeName(typeof(T)), null, GetFindQuery(dataQuery) });
result.Query = dataQuery;
return(result);
}
public int GetNumberOfObjectsFromTable(string query)
{
BackendlessDataQuery dataQuery = new BackendlessDataQuery(query)
{
QueryOptions = new QueryOptions()
};
return(Backendless.Data.Of <TaskModel>().Find(dataQuery).TotalObjects);
}
public TaskModel GetObjectFromTable(string query)
{
BackendlessDataQuery dataQuery = new BackendlessDataQuery(query)
{
QueryOptions = new QueryOptions()
};
return(Backendless.Data.Find <TaskModel>(dataQuery).Data[0]);
}
public List <Comments> GetListOfObjectsFromTable(string query)
{
BackendlessDataQuery dataQuery = new BackendlessDataQuery(query)
{
QueryOptions = new QueryOptions()
};
return(Backendless.Persistence.Of <Comments>().Find(dataQuery).Data);
}
public IList <T> Find <T>(DataQueryBuilder dataQueryBuilder)
{
BackendlessDataQuery dataQuery = dataQueryBuilder != null?dataQueryBuilder.Build() : null;
AddWeborbPropertyMapping <T>();
var result = Invoker.InvokeSync <IList <T> >(PERSISTENCE_MANAGER_SERVER_ALIAS, "find",
new object[] { GetTypeName(typeof(T)), dataQuery }, true);
return((IList <T>)result);
}
public static DataQueryBuilder BackendlessDataQueryToDataQueryBuilder(BackendlessDataQuery dataQuery)
{
DataQueryBuilder dataQueryBuilder = DataQueryBuilder.Create();
if (!string.IsNullOrEmpty(dataQuery.WhereClause))
{
dataQueryBuilder.SetWhereClause(dataQuery.WhereClause);
}
if (dataQuery.Offset > 0)
{
dataQueryBuilder.SetOffset(dataQuery.Offset);
}
if (dataQuery.PageSize > 0)
{
dataQueryBuilder.SetPageSize(dataQuery.PageSize);
}
if (dataQuery.Properties != null)
{
dataQueryBuilder.SetProperties(dataQuery.Properties);
}
if (dataQuery.QueryOptions != null)
{
if (dataQuery.QueryOptions.Offset > 0)
{
dataQueryBuilder.SetOffset(dataQuery.QueryOptions.Offset);
}
if (dataQuery.QueryOptions.PageSize > 0)
{
dataQueryBuilder.SetPageSize(dataQuery.QueryOptions.PageSize);
}
if (dataQuery.QueryOptions.Related != null)
{
dataQueryBuilder.SetRelated(dataQuery.QueryOptions.Related);
}
if (dataQuery.QueryOptions.RelationsDepth > 0)
{
dataQueryBuilder.SetRelationsDepth(dataQuery.QueryOptions.RelationsDepth);
}
if (dataQuery.QueryOptions.SortBy != null)
{
dataQueryBuilder.SetSortBy(dataQuery.QueryOptions.SortBy);
}
}
return(dataQueryBuilder);
}
public OpResult Find(String tableName, DataQueryBuilder queryBuilder)
{
BackendlessDataQuery query = queryBuilder.Build();
String operationResultId = opResultIdGenerator.GenerateOpResultId(OperationType.FIND, tableName);
OperationFind operationFind = new OperationFind(OperationType.FIND, tableName, operationResultId, query);
operations.AddLast(operationFind);
return(TransactionHelper.MakeOpResult(tableName, operationResultId, OperationType.FIND));
}
public void TestFindWithExtraPropertiesQuery()
{
RunAndAwait(() =>
{
var findWithPropertiesEntity = new FindWithPropertiesEntityAsync {
Name = "bot_#foobar", Age = 20
};
Backendless.Persistence.Save(findWithPropertiesEntity,
new ResponseCallback <FindWithPropertiesEntityAsync>(this)
{
ResponseHandler = response =>
{
var properties = new List <string> {
"Age"
};
var dataQuery = new BackendlessDataQuery(properties);
Backendless.Persistence.Of <FindWithPropertiesEntityAsync>()
.Find(dataQuery,
new ResponseCallback
<BackendlessCollection <FindWithPropertiesEntityAsync> >
(this)
{
ResponseHandler = backendlessCollection =>
{
Assert.IsTrue(
backendlessCollection.TotalObjects > 0,
"Server found wrong number of objects");
Assert.IsTrue(
backendlessCollection.GetCurrentPage().Count > 0,
"Server returned wrong number of objects");
foreach (FindWithPropertiesEntityAsync entity in
backendlessCollection.GetCurrentPage())
{
Assert.IsTrue(entity.Age > 0,
"Server result contained wrong age field value");
Assert.IsNull(entity.Name,
"Server result contained non null field");
Assert.IsNull(entity.ObjectId,
"Server result contained non null field");
Assert.IsNull(entity.Created,
"Server result contained non null field");
}
CountDown();
}
});
}
});
});
}
public IList <Dictionary <String, Object> > Find(DataQueryBuilder dataQueryBuilder)
{
if (dataQueryBuilder == null)
{
dataQueryBuilder = DataQueryBuilder.Create();
}
BackendlessDataQuery dataQuery = dataQueryBuilder.Build();
PersistenceService.CheckPageSizeAndOffset(dataQuery);
Object[] args = { tableName, dataQuery };
return(Invoker.InvokeSync <IList <Dictionary <String, Object> > >(PERSISTENCE_MANAGER_SERVER_ALIAS, "find", args));
}
public IList <Dictionary <string, object> > Find(DataQueryBuilder dataQueryBuilder)
{
BackendlessDataQuery dataQuery = null;
if (dataQueryBuilder != null)
{
dataQuery = dataQueryBuilder.Build();
PersistenceService.CheckPageSizeAndOffset(dataQuery);
}
object[] args = new object[] { tableName, dataQueryBuilder };
var result = Invoker.InvokeSync <IList <Dictionary <string, object> > >(PERSISTENCE_MANAGER_SERVER_ALIAS, "find", args);
return((IList <Dictionary <string, object> >)result);
}
private IList <T> LoadRelationsImpl <T>(string parentType, string objectId, LoadRelationsQueryBuilder <T> queryBuilder, AsyncCallback <IList <T> > responder)
{
if (string.IsNullOrEmpty(objectId))
{
if (responder != null)
{
responder.ErrorHandler(new BackendlessFault(ExceptionMessage.NULL_ID));
}
else
{
throw new ArgumentNullException(ExceptionMessage.NULL_ID);
}
}
if (queryBuilder == null)
{
String error = "Cannot execute load relations request. The queryBuilder argument must not be null";
if (responder != null)
{
responder.ErrorHandler(new BackendlessFault(error));
}
else
{
throw new ArgumentNullException(error);
}
}
BackendlessDataQuery dataQuery = queryBuilder.Build();
String relationName = dataQuery.QueryOptions.Related[0];
int pageSize = dataQuery.PageSize;
int offset = dataQuery.Offset;
AddWeborbPropertyMapping <T>();
Object[] args = new Object[] { parentType, objectId, relationName, pageSize, offset };
if (responder == null)
{
return((IList <T>)Invoker.InvokeSync <IList <T> >(PERSISTENCE_MANAGER_SERVER_ALIAS, "loadRelations", args, true));
}
else
{
Invoker.InvokeAsync <IList <T> >(PERSISTENCE_MANAGER_SERVER_ALIAS, "loadRelations", args, true, responder);
return(null);
}
}
internal void FindByPrimaryKey <T>(T entity, DataQueryBuilder queryBuilder, AsyncCallback <T> callback)
{
if (entity == null)
{
throw new ArgumentException(ExceptionMessage.NULL_ENTITY);
}
if (queryBuilder == null)
{
queryBuilder = DataQueryBuilder.Create();
}
BackendlessDataQuery dataQuery = queryBuilder.Build();
AddWeborbPropertyMapping <T>();
Invoker.InvokeAsync(PERSISTENCE_MANAGER_SERVER_ALIAS, "findById", new Object[] { entity, queryBuilder }, true, callback);
}
internal void FindByIdViaDataQueryBuilder <T>(String id, DataQueryBuilder queryBuilder, AsyncCallback <T> callback)
{
if (id == null)
{
throw new ArgumentException(ExceptionMessage.NULL_ID);
}
if (queryBuilder == null)
{
queryBuilder = DataQueryBuilder.Create();
}
BackendlessDataQuery dataQuery = queryBuilder.Build();
AddWeborbPropertyMapping <T>();
Invoker.InvokeAsync(PERSISTENCE_MANAGER_SERVER_ALIAS, "findById", new Object[] { id, dataQuery }, true, callback);
}
internal T FindByPrimaryKey <T>(T entity, DataQueryBuilder queryBuilder)
{
if (entity == null)
{
throw new ArgumentException(ExceptionMessage.NULL_ENTITY);
}
if (queryBuilder == null)
{
queryBuilder = DataQueryBuilder.Create();
}
BackendlessDataQuery dataQuery = queryBuilder.Build();
AddWeborbPropertyMapping <T>();
return(Invoker.InvokeSync <T>(PERSISTENCE_MANAGER_SERVER_ALIAS, "findById",
new Object[] { entity, dataQuery }, true));
}
public void TestFindWithWhereEntities()
{
RunAndAwait(() =>
{
var entities = new List <FindWithWhereEntityAsync>();
var latch = new CountdownEvent(10);
for (int i = 0; i < 10; i++)
{
var findWithWhereEntity = new FindWithWhereEntityAsync();
findWithWhereEntity.Name = "bot_#" + i;
findWithWhereEntity.Age = 20 + i;
Backendless.Persistence.Save(findWithWhereEntity, new AsyncCallback <FindWithWhereEntityAsync>(response => latch.Signal(), fault =>
{
for (int j = 0; j < latch.CurrentCount; j++)
{
latch.Signal();
}
FailCountDownWith(fault);
}));
if (i < 5)
{
entities.Add(findWithWhereEntity);
}
}
latch.Wait();
BackendlessDataQuery dataQuery = new BackendlessDataQuery("Age < 25");
Backendless.Persistence.Of <FindWithWhereEntityAsync>()
.Find(dataQuery,
new ResponseCallback <BackendlessCollection <FindWithWhereEntityAsync> >(this)
{
ResponseHandler =
backendlessCollection =>
AssertArgumentAndResultCollections(entities, backendlessCollection)
});
});
}
public void TestFindWithMissingProperties()
{
var findWithPropertiesEntity = new FindWithPropertiesEntity {
Name = "bot_#foobar", Age = 20
};
Backendless.Persistence.Save(findWithPropertiesEntity);
var properties = new List <string> {
"foobar"
};
var dataQuery = new BackendlessDataQuery(properties);
try
{
Backendless.Persistence.Of <FindWithPropertiesEntity>().Find(dataQuery);
Assert.Fail("Server didn't throw an exception");
}
catch (System.Exception e)
{
CheckErrorCode(1006, e);
}
}
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);
}
public void GetObjectCount <T>(DataQueryBuilder dataQueryBuilder, AsyncCallback <int> callback)
{
var responder = new AsyncCallback <int>(r =>
{
if (callback != null)
{
callback.ResponseHandler.Invoke(r);
}
}, f =>
{
if (callback != null)
{
callback.ErrorHandler.Invoke(f);
}
else
{
throw new BackendlessException(f);
}
});
BackendlessDataQuery dataQuery = dataQueryBuilder.Build();
Invoker.InvokeAsync <int>(PERSISTENCE_MANAGER_SERVER_ALIAS, "count",
new object[] { GetTypeName(typeof(T)), dataQuery }, true, responder);
}
