コード例 #1
0
        private static MobileServiceTableQuery <Movie> ApplyOrdering(MobileServiceTableQuery <Movie> query, OrderByClause[] orderBy)
        {
            if (orderBy.Length == 1)
            {
                if (orderBy[0].IsAscending && orderBy[0].FieldName == "Title")
                {
                    return(query.OrderBy(m => m.Title));
                }
                else if (!orderBy[0].IsAscending && orderBy[0].FieldName == "Year")
                {
                    return(query.OrderByDescending(m => m.Year));
                }
            }
            else if (orderBy.Length == 2)
            {
                if (orderBy[1].FieldName == "Title" && orderBy[1].IsAscending)
                {
                    if (orderBy[0].FieldName == "Duration" && orderBy[0].IsAscending)
                    {
                        return(query.OrderBy(m => m.Duration).ThenBy(m => m.Title));
                    }
                    else if (orderBy[0].FieldName == "ReleaseDate" && !orderBy[0].IsAscending)
                    {
                        return(query.OrderByDescending(m => m.ReleaseDate).ThenBy(m => m.Title));
                    }
                }
            }

            throw new NotImplementedException(string.Format("Ordering by [{0}] not implemented yet",
                                                            string.Join(", ", orderBy.Select(c => string.Format("{0} {1}", c.FieldName, c.IsAscending ? "asc" : "desc")))));
        }
コード例 #2
0
        public InviteUserViewModel(MainViewModel parent, IMobileServiceTable <Profile> profileTable, Action dismiss)
        {
            _profileTable = profileTable;
            _parent       = parent;
            _dismiss      = dismiss;

            SearchCommand = new DelegateCommand(() =>
            {
                _currentPage = 0;
                if (String.IsNullOrWhiteSpace(SearchText))
                {
                    _query = profileTable.Take(_pageCount).IncludeTotalCount();
                }
                else
                {
                    _query = profileTable.Take(_pageCount).IncludeTotalCount().Where(p => p.Name.IndexOf(SearchText) > -1);
                }
                RefreshQuery();
            });

            NextCommand = new DelegateCommand(() =>
            {
                _currentPage++;
                RefreshQuery();
            }, false);

            PrevCommand = new DelegateCommand(() =>
            {
                _currentPage--;
                RefreshQuery();
            }, false);
        }
コード例 #3
0
        public InviteUserViewModel(MainViewModel parent, IMobileServiceTable<Profile> profileTable, Action dismiss)
        {
            _profileTable = profileTable;
            _parent = parent;
            _dismiss = dismiss;

            SearchCommand = new DelegateCommand(() =>
            {
                _currentPage = 0;
                if (String.IsNullOrWhiteSpace(SearchText))
                {
                    _query = profileTable.Take(_pageCount).IncludeTotalCount();
                }
                else
                {
                    _query = profileTable.Take(_pageCount).IncludeTotalCount().Where(p => p.Name.IndexOf(SearchText) > -1);
                }
                RefreshQuery();
            });

            NextCommand = new DelegateCommand(() =>
            {
                _currentPage++;
                RefreshQuery();
            }, false);

            PrevCommand = new DelegateCommand(() =>
            {
                _currentPage--;
                RefreshQuery();
            }, false);
        }
コード例 #4
0
        public async Task TotalCountBasics()
        {
            // Insert a few records
            IMobileServiceTable <ToDo> table = GetClient().GetTable <ToDo>();
            ToDo first = new ToDo {
                Title = "ABC", Complete = false
            };
            await table.InsertAsync(first);

            await table.InsertAsync(new ToDo { Title = "DEF", Complete = true });

            await table.InsertAsync(new ToDo { Title = "GHI", Complete = false });

            ITotalCountProvider            countProvider = null;
            MobileServiceTableQuery <ToDo> query         = table.Where(t => t.Id >= first.Id);

            // Run a simple query and verify we get all 3 items, but the
            // TotalCount is not provided.
            List <ToDo> items = await query.ToListAsync();

            countProvider = items as ITotalCountProvider;
            Assert.AreEqual(3, items.Count);
            Assert.IsNotNull(countProvider);
            Assert.AreEqual(-1L, countProvider.TotalCount);

            IEnumerable <ToDo> sequence = await query.ToEnumerableAsync();

            countProvider = sequence as ITotalCountProvider;
            Assert.IsNotNull(countProvider);
            Assert.AreEqual(-1L, countProvider.TotalCount);

            // Now use IncludeTotalCount and make sure we get the expected
            // number of results
            query = query.IncludeTotalCount();
            items = await query.ToListAsync();

            countProvider = items as ITotalCountProvider;
            Assert.AreEqual(3, items.Count);
            Assert.IsNotNull(countProvider);
            Assert.AreEqual(3L, countProvider.TotalCount);

            sequence = await query.ToEnumerableAsync();

            countProvider = sequence as ITotalCountProvider;
            Assert.IsNotNull(countProvider);
            Assert.AreEqual(3L, countProvider.TotalCount);

            // Verify that IncludeTotalCount is correctly propagated with
            // projections
            List <string> titles = await query.Select(t => t.Title).ToListAsync();

            countProvider = titles as ITotalCountProvider;
            Assert.AreEqual(3, titles.Count);
            Assert.IsNotNull(countProvider);
            Assert.AreEqual(3L, countProvider.TotalCount);
        }
コード例 #5
0
        private static MobileServiceTableQueryDescription Compile <T, U>(Func <IMobileServiceTable <T>, MobileServiceTableQuery <U> > getQuery)
        {
            MobileServiceClient                service = new MobileServiceClient("http://www.test.com");
            IMobileServiceTable <T>            table   = service.GetTable <T>();
            MobileServiceTableQuery <U>        query   = getQuery(table);
            MobileServiceTableQueryDescription odata   = query.Compile();

            App.Harness.Log(">>> " + odata.ToString());
            return(odata);
        }
コード例 #6
0
        private static ZumoTest CreateQueryTest <TExpectedException>(
            string name, Expression <Func <Movie, bool> > whereClause,
            int?top = null, int?skip = null, OrderByClause[] orderBy = null,
            Expression <Func <Movie, string> > selectExpression = null, bool?includeTotalCount = null)
            where TExpectedException : Exception
        {
            return(new ZumoTest(name, async delegate(ZumoTest test)
            {
                try
                {
                    var table = ZumoTestGlobals.Instance.Client.GetTable <Movie>();
                    MobileServiceTableQuery <Movie> query = null;
                    MobileServiceTableQuery <string> selectedQuery = null;

                    if (whereClause != null)
                    {
                        query = table.Where(whereClause);
                    }

                    if (orderBy != null)
                    {
                        if (query == null)
                        {
                            query = table.Where(m => m.Duration == m.Duration);
                        }

                        query = ApplyOrdering(query, orderBy);
                    }

                    if (top.HasValue)
                    {
                        query = query == null ? table.Take(top.Value) : query.Take(top.Value);
                    }

                    if (skip.HasValue)
                    {
                        query = query == null ? table.Skip(skip.Value) : query.Skip(skip.Value);
                    }

                    if (selectExpression != null)
                    {
                        selectedQuery = query == null ? table.Select(selectExpression) : query.Select(selectExpression);
                    }

                    if (includeTotalCount.HasValue)
                    {
                        query = query.IncludeTotalCount();
                    }

                    IEnumerable <Movie> readMovies = null;
                    IEnumerable <string> readProjectedMovies = null;
                    if (selectedQuery == null)
                    {
                        // Both ways of querying should be equivalent, so using both with equal probability here.
                        var tickCount = Environment.TickCount;
                        if ((tickCount % 2) == 0)
                        {
                            test.AddLog("Querying using MobileServiceTableQuery<T>.ToEnumerableAsync");
                            readMovies = await query.ToEnumerableAsync();
                        }
                        else
                        {
                            test.AddLog("Querying using IMobileServiceTable<T>.ReadAsync(MobileServiceTableQuery<U>)");
                            readMovies = await table.ReadAsync(query);
                        }
                    }
                    else
                    {
                        readProjectedMovies = await selectedQuery.ToEnumerableAsync();
                    }

                    long actualTotalCount = -1;
                    ITotalCountProvider totalCountProvider = (readMovies as ITotalCountProvider) ?? (readProjectedMovies as ITotalCountProvider);
                    if (totalCountProvider != null)
                    {
                        actualTotalCount = totalCountProvider.TotalCount;
                    }

                    IEnumerable <Movie> expectedData = ZumoQueryTestData.AllMovies;
                    if (whereClause != null)
                    {
                        expectedData = expectedData.Where(whereClause.Compile());
                    }

                    long expectedTotalCount = -1;
                    if (includeTotalCount.HasValue && includeTotalCount.Value)
                    {
                        expectedTotalCount = expectedData.Count();
                    }

                    if (orderBy != null)
                    {
                        expectedData = ApplyOrdering(expectedData, orderBy);
                    }

                    if (skip.HasValue)
                    {
                        expectedData = expectedData.Skip(skip.Value);
                    }

                    if (top.HasValue)
                    {
                        expectedData = expectedData.Take(top.Value);
                    }


                    if (includeTotalCount.HasValue)
                    {
                        if (expectedTotalCount != actualTotalCount)
                        {
                            test.AddLog("Total count was requested, but the returned value is incorrect: expected={0}, actual={1}", expectedTotalCount, actualTotalCount);
                            return false;
                        }
                    }

                    List <string> errors = new List <string>();
                    bool expectedDataIsSameAsReadData;

                    if (selectExpression != null)
                    {
                        string[] expectedProjectedData = expectedData.Select(selectExpression.Compile()).ToArray();
                        expectedDataIsSameAsReadData = Util.CompareArrays(expectedProjectedData, readProjectedMovies.ToArray(), errors);
                    }
                    else
                    {
                        expectedDataIsSameAsReadData = Util.CompareArrays(expectedData.ToArray(), readMovies.ToArray(), errors);
                    }

                    if (!expectedDataIsSameAsReadData)
                    {
                        foreach (var error in errors)
                        {
                            test.AddLog(error);
                        }

                        test.AddLog("Expected data is different");
                        return false;
                    }
                    else
                    {
                        if (typeof(TExpectedException) == typeof(ExceptionTypeWhichWillNeverBeThrown))
                        {
                            return true;
                        }
                        else
                        {
                            test.AddLog("Error, test should have failed with {0}, but succeeded.", typeof(TExpectedException).FullName);
                            return false;
                        }
                    }
                }
                catch (TExpectedException ex)
                {
                    test.AddLog("Caught expected exception - {0}: {1}", ex.GetType().FullName, ex.Message);
                    return true;
                }
            }));
        }
コード例 #7
0
 private async Task Query <T, U>(Func <IMobileServiceTable <T>, MobileServiceTableQuery <U> > getQuery)
 {
     IMobileServiceTable <T>     table = GetClient().GetTable <T>();
     MobileServiceTableQuery <U> query = getQuery(table);
     await table.ReadAsync(query);
 }