public Task Update(MapModel map)
{
SQLiteAsyncConnection connection = new SQLiteAsyncConnection(SQLiteConfiguration.ConnectionString);
_dataSources.Remove(_dataSources.First(source => source.ID.Equals(map.ID)));
_dataSources.Add(map);
return connection.UpdateAsync(map);
}
public async Task <bool> UpdateDBAsync(FreeDiscItemDownload freeDiscDownloader)
{
if (freeDiscDownloader == null)
{
#if DEBUG
Debug.Write("UpdateDBAsync: freeDiscDownloader == null");
#endif
return(false);
}
#if DEBUG
Debug.Write("UpdateDB: ID" + freeDiscDownloader.DBID + " Title: " + freeDiscDownloader?.Title + " Status: " + freeDiscDownloader?.ItemStatus.ToString());
#endif
if (freeDiscDownloader.DBID == 0)
{
#if DEBUG
Debug.Write("UpdateDBAsync: freeDiscDownloader.DBID == 0 !");
#endif
return(false);
}
try
{
var conn = new SQLite.SQLiteAsyncConnection(App.AppSetting.DBDownloadPath);
await conn.CreateTableAsync <FreeDiscItemDownload>();
await conn.UpdateAsync(freeDiscDownloader);
}
catch (Exception e)
{
#if DEBUG
Debug.Write("UpdateDBAsync: Update error !: " + e.ToString());
#endif
return(false);
}
return(true);
}
private static async Task SetValueAsyncInternal(string name, string value, SQLiteAsyncConnection conn)
{
// if we don't have a connection, assume the system one...
if(conn == null)
conn = StreetFooRuntime.GetSystemDatabase();
// load an existing value...
var setting = await conn.Table<SettingItem>().Where(v => v.Name == name).FirstOrDefaultAsync();
if (setting != null)
{
// change and update...
setting.Value = value;
await conn.UpdateAsync(setting);
}
else
{
setting = new SettingItem()
{
Name = name,
Value = value
};
// save...
await conn.InsertAsync(setting);
}
}
public async Task<int> AddVisit(Visit visit) {
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(this.dbPath);
if (visit.ID > 0) {
return await conn.UpdateAsync(visit);
}
return await conn.InsertAsync(visit);
}
private async void btnOK_Click(object sender, RoutedEventArgs e)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(Path.Combine(ApplicationData.Current.LocalFolder.Path, "people.db"), true);
//string[] per = new string[10];
var per=App.ViewModel.Items[index];
per.LineFive = watermarkTextBox.Text;
per.Linesix = watermarkTextBox1.Text;
per.Lineseven = watermarkTextBox2.Text;
per.Lineeight = watermarkTextBox3.Text;
Person person = new Person()
{
ID=per.Lineone,
DoctorName=per.Linetwo,
Date=per.Linethree,
Time=per.LineFour,
Temperature=per.LineFive,
Bp=per.Linesix,
symptoms=per.Lineseven,
description=per.Lineeight
};
await conn.UpdateAsync(person);
NavigationService.GoBack();
}
public static async Task<int> updateSettings(OCSettings settings)
{
settings.id = 1;
String path = ApplicationData.Current.LocalFolder.Path + "/OCTranspo.sqlite";
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(path);
int result = await conn.UpdateAsync(settings);
return result;
}
private async void Button_Click_5(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)
{
item.Work = "产品经理";
await conn.UpdateAsync(item);
}
}
async Task RunUpdateTest()
{
var db = new SQLiteAsyncConnection(DatabasePath);
var person = await db.GetAsync<Person>(f => f.FullName.EndsWith("8"));
person.OtherField = "ABCD";
await db.UpdateAsync(person);
var updatedPerson = await db.GetAsync<Person>(f => f.FullName.EndsWith("8"));
var message = updatedPerson.OtherField == "ABCD"
? "Completed!"
: "Did not update person!";
await dispatcher.RunIdleAsync(a => { UpdateResult = message; });
}
public async static Task InsertMenu(Menu menu)
{
SQLiteAsyncConnection sqlConnection = new SQLiteAsyncConnection(DbHelper.DB_PATH);
var collectionItem = await sqlConnection.Table<Menu>().Where(x => x.MenuId == menu.MenuId && x.CounterId == menu.CounterId).FirstOrDefaultAsync();
if (collectionItem != null)
{
if (collectionItem.Version < menu.Version)
{
await sqlConnection.UpdateAsync(menu);
}
}
else
{
System.Diagnostics.Debug.WriteLine("Menu Inserted: "+await sqlConnection.InsertAsync(menu));
}
}
public async Task<string> InsertUpdateDataAsync (UserVideo data)
{
try
{
var db = new SQLiteAsyncConnection (_path);
if (await db.InsertAsync (data) != 0)
await db.UpdateAsync (data);
return "Single data file inserted or updated";
}
catch (SQLiteException ex)
{
Log.Error (TAG, ex.Message);
return string.Empty;
}
}
public async static Task InsertCounter(Counter counter)
{
SQLiteAsyncConnection sqlConnection = new SQLiteAsyncConnection(DbHelper.DB_PATH);
var collectionItem = await sqlConnection.Table<Counter>().Where(x => x.Id == counter.Id).FirstOrDefaultAsync();
if (collectionItem != null)
{
if (collectionItem.MenuVersion != counter.MenuVersion)
{
await sqlConnection.UpdateAsync(counter);
}
}
else
{
await sqlConnection.InsertAsync(counter);
}
await CounterSubscribed();
}
private async Task<string> insertUpdateData(Person data, string path)
{
try
{
var db = new SQLiteAsyncConnection(path);
if (await db.InsertAsync(data) != 0)
await db.UpdateAsync(data);
return "Single data file inserted or updated";
}
catch (SQLiteException ex)
{
return ex.Message;
}
}
private async void AppBarButton_Click(object sender, RoutedEventArgs e)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("appData.db");
await conn.CreateTableAsync<User>();
String name = NameBox.Text;
String email = MailBox.Text;
var user = await conn.Table<User>().Where(x => x.Name == name && x.Email == email).FirstOrDefaultAsync();
if (user == null)
{
var msg = new MessageDialog("Couldn't Find User");
await msg.ShowAsync();
}
else
{
if (currUser == user)
{
var msg = new MessageDialog("I can't allow you to friend yourself! I'll be your friend :-)");
await msg.ShowAsync();
}
if (currUser.friendsList.Contains(user.Username))
{
var msg = new MessageDialog("Already your friend!");
await msg.ShowAsync();
}
else
{
currUser.friendsList += (user.Username + ",");
user.friendsList += (currUser.Username + ",");
await conn.UpdateAsync(currUser);
await conn.UpdateAsync(user);
var msg = new MessageDialog("User added!");
await msg.ShowAsync();
NameBox.Text = "";
MailBox.Text = "";
}
}
}
private async void sifirla_Click(object sender, RoutedEventArgs e)
{
// SayfaID'sinden dualistesinde istenen duayı bul, kacKezOkundu değerini sıfırla
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("duaDB.db");
var sayac = await conn.Table<Dualar>().Where(x => x.Id == sayfaID).FirstOrDefaultAsync();
if (sayac != null)
{
sayac.kacKezOkundu = 0;
await conn.UpdateAsync(sayac);
}
var allusers = await conn.QueryAsync<Dualar>("SELECT kacKezOkundu FROM DuaList WHERE Id = ?",sayfaID);
foreach (var user in allusers)
{
//txtDuaSayaci.Text = user.kacKezOkundu.ToString();
txtDuaSayisi.Text = user.kacKezOkundu.ToString();
}
}
public Task Update(VideoItem video)
{
var connection = new SQLiteAsyncConnection(DbPath);
return connection.UpdateAsync(video);
}
public Task Update(MusicLibraryViewModel.TrackItem track)
{
var connection = new SQLiteAsyncConnection(_dbPath);
return connection.UpdateAsync(track);
}
public Task <int> UpdateStationAsync(Entities.Station Station)
{
return(Database.UpdateAsync(Station));
}
public Task <int> UpdateEmergencyAsync(Entities.Emergency Emergency)
{
return(Database.UpdateAsync(Emergency));
}
public Task Update(TrackItem track)
{
var connection = new SQLiteAsyncConnection(DbPath);
return connection.UpdateAsync(track);
}
public Task Update(MusicLibraryViewModel.AlbumItem album)
{
var connection = new SQLiteAsyncConnection(_dbPath);
return connection.UpdateAsync(album);
}
public async void UpdateDB(DB data)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("exercice");
await conn.UpdateAsync(data);
}
private async Task UpdateArticleTitleAsync(string oldTitle, string newTitle)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(dbName);
// Retrieve Article
var article = await conn.Table<Article>()
.Where(x => x.Title == oldTitle).FirstOrDefaultAsync();
if (article != null)
{
// Modify Article
article.Title = newTitle;
// Update record
await conn.UpdateAsync(article);
}
}
public async Task<string> SaveCard(CardViewModel card)
{
string result = String.Empty;
var db = new SQLiteAsyncConnection(App.DBPath);
try
{
var existingCard = await (db.Table<Card>().Where(c1 => c1.Id == card.Id)).FirstOrDefaultAsync();
if (existingCard != null)
{
existingCard.FrontContent = card.FrontContent;
existingCard.BackContent = card.BackContent;
int success = await db.UpdateAsync(existingCard);
}
else
{
var _card = new Card();
_card.FrontContent = card.FrontContent;
_card.BackContent = card.BackContent;
_card.DeckId = card.DeckId;
int success = await db.InsertAsync(_card);
}
result = "Success";
}
catch
{
result = "this card was not saved";
}
return result;
}
public Task <int> UpdateProductAsync(Product product)
{
return(_database.UpdateAsync(product));
}
public Task UpdateLocation(MapLocationModel mapLocation)
{
SQLiteAsyncConnection connection = new SQLiteAsyncConnection(SQLiteConfiguration.ConnectionString);
_locations.Remove(_locations.First(location => location.ID == mapLocation.ID));
_locations.Add(mapLocation);
return connection.UpdateAsync(mapLocation);
}
private async void arttır_Click(object sender, RoutedEventArgs e)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("duaDB.db");
var sayac = await conn.Table<Dualar>().Where(x => x.Id == sayfaID).FirstOrDefaultAsync();
if (sayac != null)
{
sayac.kacKezOkundu += 1;
await conn.UpdateAsync(sayac);
}
var allusers = await conn.QueryAsync<Dualar>("SELECT kacKezOkundu FROM DuaList WHERE Id = ?" , sayfaID);
foreach (var user in allusers)
{
//txtDuaSayaci.Text = user.kacKezOkundu.ToString();
txtDuaSayisi.Text = user.kacKezOkundu.ToString();
//Eğer titreşim modu aktifse hedefe ulaşıldığında telefon titresin
if (Int32.Parse(txtDuaSayisi.Text) == Int32.Parse(sayac.kacKezOkunmali.ToString()) && ToggleTitresim.IsOn == true)
{
VibrationDevice testVibration = VibrationDevice.GetDefault();
testVibration.Vibrate(TimeSpan.FromSeconds(2));
}
}
}
private async void RemoveFriend_Click(object sender, RoutedEventArgs e)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("appData.db");
await conn.CreateTableAsync<User>();
String[] frList1 = currUser.friendsList.Split(',');
String[] frList2 = clickedUser.friendsList.Split(',');
string newList1 = "";
string newList2 = "";
foreach (string s in frList1) if (!s.Equals(clickedUser.Username)) newList1 += (s + ",");
foreach (string s in frList2) if (!s.Equals(currUser.Username)) newList2 += (s + ",");
currUser.friendsList = newList1;
clickedUser.friendsList = newList2;
await conn.UpdateAsync(currUser);
await conn.UpdateAsync(clickedUser);
var msg = new MessageDialog("User removed!");
await msg.ShowAsync();
this.Frame.GoBack();
}
public async Task<string> SaveDeck(DeckViewModel deck)
{
string result = String.Empty;
var db = new SQLiteAsyncConnection(App.DBPath);
try
{
var existingDeck = await (db.Table<Deck>().Where(d1 => d1.Id == deck.Id)).FirstOrDefaultAsync();
if (existingDeck != null)
{
existingDeck.Title = deck.Title;
existingDeck.Author = deck.Author;
existingDeck.Description = deck.Description;
existingDeck.Subject = deck.Subject;
int success = await db.UpdateAsync(existingDeck);
}
else
{
var _deck = new Deck();
_deck.Title = deck.Title;
_deck.Author = deck.Author;
_deck.Description = deck.Description;
_deck.Subject = deck.Subject;
int success = await db.InsertAsync(_deck);
}
result = "Success";
}
catch
{
result = "this deck was not saved";
}
return result;
}
public async Task UpdateBankAccountFundsTransferAsync(BankAccountFundsTransfer fundsTransfer)
{
var updated = await connection.UpdateAsync(fundsTransfer);
}
public Task Update(ArtistItem artist)
{
var connection = new SQLiteAsyncConnection(DbPath);
return connection.UpdateAsync(artist);
}
public Task Update(MusicLibraryViewModel.ArtistItem artist)
{
var connection = new SQLiteAsyncConnection(_dbPath);
return connection.UpdateAsync(artist);
}
private async void sifirla_Click(object sender, RoutedEventArgs e)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("duaDB.db");
var sayac = await conn.Table<Zikirmatik>().Where(x => x.Id == 1).FirstOrDefaultAsync();
if (sayac != null)
{
sayac.Counter =0;
await conn.UpdateAsync(sayac);
}
var allusers = await conn.QueryAsync<Zikirmatik>("SELECT Counter FROM ZikirmatikSayac WHERE Id = 1");
foreach (var user in allusers)
{
Sayac.Text = user.Counter.ToString();
}
}
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);
}
}
private async Task UpdatetaisanNameAsync(string oldName, string newName)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection("moneybook.db");
// Retrieve taisan
var taisan = await conn.Table<taikhoan>().Where(x => x.Loaitiente == oldName).FirstOrDefaultAsync();
if (taisan != null)
{
// Modify taisan
taisan.Tentaikhoan = newName;
// Update record
await conn.UpdateAsync(taisan);
}
}
public Task <int> UpdateUserInfoAsync(Entities.UserInfo userInfo)
{
return(Database.UpdateAsync(userInfo));
}
/// <summary>
/// Update some records
/// </summary>
public async void Update(string sensor)
{
SQLiteAsyncConnection connection = new SQLiteAsyncConnection(textBox.Text);
var SensorQry = await connection.Table<Sensor>().Where(x => x.Name.StartsWith(sensor)).FirstOrDefaultAsync();
if (SensorQry != null)
{
SensorQry.dateTime = DateTime.Now;
SensorQry.Value = GetRandomValue(SensorQry.Name);
await connection.UpdateAsync(SensorQry);
}
}
