public async Task <bool> DeleteDataFromDatabase()
{
var success = true;
try
{
await _recipiesTable.PurgeAsync(true);
await _categoriesTable.PurgeAsync(true);
await _favoritesTable.PurgeAsync(true);
await _ingredientsTable.PurgeAsync(true);
await _quantityTypeTable.PurgeAsync(true);
await _categoriesTable.PurgeAsync(true);
}
catch (Exception e)
{
success = false;
}
return(success);
}
public async Task PurgeAsync <U>(string queryId, IMobileServiceTableQuery <U> query, CancellationToken cancellationToken)
{
if (!await InitializeAsync())
{
throw new MobileServiceInvalidOperationException("Unable to purge data. Initialization failed.", null, null);
}
await _syncTable.PurgeAsync(queryId, query, cancellationToken);
}
public async Task PurgeAsync(Expression <Func <TEntity, bool> > Filter)
{
try
{
var tableQuery = tEntity.CreateQuery().Where(Filter);
await tEntity.PurgeAsync($"purge_{tEntity.TableName}", tableQuery, true, CancellationToken.None);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
public async Task LogOffAsync()
{
// Delete the local cache
CrossSecureStorage.Current.DeleteKey(App.UserIdKey);
CrossSecureStorage.Current.DeleteKey(App.TokenKey);
if (azureClient.CurrentUser == null)
{
return;
}
// Throw away token cache on server
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("X-ZUMO-AUTH", azureClient.CurrentUser.MobileServiceAuthenticationToken);
await client.GetAsync(azureClient.MobileAppUri + "/.auth/logout");
}
// Throw away token in client library
await azureClient.LogoutAsync();
Debug.Assert(azureClient.CurrentUser == null);
// Finally, purge the local data.
await entriesTable.PurgeAsync(true);
if (azureClient.CurrentUser != null)
{
azureClient.CurrentUser = null;
}
}
public async Task SyncAsync()
{
ReadOnlyCollection <MobileServiceTableOperationError> syncErrors = null;
try
{
await client.SyncContext.PushAsync();
await vehicleTable.PullAsync("allVehicleRecords", vehicleTable.CreateQuery().Where(v => v.ParkingLotId == Settings.ParkingLotId));
// the parkingLotId comparison is in case the user change it in Settings.
await vehicleTable.PurgeAsync(vehicleTable.CreateQuery().Where(v => v.Done || v.ParkingLotId != Settings.ParkingLotId));
}
catch (MobileServicePushFailedException exc)
{
syncErrors = exc.PushResult?.Errors;
}
if (syncErrors != null)
{
foreach (var error in syncErrors)
{
if (error.OperationKind == MobileServiceTableOperationKind.Update && error.Result != null)
{
await error.CancelAndUpdateItemAsync(error.Result);
}
else
{
await error.CancelAndDiscardItemAsync();
}
Console.WriteLine(@"Error executing sync operation. Item: {0} ({1}). Operation discarded.", error.TableName, error.Item["id"]);
}
}
}
public async Task <List <User> > GetUser()
{
await UserTable.PurgeAsync();
await SyncUserAsync();
return(await UserTable.ToListAsync());
}
public async Task PurgeAll()
{
await this.Initializer();
var query = table.CreateQuery();
await table.PurgeAsync("todo-incremental", query, new System.Threading.CancellationToken());
}
public async Task PurgeData()
{
if (_client.SyncContext.PendingOperations > 0)
{
await _client.SyncContext.PushAsync();
}
await _table.PurgeAsync();
}
public async Task <List <FormItem> > RefreshForms(string userId)
{
await Initialize();
await formTable.PurgeAsync();
await formTable.PullAsync(null, formTable.CreateQuery().Where(c => c.UserID == userId));
return(await formTable.OrderByDescending(c => c.EnteredDateUTC).ToListAsync());
}
public async Task UpdateMoviesAsync(List <Movie> movies)
{
await InitAndSync();
await _moviesTable.PurgeAsync();
foreach (var movie in movies)
{
await _moviesTable.InsertAsync(movie);
}
}
public async Task PurgeAsync()
{
try
{
var query = sensorDataTable.Where(s => s.speed > 0);
await sensorDataTable.PurgeAsync(query);
}
catch (MobileServiceInvalidOperationException e)
{
Console.Error.WriteLine(@"Purge Failed: {0}", e.Message);
}
}
internal async Task PurgeDataAsync()
{
IPlatform platform = DependencyService.Get <IPlatform>();
await vehicleTableSync.PurgeFilesAsync();
await vehicleTableSync.PurgeAsync(QueryVehicleString, null, true, CancellationToken.None);
await claimTableSync.PurgeFilesAsync();
await claimTableSync.PurgeAsync(QueryClaimString, null, true, CancellationToken.None);
//delete downloaded files
await FileHelper.DeleteLocalPathAsync(await platform.GetDataFilesPath());
}
/*********************************************************************/
/* Get the Azure login credentials */
/*********************************************************************/
public async Task <AzureToken> GetAzureTokenAsync(LocalToken currentUser)
{
//APPARENTLY THIS DOES NOT WORK PROPERLY
await _azureTokenTable.PullAsync("loginUser",
_azureTokenTable.Where(user => user.Id == currentUser.Id));
List <AzureToken> _tokenList = await _azureTokenTable.Where(user =>
user.Id == currentUser.Id).ToListAsync();
//DELETE THE LOGIN INFORMATION
await _azureTokenTable.PurgeAsync();
return(_tokenList[0]);
}
public static async Task <bool> PurgeTableAsync()
{
try
{
await HomeSyncTable.PurgeAsync(true);
Debug.WriteLine("HomeTableController.PurgeTableAsync - Table Purged");
return(true);
}
catch (Exception e)
{
Debug.WriteLine("AccountTableController.PurgeTableAsync - Error message recieved: " + e.Message);
return(false);
}
}
private async Task PurgeDataAsync()
{
var platform = DependencyService.Get <IPlatform>();
await platform.LogoutAsync();
await imageTableSync.PurgeAsync(AllImagesQueryString, null, true, CancellationToken.None);
await albumTableSync.PurgeAsync(AllAlbumsQueryString, null, true, CancellationToken.None);
// delete downloaded files
await FileHelper.DeleteLocalFileAsync(await platform.GetDataFilesPath());
Settings.Current.AuthenticationType = Settings.AuthOption.GuestAccess;
Settings.Current.CurrentUserId = Settings.Current.DefaultUserId;
}
public static async Task <bool> PurgeTableAsync()
{
try
{
await deviceTable.PurgeAsync(true);
Debug.WriteLine("DeviceTable.PurgeTableAsync - Table Purged");
return(true);
}
catch (Exception e)
{
Debug.WriteLine("DeviceTable.PurgeTableAsync - Error message recieved: " + e.Message);
return(false);
}
}
private async Task InitializeAsync()
{
if (_avisoTable != null)
{
return;
}
// Inicialización de SQLite local
var store = new MobileServiceSQLiteStore(GlobalSettings.Database);
store.DefineTable <Aviso>();
await _client.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
_avisoTable = _client.GetSyncTable <Aviso>();
// Limpiar registros offline.
await _avisoTable.PurgeAsync(true);
}
public async Task InitializeAsync()
{
if (azureClient?.SyncContext?.IsInitialized ?? false)
{
return;
}
//if (entriesTable != null)
// return;
//InitialzeDatabase for path
var path = localDatabaseFile;
path = Path.Combine(MobileServiceClient.DefaultDatabasePath, path);
//setup our local sqlite store and intialize our table
store = new MobileServiceSQLiteStore(path);
//Define Table
store.DefineTable <DiaryEntry>();
store.DefineTable <User>();
try
{
//Initialize SyncContext
await azureClient.SyncContext.InitializeAsync(store, new AzureSyncHandler(azureClient));
//Get our sync table that will call out to azure
entriesTable = azureClient.GetSyncTable <DiaryEntry>();
userTable = azureClient.GetSyncTable <User>();
//Clean out local table
await userTable.PurgeAsync(true);
}
catch (Exception ex)
{
Debug.WriteLine("Got exception: {0}", ex.Message);
}
}
public async Task SynchronizeTopPostsAsync()
{
if (!LocalDBExists)
{
await Init();
}
try
{
await _topPostTable.PullAsync("MainPage", _topPostTable.CreateQuery());
IList <TopPost> posts = await _topPostTable.Where(p => p.UserId == "u1").ToListAsync();
foreach (var post in posts)
{
Debug.WriteLine(post.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
await _topPostTable.PurgeAsync();
}
}
public async Task SynchronizePostsAsync()
{
if (!LocalDBExists)
{
await Init();
}
try
{
await _postTable.PullAsync("syncPosts", _postTable.CreateQuery());
IEnumerable <Post> posts = await _postTable.Where(p => p.UserId == "u1").ToEnumerableAsync();
foreach (var post in posts)
{
Debug.WriteLine(post.Id);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
await _postTable.PurgeAsync();
}
}
/// <summary>
/// Ensures the data is seeded.
/// </summary>
async Task EnsureDataIsSeededAsync()
{
if (Settings.DataIsSeeded)
{
return;
}
await _RecipeTable.PullAsync($"getAll{typeof(Recipe).Name}", _RecipeTable.Where(x => x.DataPartitionId == _DataPartitionId)).ConfigureAwait(false);
var any = (await _RecipeTable.Where(x => x.DataPartitionId == _DataPartitionId).OrderBy(x => x.Name).ToEnumerableAsync().ConfigureAwait(false)).Any();
if (any)
{
Settings.DataIsSeeded = true;
}
await _RecipeTable.PurgeAsync();
if (!Settings.DataIsSeeded)
{
var newItems = SeedData.Get("");
foreach (var i in newItems)
{
try
{
await _RecipeTable.InsertAsync(i);
}
catch (Exception e)
{
throw e;
}
}
Settings.DataIsSeeded = true;
}
}
public async Task ClearTable()
{
await mainTable.PurgeAsync(true);
}
public Task PurgeAsync()
{
return(_mobileServiceSyncTable.PurgeAsync(true));
}
public async Task Insert_ThenPush_ThenPull_ThenRead_ThenUpdate_ThenRefresh_ThenDelete_ThenLookup_ThenPush_ThenPurge_ThenRead()
{
ResetDatabase(TestTable);
var hijack = new TestHttpHandler();
hijack.AddResponseContent("{\"id\":\"b\",\"String\":\"Hey\"}"); // insert response
hijack.AddResponseContent("[{\"id\":\"b\",\"String\":\"Hey\"},{\"id\":\"a\",\"String\":\"World\"}]"); // pull response
hijack.AddResponseContent("[]"); // pull last page
IMobileServiceClient service = await CreateTodoClient(hijack);
IMobileServiceSyncTable <ToDoWithStringId> table = service.GetSyncTable <ToDoWithStringId>();
// first insert an item
await table.InsertAsync(new ToDoWithStringId()
{
Id = "b", String = "Hey"
});
// then push it to server
await service.SyncContext.PushAsync();
// then pull changes from server
await table.PullAsync(null, null);
// order the records by id so we can assert them predictably
IList <ToDoWithStringId> items = await table.OrderBy(i => i.Id).ToListAsync();
// we should have 2 records
Assert.Equal(2, items.Count);
// according to ordering a id comes first
Assert.Equal("a", items[0].Id);
Assert.Equal("World", items[0].String);
// then comes b record
Assert.Equal("b", items[1].Id);
Assert.Equal("Hey", items[1].String);
// we made 2 requests, one for push and two for pull
Assert.Equal(3, hijack.Requests.Count);
// recreating the client from state in the store
service = await CreateTodoClient(hijack);
table = service.GetSyncTable <ToDoWithStringId>();
// update the second record
items[1].String = "Hello";
await table.UpdateAsync(items[1]);
// create an empty record with same id as modified record
var second = new ToDoWithStringId()
{
Id = items[1].Id
};
// refresh the empty record
await table.RefreshAsync(second);
// make sure it is same as modified record now
Assert.Equal(second.String, items[1].String);
// now delete the record
await table.DeleteAsync(second);
// now try to get the deleted record
ToDoWithStringId deleted = await table.LookupAsync(second.Id);
// this should be null
Assert.Null(deleted);
// try to get the non-deleted record
ToDoWithStringId first = await table.LookupAsync(items[0].Id);
// this should still be there;
Assert.NotNull(first);
// make sure it is same as
Assert.Equal(first.String, items[0].String);
// recreating the client from state in the store
service = await CreateTodoClient(hijack);
table = service.GetSyncTable <ToDoWithStringId>();
await service.SyncContext.PushAsync();
// now purge the remaining records
await table.PurgeAsync();
// now read one last time
IEnumerable <ToDoWithStringId> remaining = await table.ReadAsync();
// There shouldn't be anything remaining
Assert.Empty(remaining);
}
public async Task CleanData()
{
await _table.PurgeAsync("allContacts", _table.CreateQuery(), new System.Threading.CancellationToken());
}
public async Task CleanData()
{
await Table.PurgeAsync("GetAllCategories", Table.CreateQuery(), new System.Threading.CancellationToken());
}
public async Task PurgeData()
{
await offlineTimesheet.PurgeAsync("allOfflineTimesheet", null, true, CancellationToken.None);
}
public async Task CleanLoginData()
{
await _loginTable.PurgeAsync("allLogins", _loginTable.CreateQuery(), new System.Threading.CancellationToken());
}
public async Task CleanPoItemData()
{
await _purchaseOrderItemTable.PurgeAsync("allPoItems", _purchaseOrderItemTable.CreateQuery(), new System.Threading.CancellationToken());
}
public async Task CleanAsync()
{
await _table.PurgeAsync("allContacts", string.Empty, true, new
System.Threading.CancellationToken())
.ContinueWith((b) => { SetNotification(GetPendingOperations()); });
}
