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