public async Task <bool> DeleteFromDBAsync(FreeDiscItemDownload freeDiscDownloader)
{
if (freeDiscDownloader == null)
{
#if DEBUG
Debug.Write("DeleteFromDBAsync: freeDiscDownloader == null");
#endif
return(false);
}
#if DEBUG
Debug.Write("DeleteFromDB: ID" + freeDiscDownloader.DBID + " Title: " + freeDiscDownloader?.Title + " Status: " + freeDiscDownloader?.ItemStatus.ToString());
#endif
if (freeDiscDownloader.DBID == 0)
{
#if DEBUG
Debug.Write("DeleteFromDB: freeDiscDownloader.DBID == 0 !");
#endif
return(false);
}
try
{
var conn = new SQLite.SQLiteAsyncConnection(App.AppSetting.DBDownloadPath);
await conn.CreateTableAsync <FreeDiscItemDownload>();
await conn.DeleteAsync(freeDiscDownloader);
}
catch (Exception e)
{
#if DEBUG
Debug.Write("DeleteFromDB: Delete error ! : " + e.ToString());
#endif
return(false);
}
return(true);
}
public async Task DeleteCounterAsync(Counter counter)
{
var connection = new SQLiteAsyncConnection(_dbPath);
await connection.DeleteAsync(counter);
OnCountersChanged();
}
public async static Task DeleteItems(int menuId)
{
SQLiteAsyncConnection sqlConnection = new SQLiteAsyncConnection(DbHelper.DB_PATH);
var collectionItem = await sqlConnection.Table<Item>().Where(x => x.MenuId == menuId).ToListAsync();
foreach(Item item in collectionItem)
{
await sqlConnection.DeleteAsync(item);
}
}
public async Task Remove(TrackCollection trackCollection)
{
var connection = new SQLiteAsyncConnection(DbPath);
var loadTracks = await Locator.MusicLibraryVM.TracklistItemRepository.LoadTracks(trackCollection);
foreach (TracklistItem tracklistItem in loadTracks)
{
await Locator.MusicLibraryVM.TracklistItemRepository.Remove(tracklistItem);
}
await connection.DeleteAsync(trackCollection);
}
public async static Task DeleteCounter(int counterId)
{
SQLiteAsyncConnection sqlConnection = new SQLiteAsyncConnection(DbHelper.DB_PATH);
var collectionItem = await sqlConnection.Table<Counter>().Where(x => x.Id == counterId).FirstOrDefaultAsync();
if (collectionItem != null)
{
await sqlConnection.DeleteAsync(collectionItem);
}
await CounterSubscribed();
}
private async void Button_Click_4(object sender, RoutedEventArgs e)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(ApplicationData.Current.LocalFolder.Path + "\\people.db");
var query = conn.Table<Person>().Where(x => x.Name == "张三");
var result = await query.ToListAsync();
foreach (var item in result)
{
await conn.DeleteAsync(item);
}
}
public async Task<int> DeleteVisit(Visit visit) {
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(this.dbPath);
return await conn.DeleteAsync(visit);
}
async Task PickAlbumsFromDir()
{
var now = DateTime.Now;
var albumFolders = await KnownFolders.MusicLibrary.GetFoldersAsync(Windows.Storage.Search.CommonFolderQuery.GroupByArtist);
foreach (var albumFolder in albumFolders)
{
Debug.WriteLine(albumFolder.Name);
var files = from b in await albumFolder.GetFilesAsync()
where !b.Path.EndsWith(".jpg")
select b;
var propDict = (from b in files
select new { b.Properties.GetMusicPropertiesAsync().AsTask().Result,
Value = b }
).ToDictionary(b => b.Result, b => b.Value);
var musicProperties = from b in propDict.Keys
orderby b.TrackNumber
group b by b.Album;
var albumPool = new List<Album>() { };
foreach (var tracks in musicProperties)
{
var props = tracks.ToList();
var paths = (from b in props
select propDict[b].Path).ToList();
var yearDesc = 10000 - props[0].Year;
var albumID = $"{props[0].Artist} {yearDesc} {props[0].Album}";
var db1 = new SQLiteAsyncConnection("PlaneAudioU.db");
var album = await db1
.Table<Album>()
.Where(a => a.AlbumID == albumID)
.FirstOrDefaultAsync();
var albumNew = new Album()
{
AlbumID = albumID,
Title = props[0].Album,
Artist = props[0].Artist,
Titles = props.Select(a => a.Title).ToList(),
TrackPaths = paths,
Length = props.Count(),
Added = now
};
var db2 = new SQLiteAsyncConnection("PlaneAudioU.db");
if (album == null)
{
await db2.InsertAsync(albumNew);
}
else
{
await db2.UpdateAsync(albumNew);
}
albumPool.Add(albumNew);
}
Debug.WriteLine("album pool. " + albumPool.Count.ToString());
if (albumPool.Count() > 0)
{
var albumToShow = (from a in albumPool
where !shownAlbums.Contains(a.AlbumID)
select a).ToList();
if (albumToShow.Count() > 0)
{
var artistRect = GetArtistRect(albumToShow[0].Artist);
albumPanel.Items.Add(artistRect);
foreach (var album in albumToShow.OrderBy(a => a.AlbumID))
{
var button = await album.GetButton();
button.Click += AlbumButton_Clicked;
albumPanel.Items.Add(button);
shownAlbums.Add(album.AlbumID);
}
}
}
}
Debug.WriteLine("Saving to db.");
var db3 = new SQLiteAsyncConnection("PlaneAudioU.db");
foreach (var oldAlbum in await db3.Table<Album>().Where(a => now > a.Added).ToListAsync())
{
var db4 = new SQLiteAsyncConnection("PlaneAudioU.db");
await db4.DeleteAsync(oldAlbum);
}
}
/// <summary>
/// Removes a cached image from the database.
/// </summary>
/// <param name="cachedImage">
/// The key for the cached image.
/// </param>
/// <returns>
/// The true if the addition of the cached image is removed; otherwise, false.
/// </returns>
internal static async Task<int> RemoveImageAsync(CachedImage cachedImage)
{
try
{
SQLiteAsyncConnection connection = new SQLiteAsyncConnection(ConnectionString);
return await connection.DeleteAsync(cachedImage);
}
catch
{
return 0;
}
}
public static async Task<int> deleteFavourite(OCDirection direction)
{
String path = ApplicationData.Current.LocalFolder.Path + "/OCTranspo.sqlite";
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(path);
String Query = "DELETE from OCDirection WHERE routeNo=" + direction.RouteNo + " AND FromStopNumber=" + direction.FromStopNumber + ";";
int result = await conn.DeleteAsync(direction);
return result;
}
private async Task DeletetaisanAsync(string name)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("moneybook.db");
// Retrieve taisan
var taisan = await conn.Table<taikhoan>().Where(x => x.Tentaikhoan == name).FirstOrDefaultAsync();
if (taisan != null)
{
// Delete record
await conn.DeleteAsync(taisan);
}
}
public void Remove(AlbumItem album)
{
if (album == null) return;
var connection = new SQLiteAsyncConnection(DbPath);
connection.DeleteAsync(album);
}
public async Task DeleteBudgetCategoryAsync(BudgetCategory category)
{
var deleted = await connection.DeleteAsync(category);
}
private async Task DeleteTaiSanAsync(int oldid)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("moneybook.db");
// Retrieve taisan
var pvtaisan = await conn.Table<taikhoan>().Where(x => x.Id == oldid).FirstOrDefaultAsync();
if (pvtaisan != null)
{
// Delete record
await conn.DeleteAsync(pvtaisan);
}
}
private async Task DeleteGhichepAsync(int oldid)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("moneybook.db");
// Retrieve taisan
var pv = await conn.Table<ghichep>().Where(x => x.Id == oldid).FirstOrDefaultAsync();
if (pv != null)
{
// Delete record
await conn.DeleteAsync(pv);
}
}
private async void DeleteUserAppBarButton_Click(object sender, RoutedEventArgs e)
{
if (users != null && users.Count > 0)
{
// get last inserted user
College user = users.Last();
// delete the row of the table
// SQLite uses the User.Id to find witch row correspond to the user instance
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("institutionFinder.db");
await conn.DeleteAsync(user);
// delete the user from the user list
users.RemoveAt(users.Count - 1);
// Refresh user list
UserLists.ItemsSource = null;
UserLists.ItemsSource = users;
}
}
public async Task<string> DeleteDeck(int deckId)
{
string result = string.Empty;
var db = new SQLite.SQLiteAsyncConnection(App.DBPath);
var existingDeck = await (db.Table<Deck>().Where(
d => d.Id == deckId)).FirstAsync();
try
{
var _cards = await db.Table<Card>().Where(c1 => c1.DeckId == existingDeck.Id).ToListAsync();
foreach (var _card in _cards)
{
int s = await db.DeleteAsync(_card);
}
int succcess = await db.DeleteAsync(existingDeck);
result = "Success";
}
catch
{
result = "This project was not removed";
}
return result;
}
public Task Remove(ArtistItem artist)
{
var connection = new SQLiteAsyncConnection(DbPath);
return connection.DeleteAsync(artist);
}
private async Task DeleteArticleAsync(string name)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(dbName);
// Retrieve Article
var article = await conn.Table<Article>().Where(x => x.Title == name).FirstOrDefaultAsync();
if (article != null)
{
// Delete record
await conn.DeleteAsync(article);
}
}
public async Task <bool> Delete <T>(T item) where T : BaseModel, new()
{
return(await connection.DeleteAsync(item) > 0);
}
public Task <int> DeleteProductAsync(Product product)
{
return(_database.DeleteAsync(product));
}
public async void DeleteDB(DB data)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("exercice");
await conn.DeleteAsync(data);
}
/// <summary>
/// Delete a record
/// </summary>
public async void Delete(string sensor)
{
SQLiteAsyncConnection connection = new SQLiteAsyncConnection(textBox.Text);
var SensorQry = await connection.Table<Sensor>().Where(x => x.Name.StartsWith(sensor)).FirstOrDefaultAsync();
if (SensorQry != null)
{
await connection.DeleteAsync(SensorQry);
}
}
private async void Button_Click_1(object sender, RoutedEventArgs e)
{
string baza = comboboxusunzbazy.SelectedValue.ToString();
string slowko = comboboxslowkodousuniecia.SelectedValue.ToString();
string[] tablica = slowko.Split(new[] {'.'});
if (baza.Equals("eFiszki"))
{
baza = "AppData";
}
var path = Windows.Storage.ApplicationData.Current.LocalFolder.Path + @"\" + baza + ".sqlite";
var db = new SQLiteAsyncConnection(path);
var maxid = 0;
List<UserDefaultDataBase> result = await db.QueryAsync<UserDefaultDataBase>("Select max(id) as Id From UserDefaultDataBase");
foreach (var item in result)
{
maxid = item.Id;
}
int indeksdousuniecia = Convert.ToInt32(tablica[0]);
var all = await db.QueryAsync<UserDefaultDataBase>("Select * From UserDefaultDataBase");
var del = await db.FindAsync<UserDefaultDataBase>(u => u.Id == indeksdousuniecia);
await db.DeleteAsync(del);
//Debug.WriteLine("maksymalny indeks: " + maxid + ", indeks do usuniecia:" + indeksdousuniecia);
//if (maxid != indeksdousuniecia)
//{
// List<UserDefaultDataBase> updateid = await db.QueryAsync<UserDefaultDataBase>("Select * From UserDefaultDataBase Where Id = ?", new object[] { maxid });
// var update = updateid.First();
// update.Id += 100;
// update.SlowkoEn = "toz to dziala";
// await db.UpdateAsync(update);
// Debug.WriteLine("Update indeksu:" + maxid + " na " + indeksdousuniecia);
// //foreach (var i in updateid)
// //{
// // Debug.WriteLine(i.Id);
// //}
// //await db.QueryAsync<UserDefaultDataBase>("Update UserDefaultDataBase set id= ? where id=?", new object[] {maxid, indeksdousuniecia });
// //foreach (var i in updateid)
// //{
// // var update = updateid.First();
// // update.Id = indeksdousuniecia;
// // await db.UpdateAsync(update);
// //}
//}
comboboxslowkodousuniecia.Items.Clear();
setcomboslowko();
}
/// <summary>
/// Löscht einen Trainingsplan aus der lokalen DB
/// </summary>
/// <param name="data">Schedule</param>
/// <param name="path">SQLite Connection String</param>
/// <returns>1 -> Delete</returns>
/// <returns>-1 -> Exception</returns>
public async Task<int> deleteSchedule(Schedule data)
{
try
{
var db = new SQLiteAsyncConnection(path);
await db.DeleteAsync(data);
return 1;
}
catch (SQLiteException ex)
{
Console.WriteLine(ex.Message);
return -1;
}
}
public async Task <int> DeleteAsync <T>(T item)
{
return(await _connection.DeleteAsync(item));
}
public Task Remove(MapModel map)
{
SQLiteAsyncConnection connection = new SQLiteAsyncConnection(SQLiteConfiguration.ConnectionString);
_dataSources.Remove(map);
return connection.DeleteAsync(map);
}
public Task Remove(TracklistItem track)
{
var connection = new SQLiteAsyncConnection(DbPath);
return connection.DeleteAsync(track);
}
public Task RemoveLocation(MapLocationModel mapLocation)
{
SQLiteAsyncConnection connection = new SQLiteAsyncConnection(SQLiteConfiguration.ConnectionString);
_locations.Remove(mapLocation);
connection.ExecuteAsync("DELETE FROM MapLocationFolders WHERE MapLocationId = ?", mapLocation.ID);
return connection.DeleteAsync(mapLocation);
}
public async Task<string> DeleteCard(int cardId)
{
string result = string.Empty;
var db = new SQLite.SQLiteAsyncConnection(App.DBPath);
var existingCard = await (db.Table<Card>().Where(
c => c.Id == cardId)).FirstAsync();
if (await db.DeleteAsync(existingCard) > 0)
{
result = "Success";
}
else
{
result = "This project was not removed";
}
return result;
}
private async void DelReq_Click(object sender, RoutedEventArgs e)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("appData.db");
await conn.CreateTableAsync<Request>();
var toDelete = await conn.Table<Request>().Where(x => x.id == clickedItem.id).FirstOrDefaultAsync();
if (toDelete == null) throw new NullReferenceException();
await conn.DeleteAsync(clickedItem);
var msg = new MessageDialog("Request Removed");
await msg.ShowAsync();
this.Frame.GoBack();
}
