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); }