public async Task <ObservableCollection <Job2> > GetJob2sAsync(bool syncItems = false) { try { #if OFFLINE_SYNC_ENABLED if (syncItems) { await this.SyncAsync(); } #endif IEnumerable <Job2> items = await job2Table // .Where(couItem => !couItem.Done) .ToEnumerableAsync(); return(new ObservableCollection <Job2>(items)); } catch (MobileServiceInvalidOperationException msioe) { Debug.WriteLine(@"Invalid sync operation: {0}", msioe.Message); } catch (Exception e) { Debug.WriteLine(@"Sync error: {0}", e.Message); } return(null); }
public async Task <ObservableCollection <TodoItem> > GetWholeAsync(bool syncItems = false) { try { #if OFFLINE_SYNC_ENABLED if (syncItems) { await this.SyncAsync(); } #endif IEnumerable <TodoItem> items = await todoTable //.Where(todoItem => !todoItem.Done) .ToEnumerableAsync(); return(new ObservableCollection <TodoItem>(items)); } catch (MobileServiceInvalidOperationException msioe) { Debug.WriteLine("Invalid sync operation: {0}", new[] { msioe.Message }); } catch (Exception e) { Debug.WriteLine("Sync error: {0}", new[] { e.Message }); } return(null); }
public async Task <ObservableRangeCollection <T> > FilterItemsAsync(Func <T, bool> filter, bool sync) { if (sync) { await this.SyncAsync(); } var items = await table.ToEnumerableAsync(); var filtered = items.Where(filter); return(new ObservableRangeCollection <T>(filtered)); }
public async Task <IEnumerable> GetTodos() { await Initialize(); await SyncTodo(); return(await _todoTable.ToEnumerableAsync()); }
public async Task <IEnumerable <TodoItem> > GetAllItemsAsync() { await InitializeAsync(); await SynchronizeServiceAsync(); return(await itemTable.ToEnumerableAsync()); }
public async Task <IEnumerable <Tag> > GetAllTagsAsync() { await InitializeAsync(); await SynchronizeServiceAsync(); return(await tagTable.ToEnumerableAsync()); }
public async Task <IEnumerable <BarberSchedule> > GetSchedule() { await Initialize(); await SyncSchedule(); return(await scheduleTable.ToEnumerableAsync()); }
public async Task <IEnumerable <Word> > GetWords() { await Initialize(); await SyncWords(); return(await wordTable.ToEnumerableAsync()); }
public async Task <ObservableCollection <Log> > GetTodoItemsAsync(bool syncItems = false) { try { #if OFFLINE_SYNC_ENABLED if (syncItems) { await this.SyncAsync(); } #endif IEnumerable <Log> items = await todoTable .ToEnumerableAsync(); //items = items.OrderBy(C => C.date); return(new ObservableCollection <Log>(items)); } catch (MobileServiceInvalidOperationException msioe) { Debug.WriteLine("Invalid sync operation: {0}", new[] { msioe.Message }); } catch (Exception e) { Debug.WriteLine("Sync error: {0}", new[] { e.Message }); } return(null); }
public async Task <IEnumerable <Aviso> > ReadAvisosAsync() { await InitializeAsync(); await SynchronizeAsync(); return(await _avisoTable.ToEnumerableAsync()); }
public async Task <IEnumerable <Assignment> > GetAssignments() { await Initialize(); await SyncAssignments(); return(await AssignmentTable.ToEnumerableAsync()); }
public async Task <IEnumerable <Activities> > GetActivities() { //await Initialize(); await SyncActivties(); return(await _activities.ToEnumerableAsync()); }
public async Task <ObservableCollection <Contact> > GetItemsAsync(bool syncItems = false) { try { if (syncItems) { await SyncAsync(); } IEnumerable <Contact> items = await contactTable.ToEnumerableAsync(); return(new ObservableCollection <Contact>(items)); } catch (MobileServiceInvalidOperationException mobException) { Debug.WriteLine($"Excepción: {mobException.Message}"); } catch (Exception ex) { Debug.WriteLine($"Excepción: {ex.Message}"); } return(null); }
public async Task <IEnumerable <DiaryEntry> > GetAllEntry() { await InitializeAsync(); await SynchronizeEntriesAsync(); return(await entriesTable.ToEnumerableAsync()); }
public async Task <IEnumerable <ToDoItem> > GetToDos() { await Initialize(); await SyncToDos(); return(await todoTable.ToEnumerableAsync()); }
public async Task <IEnumerable <Message> > GetMessages() { await Initialize(); await SyncMessage(); return(await _messageTable.ToEnumerableAsync()); }
public async Task <IEnumerable <Topic> > GetTopics() { await Initialize(); await Sync(); return(await topicsTable.ToEnumerableAsync()); }
public async Task <ObservableCollection <Familiar> > RefreshDataAsync(bool syncItems = false) { try { #if OFFLINE_SYNC_ENABLED if (syncItems) { await this.SyncAsync(); } #endif var items = await FamiliarTable .ToEnumerableAsync(); return(new ObservableCollection <Familiar>(items)); } catch (MobileServiceInvalidOperationException msioe) { Debug.WriteLine(@"Invalid sync operation: {0}", msioe.Message); } catch (Exception e) { Debug.WriteLine(@"Sync error: {0}", e.Message); } return(null); }
public async Task <ObservableCollection <Client> > GetClientsAsync(bool syncItems = false) { try { if (syncItems) { await this.SyncAsync(); } IEnumerable <Client> items = await todoTable .ToEnumerableAsync(); Clients.Clear(); foreach (var item in items.OrderBy(a => a.FirstName)) { if (item.Hide) { continue; } Clients.Add(item); } return(new ObservableCollection <Client>(items)); } catch (MobileServiceInvalidOperationException msioe) { Debug.WriteLine(@"Invalid sync operation: {0}", msioe.Message); } catch (Exception e) { Debug.WriteLine(@"Sync error: {0}", e.Message); } return(null); }
public async Task <ObservableCollection <TodoItem> > GetTodoItemsAsync(bool syncItems = false) { try { #if OFFLINE_SYNC_ENABLED if (syncItems) { await this.SyncAsync(); } #endif IEnumerable <TodoItem> items = await todoTable .ToEnumerableAsync(); return(new ObservableCollection <TodoItem>(items.Reverse())); } catch (MobileServiceInvalidOperationException msioe) { Debug.WriteLine(@"Invalid sync operation: {0}", msioe.Message); } catch (Exception e) { Debug.WriteLine(@"Sync error: {0}", e.Message); } return(null); }
public async Task <IEnumerable <Feedback> > GetFeedback() { //Initialize & Sync await Initialize(); await SyncFeedback(); return(await feedbackTable.ToEnumerableAsync());//.OrderBy(c => c.DateUtc).ToEnumerableAsync(); }
public async Task <IEnumerable <Location> > GetLocations() { //Initialize & Sync await Initialize(); await SyncLocations(); return(await locationsTable.ToEnumerableAsync());//.OrderBy(c => c.DateUtc).ToEnumerableAsync(); }
public async Task<IEnumerable<Item>> GetItemsAsync(bool forceRefresh = false) { await InitializeAsync(); if (forceRefresh) await PullLatestAsync(); return await itemsTable.ToEnumerableAsync(); }
public async Task <IEnumerable <Client> > GetClients() { if (Plugin.Connectivity.CrossConnectivity.Current.IsConnected) { await SyncAsync(); } return(await _table.ToEnumerableAsync()); }
public async Task <IEnumerable <Expense> > GetExpensesAsync() { await Initialize(); await SyncExpenses(); return(await _expensesTable.ToEnumerableAsync()); }
public async Task <IEnumerable <ExpenseCategory> > GetExpenseCategories() { await Initialize(); await _expenseCategoryTable.PullAsync("expenseCategories", _expenseCategoryTable.CreateQuery()); return(await _expenseCategoryTable.ToEnumerableAsync()); }
public async Task <IEnumerable <Order> > GetAllOrdersAsync() { return(await Execute <IEnumerable <Order> >( async() => await _OrderTable.ToEnumerableAsync(), new List <Order>() )); }
public async Task <DataStoreSyncResult <T> > GetItemsAsync <T>(bool syncItems = false, bool includeNavigationProperties = false) where T : class, ISyncEntity { try { var result = new DataStoreSyncResult <T>(); if (syncItems) { result.Code = await SyncAsync(); } IEnumerable <T> items = null; if (typeof(T).Equals(typeof(Tag))) { items = (IEnumerable <T>)(await _tagTable.ToEnumerableAsync()); } else if (typeof(T).Equals(typeof(Contact))) { items = (IEnumerable <T>)(await _contactTable.ToEnumerableAsync()); } else if (typeof(T).Equals(typeof(Transaction))) { if (includeNavigationProperties) { var transactions = await _transactionTable.ToListAsync(); var contactKeys = transactions.GroupBy(p => p.ContactId).Select(p => p.Key); var contacts = await _contactTable.Where(p => contactKeys.Contains(p.Id)).ToEnumerableAsync(); foreach (var transaction in transactions) { transaction.Contact = contacts.Single(p => p.Id == transaction.ContactId); } items = (IEnumerable <T>)transactions; } else { items = (IEnumerable <T>)(await _transactionTable.ToEnumerableAsync()); } } if (result.Code == DataStoreSyncCode.None) { result.Code = DataStoreSyncCode.Success; } result.Items = new ObservableCollection <T>(items); return(result); } catch (MobileServiceInvalidOperationException msioe) { Debug.WriteLine($"Invalid sync operation: {msioe.Message}"); } catch (Exception ex) { Debug.WriteLine($"Sync Error: {ex.Message}"); } return(null); }
public async Task <ObservableCollection <SPECIES_LA_LONG> > GetPinsAsync() { await SyncPins(); IEnumerable <SPECIES_LA_LONG> items = await pinsTable .ToEnumerableAsync(); return(new ObservableCollection <SPECIES_LA_LONG>(items)); }
public async Task <IEnumerable <Order> > GetAllOrdersAsync() { return(await Execute <IEnumerable <Order> >( InsightsReportingConstants.TIME_ORDERS_GET_ALL, async() => await _OrderTable.ToEnumerableAsync(), new List <Order>() )); }