public async Task<bool> Save()
{
var db = new SQLite.SQLiteAsyncConnection(app.DBPath);
int success = 0;
try
{
Account existingAccount = await (db.Table<Account>().Where(
a => a.Id == Id)).FirstOrDefaultAsync();
if (existingAccount != null)
{
existingAccount.Name = Name;
existingAccount.Description = Description;
existingAccount.CurrentBalance = CurrentBalance;
success = await db.UpdateAsync(existingAccount);
}
else
{
success = await db.InsertAsync(new Account()
{
Name = this.Name,
Description = this.Name,
Type = this.Type,
CurrentBalance = this.CurrentBalance,
DateCreated = DateTime.Now
});
}
}
catch
{
success = 0;
}
return success != 0;
}
/// <summary>
/// Opens the database connection asynchronously
/// </summary>
private void ConnectAsync()
{
// If we don't get a connection String, use the default one
if (String.IsNullOrEmpty(this.connection_String))
{
this.connection_String = DEFAULT_DATABASE;
}
if (!String.IsNullOrEmpty(this.connection_String))
{
try
{
if (!File.Exists(DEFAULT_DATABASE))
{
CreateDatabase();
}
m_asyncdbConnection = new SQLite.SQLiteAsyncConnection(String.Format("Data Source={0};Version=3;", this.connection_String));
}
catch (Exception ex)
{
throw ex;
}
finally {
is_connected = false;
}
}
else
{
is_connected = false;
}
}
public async Task<List<ParentViewModel>> GetParentsAsync(Guid user)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
List<ParentViewModel> parents = new List<ParentViewModel>();
List<Item> result = await context.Table<Item>().Where(p => p.Parent == 0).ToListAsync();
foreach (Item item in result)
{
parents.Add(new ParentViewModel()
{
Title = item.Title,
Description = item.Description,
StartDate = Convert.ToDateTime(item.StartDate),
Category = (Int16)Generic.UI.Logic.Enumerations.Category.Trips,
Cost = item.Cost,
Identifier = item.Identifier,
Latitude = item.Latitude,
Longitude = item.Longitude,
LocalPathImage = item.Image == null ? loader.GetString("DefaultParentImage") : item.Image,
User = new Guid(item.User)
});
}
return parents;
}
/**
* This method is called when the button to valid the club list is clicked
*/
private async void onValidClubSelection(object sender, EventArgs e)
{
Btn.IsEnabled = false;
Btn.Text = "En cours...";
Btn.TextColor = Color.White;
SQLite.SQLiteAsyncConnection connection = DependencyService.Get <ISQLiteDb>().GetConnectionAsync();
await connection.CreateTableAsync <Club>();
List <Club> clubselected = new List <Club>();
bool atLeastOneSelected = false;
foreach (Club c in listviewclub.ItemsSource) //updates each club 'selected' attribute in the database
{
if (c.selected)
{
atLeastOneSelected = true;
}
await SQLiteNetExtensionsAsync.Extensions.WriteOperations.UpdateWithChildrenAsync(connection, c);
}
if (!atLeastOneSelected)//checks if at least one club is selected
{
await DisplayAlert("Aucun club selectionné", "Vous devez selectionner au moins un club", "ok");
}
else
{
await Navigation.PopAsync();
}
Btn.IsEnabled = true;
Btn.Text = "Valider";
}
public ContactsDetailPage(Contact contact)
{
InitializeComponent();
if (contact == null)
{
throw new ArgumentNullException(nameof(contact));
}
_connection = DependencyService.Get <ISQLiteDb>().GetConnection();
BindingContext = new Contact
{
Id = contact.Id,
FirstName = contact.FirstName,
Surname = contact.Surname,
PhoneNumber = contact.PhoneNumber,
Email = contact.Email,
IsBlocked = contact.IsBlocked
};
if (contact.Id != 0)
{
Title = "Update contact";
}
}
public async Task SimpleReadThroughCache()
{
var path = System.IO.Path.GetTempFileName();
var conn = new SQLite.SQLiteAsyncConnection(path);
var db = new TestDatabase(conn);
await db.Reset();
var sqliteThingCache = new SqliteClassCache <Parent, long>(db);
await sqliteThingCache.Setup();
var cache1 = new ModelCache(aClassCache: new Dictionary <Type, IModelClassCache>()
{
{ typeof(Parent), sqliteThingCache }
});
// read from origin
var cascade = new CascadeDataLayer(origin, new ICascadeCache[] { cache1 }, new CascadeConfig()
{
DefaultFreshnessSeconds = 1
});
var thing1 = await cascade.Get <Parent>(5);
Assert.AreEqual(5, thing1 !.id);
Assert.AreEqual(cascade.NowMs, thing1.updatedAtMs);
origin.IncNowMs();
var thing2 = await cascade.Get <Parent>(5, freshnessSeconds : 2);
Assert.AreEqual(thing1.updatedAtMs, thing2 !.updatedAtMs);
var thing3 = await cascade.Get <Parent>(5, freshnessSeconds : 0);
Assert.AreEqual(origin.NowMs, thing3 !.updatedAtMs);
}
public async Task<List<TripViewModel>> GetTripsAsync(Guid traveler)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
List<TripViewModel> trips = new List<TripViewModel>();
//trips have the parent null, items have a trip as parent
List<Item> result = await context.Table<Item>().Where(p => p.IsSuggestion == false && p.Parent == 0).ToListAsync();
foreach (Item item in result)
{
trips.Add(new TripViewModel()
{
Title = item.Title,
Description = item.Description,
EndDate = Convert.ToDateTime(item.EndDate),
StartDate = Convert.ToDateTime(item.StartDate),
Category = (Int16)Sugges.UI.Logic.Enumerations.Category.Trips,
Cost = item.Cost,
Identifier = item.Identifier,
Latitude = item.Latitude,
Longitude = item.Longitude,
RemotePathImage = item.Image == null ? "/Assets/Trip.png" : item.Image,
LocalPathImage = item.Image == null ? "/Assets/Trip.png" : item.Image,
Traveler = new Guid(item.Traveler)
});
}
return trips;
}
public async Task <bool> SaveToDBAsync(FreeDiscItemDownload freeDiscDownloader)
{
if (freeDiscDownloader == null)
{
#if DEBUG
Debug.Write("SaveToDBAsync: freeDiscDownloader == null");
#endif
return(false);
}
Debug.Write("SaveToDB: ID" + freeDiscDownloader.DBID + " Title: " + freeDiscDownloader?.Title + " Status: " + freeDiscDownloader?.ItemStatus.ToString());
try
{
var conn = new SQLite.SQLiteAsyncConnection(App.AppSetting.DBDownloadPath);
await conn.CreateTableAsync <FreeDiscItemDownload>();
await conn.InsertAsync(freeDiscDownloader);
}
catch (Exception e)
{
Debug.Write("SaveToDB: Save error !");
return(false);
}
Debug.Write("SaveToDB: Result ID" + freeDiscDownloader?.DBID ?? "NULL");
return(true);
}
public async Task <bool> DeleteFromDBAsync(FreeDiscItemDownload freeDiscDownloader)
{
if (freeDiscDownloader == null)
{
#if DEBUG
Debug.Write("DeleteFromDBAsync: freeDiscDownloader == null");
#endif
return(false);
}
Debug.Write("DeleteFromDB: ID" + freeDiscDownloader.DBID + " Title: " + freeDiscDownloader?.Title + " Status: " + freeDiscDownloader?.ItemStatus.ToString());
if (freeDiscDownloader.DBID == 0)
{
Debug.Write("DeleteFromDB: freeDiscDownloader.DBID == 0 !");
return(false);
}
try
{
var conn = new SQLite.SQLiteAsyncConnection(App.AppSetting.DBDownloadPath);
await conn.CreateTableAsync <FreeDiscItemDownload>();
await conn.DeleteAsync(freeDiscDownloader);
}
catch (Exception e)
{
Debug.Write("DeleteFromDB: Delete error !");
return(false);
}
return(true);
}
public SQLite.SQLiteAsyncConnection GetConnection()
{
var oldSqliteFilename = "GenconMobileSQLite.db3";
var sqliteFilename = "GenconMobile4SQLite.db3";
//string documentsPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal); // Documents folder
//string libraryPath = Path.Combine(documentsPath, "..", "Library"); // Library folder
//var path = Path.Combine(libraryPath, sqliteFilename);
var libraryPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "..", "Library");
var cachePath = Path.Combine(libraryPath, "Caches");
var finalPath = Path.Combine(cachePath, sqliteFilename);
var oldFinalPath = Path.Combine(cachePath, oldSqliteFilename);
if (File.Exists(oldFinalPath))
{
File.Delete(oldFinalPath);
}
// This is where we copy in the prepopulated database
//Console.WriteLine(path);
//if (!File.Exists(path))
//{
// File.Copy(sqliteFilename, path);
//}
var conn = new SQLite.SQLiteAsyncConnection(finalPath);
// Return the database connection
return(conn);
}
public async Task CreateReadUpdateDeleteTest()
{
var path = System.IO.Path.GetTempFileName();
var conn = new SQLite.SQLiteAsyncConnection(path);
var db = new TestDatabase(conn);
await db.Reset();
var thing1 = new Parent()
{
colour = "red"
};
thing1 = await db.Create <Parent>(thing1);
Assert.Greater(thing1.id, 0);
var loaded = await db.Get <Parent>(thing1.id);
Assert.AreEqual(thing1.id, loaded.id);
thing1.colour = "green";
await db.Update(thing1);
var thing2 = await db.Get <Parent>(thing1.id);
Assert.AreEqual(thing1.colour, thing2.colour);
await db.Delete(thing2);
var thing3 = await db.Get <Parent>(thing2.id);
Assert.IsNull(thing3);
}
/// <summary>
/// Загрузка окна, инициализация контроллеров, загрузка в listview данных и сброс управления.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void MetroWindow_Loaded(object sender, RoutedEventArgs e)
{
Firts_Start = true;
DBConnection oDBConnection = new DBConnection();
await oDBConnection.InitializeDatabase();
oOrdersRepository = new OrdersRepository(oDBConnection);
oClientsRepository = new ClientsRepository(oDBConnection);
oCardsRepository = new CardsRepository(oDBConnection);
oBouquetsRepository = new BouquetsRepository(oDBConnection);
oContentsRepository = new ContentsRepository(oDBConnection);
oCartsRepository = new CartsRepository(oDBConnection);
oAccessoriesRepository = new AccessoriesRepository(oDBConnection);
oFlowersRepository = new FlowersRepository(oDBConnection);
oSpecialDealsRepository = new SpecialDealsRepository(oDBConnection);
oDiscountRepository = new DiscountsRepository(oDBConnection);
conn = oDBConnection.GetAsyncConnection();
lCart_Bouquet = new List <Cart_Bouquet>();
await Update_ListView_Clients();
await Update_ListView_Bouquets();
Clear_Control_All();
}
public async Task FileConnectionTestAsync()
{
var guid = System.Guid.NewGuid().ToString();
string dbPath = $@"C:\temp\{guid}.db";
if (System.IO.File.Exists(dbPath))
{
System.IO.File.Delete(dbPath);
}
_db = new SQLite.SQLiteAsyncConnection(dbPath);
await _db.CreateTableAsync <DummyTable>().ConfigureAwait(false);
bool exists = System.IO.File.Exists(dbPath);
Assert.AreEqual(true, exists, "Make sure VS is in Admin mode");
await _db.CloseAsync();
if (File.Exists(dbPath))
{
File.Delete(dbPath);
}
if (File.Exists(dbPath))
{
Assert.Fail($"File '{dbPath}' was not deleted");
}
}
private DatabaseOperations()
{
_articleDbLock = new object();
_cateogryDbLock = new object();
_slideDbLock = new object();
_dbConnection = new SQLite.SQLiteAsyncConnection(Path.Combine(ApplicationData.Current.LocalFolder.Path, "articlesDb.sqlite"));
}
/**
* Gets all the shots in the database
*/
public async static Task <List <Shot> > getShots()
{
SQLite.SQLiteAsyncConnection connection = DependencyService.Get <ISQLiteDb>().GetConnectionAsync();
await connection.CreateTableAsync <Shot>();
List <Shot> allShots = await SQLiteNetExtensionsAsync.Extensions.ReadOperations.GetAllWithChildrenAsync <Shot>(connection);
return(allShots);
}
public SQLite.SQLiteAsyncConnection GetConnection()
{
var dbName = "Rescue.db3";
var dbPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.ApplicationData);
var path = Path.Combine(dbPath, dbName);
var conn = new SQLite.SQLiteAsyncConnection(path);
return(conn);
}
/**
* Gets all the golf courses from the database
*/
public async static Task <List <GolfCourse> > getGolfCourses()
{
SQLite.SQLiteAsyncConnection connection = DependencyService.Get <ISQLiteDb>().GetConnectionAsync();
await connection.CreateTableAsync <GolfCourse>();
List <GolfCourse> golfCourses = await SQLiteNetExtensionsAsync.Extensions.ReadOperations.GetAllWithChildrenAsync <GolfCourse>(connection);
return(golfCourses);
}
/**
* Saves the given game
* scoreOfThisPartie : the game statistics
*/
public async static Task saveGameForStats(ScorePartie scoreOfThisPartie)
{
SQLite.SQLiteAsyncConnection connection = DependencyService.Get <ISQLiteDb>().GetConnectionAsync();
await connection.CreateTableAsync <ScoreHole>();
await connection.CreateTableAsync <ScorePartie>();
await SQLiteNetExtensionsAsync.Extensions.WriteOperations.InsertOrReplaceWithChildrenAsync(connection, scoreOfThisPartie, false);
}
/**
* Gets all the ScoreHole from the database
*/
public async static Task <List <ScoreHole> > getScoreHoles()
{
SQLite.SQLiteAsyncConnection connection = DependencyService.Get <ISQLiteDb>().GetConnectionAsync();
await connection.CreateTableAsync <ScoreHole>();
List <ScoreHole> allScoreHoles = await SQLiteNetExtensionsAsync.Extensions.ReadOperations.GetAllWithChildrenAsync <ScoreHole>(connection, recursive : true);
return(allScoreHoles);
}
public TodoDatabase()
{
var location = "tododb.db3";
location = System.IO.Path.Combine(Root, location);
Connection = new SQLite.SQLiteAsyncConnection(location);
Connection.CreateTableAsync <ToDoItem>();
}
public async void CreateDatabase()
{
try
{
SQLite.SQLiteAsyncConnection connection = new SQLite.SQLiteAsyncConnection(DEFAULT_DATABASE);
} catch (Exception ex)
{
throw ex;
}
}
public async Task QueryWithSqliteCache()
{
var path = System.IO.Path.GetTempFileName();
var conn = new SQLite.SQLiteAsyncConnection(path);
var db = new TestDatabase(conn);
await db.Reset();
Child[] allGadgets = new[] {
new Child()
{
id = "aaa", power = 1, weight = 100
},
new Child()
{
id = "bbb", power = 2, weight = 123
},
new Child()
{
id = "ccc", power = 3, weight = 456
},
new Child()
{
id = "ddd", power = 4, weight = 100
}
};
foreach (var t in allGadgets)
{
await gadgetOrigin.Store(t.id, t);
}
var memoryGadgetCache = new ModelClassCache <Child, string>();
var memoryCache = new ModelCache(aClassCache: new Dictionary <Type, IModelClassCache>()
{
{ typeof(Child), memoryGadgetCache }
});
var sqliteGadgetCache = new SqliteClassCache <Child, string>(db);
await sqliteGadgetCache.Setup();
var sqliteCache = new ModelCache(aClassCache: new Dictionary <Type, IModelClassCache>()
{
{ typeof(Child), sqliteGadgetCache }
});
var cascade = new CascadeDataLayer(origin, new ICascadeCache[] { memoryCache, sqliteCache }, new CascadeConfig());
var gadgets100 = await cascade.Query <Child>("gadgets100", new JsonObject {
["weight"] = 100
});
var gadgets100Ids = gadgets100.Select(t => t.id).ToImmutableArray();
Assert.That(gadgets100Ids, Is.EqualTo(new string[] { "aaa", "ddd" }));
}
private async Task Initialize_Database()
{
DBConnection oDBConnection = new DBConnection();
await oDBConnection.InitializeDatabase();
oOrdersRepository = new OrdersRepository(oDBConnection);
oCartsRepository = new CartsRepository(oDBConnection);
oBouquetsRepository = new BouquetsRepository(oDBConnection);
conn = oDBConnection.GetAsyncConnection();
}
public SQLite.SQLiteAsyncConnection GetConnection()
{
SQLitePCL.Batteries.Init();
var sqliteFilename = "TodoSQLite.db3";
string documentsPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal); // Documents folder
var path = Path.Combine(documentsPath, sqliteFilename);
// Create the connection
var conn = new SQLite.SQLiteAsyncConnection(path);
// Return the database connection
return(conn);
}
public SQLite.SQLiteAsyncConnection GetConnection()
{
var sqliteFilename = "TodoSQLite.db3";
string documentsPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal); // Documents folder
string libraryPath = Path.Combine(documentsPath, "..", "Library"); // Library folder
var path = Path.Combine(libraryPath, sqliteFilename);
// Create the connection
var conn = new SQLite.SQLiteAsyncConnection(path);
// Return the database connection
return(conn);
}
public RegisterPage()
{
InitializeComponent();
_regions = GetRegions();
foreach (var region in _regions)
{
regionPicker.Items.Add(region.Name);
}
_connection = DependencyService.Get <ISQLiteDb>().GetConnection(); //returns the connection to our SQLite database
}
public async Task InitializeAsync()
{
var localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
var loader = new Windows.ApplicationModel.Resources.ResourceLoader();
connectionString = loader.GetString("DataBasePath");
if (!await DoesFileExistAsync(loader.GetString("DataBasePath")))
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
await context.CreateTableAsync<Sugges.UI.Logic.DataModel.Item>();
}
}
public PortfolioData(string dbPath)
{
try
{
conn = new SQLite.SQLiteAsyncConnection(dbPath);
// conn.DropTableAsync<Portfolio>().Wait();
conn.CreateTableAsync <Portfolio>().Wait();
}
catch (Exception e)
{
StatusMessage = string.Format(e.Message);
}
}
private async void Window_Loaded_Reg(object sender, RoutedEventArgs e)
{
DBConnection oDBConnection = new DBConnection();
await oDBConnection.InitializeDatabase();
oClientsRepository = new ClientsRepository(oDBConnection);
oCardsRepository = new CardsRepository(oDBConnection);
conn = oDBConnection.GetAsyncConnection();
await Update_ListView();
}
public async Task <List <News> > GetNews()
{
List <News> ListItems = new List <News>();
SQLite.SQLiteAsyncConnection connection = DataManager.Instance.SqliteDatabase;
List <News> news = await connection.Table <News>().ToListAsync();
foreach (News item in news)
{
ListItems.Add(item);
}
return(await Task.FromResult <List <News> >(ListItems));
}
/// <summary>
/// Инициализация переменных при загрузке формы
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void MetroWindow_Loaded(object sender, RoutedEventArgs e)
{
DBConnection oDBConnection = new DBConnection();
await oDBConnection.InitializeDatabase();
oBouquetsRepository = new BouquetsRepository(oDBConnection);
oSpecialDealsRepository = new SpecialDealsRepository(oDBConnection);
conn = oDBConnection.GetAsyncConnection();
await Update_ListView_Bouquets();
await Update_ListView_SpecialDeals();
Clear_Control();
}
private async void LoadDatabase()
{
var installPath = Package.Current.InstalledLocation.Path;
string dbPath = Path.Combine(installPath, _packageDbPath);
try
{
await StorageFile.GetFileFromPathAsync(dbPath);
Connection = new SQLite.SQLiteAsyncConnection(dbPath);
DBLoaded.Set();
}
catch (FileNotFoundException)
{
Application.Current.Terminate();
}
}
/// <summary>
/// Инициализация переменных при загрузке формы
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void MetroWindow_Loaded(object sender, RoutedEventArgs e)
{
DBConnection oDBConnection = new DBConnection();
await oDBConnection.InitializeDatabase();
oBouquetsRepository = new BouquetsRepository(oDBConnection);
oContentsRepository = new ContentsRepository(oDBConnection);
oAccessoriesRepository = new AccessoriesRepository(oDBConnection);
oFlowersRepository = new FlowersRepository(oDBConnection);
conn = oDBConnection.GetAsyncConnection();
await Update_ListView_Bouquets();
Clear_Control_Bouquet();
}
Clients_Orders oClients_Orders; // Выделенные в списках объекты
//Carts_Bouquets oCarts_Bouquets; //
/// <summary>
/// Загрузка окна, инициализация контроллеров, загрузка в listview данных и сброс управления.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void MetroWindow_Loaded(object sender, RoutedEventArgs e)
{
DBConnection oDBConnection = new DBConnection();
await oDBConnection.InitializeDatabase();
oClientsRepository = new ClientsRepository(oDBConnection);
oOrdersRepository = new OrdersRepository(oDBConnection);
oCartsRepository = new CartsRepository(oDBConnection);
oBouquetsRepository = new BouquetsRepository(oDBConnection);
oCardsRepository = new CardsRepository(oDBConnection);
oPaymentsRepository = new PaymentsRepository(oDBConnection);
conn = oDBConnection.GetAsyncConnection();
await Update_ListView_Orders();
Clear_Control();
}
public async Task<int> SaveParentAsync(ParentViewModel trip)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
Item newItem = new Item()
{
Identifier = trip.Identifier,
Title = trip.Title,
Description = trip.Description,
Cost = trip.Cost,
StartDate = trip.StartDate,
Latitude = trip.Latitude,
Longitude = trip.Longitude,
User = trip.User.ToString(),
Image = trip.LocalPathImage
};
await context.InsertAsync(newItem);
return newItem.Identifier;
}
private async Task removeOldMessage(OldMessageSettings settings)
{
var db = new SQLite.SQLiteAsyncConnection(this.DBPath);
var messagesToDelete = db.Table<OldMessageSettings>().Where(m => m.ID == settings.ID);
foreach (var messageToDelete in await messagesToDelete.ToListAsync())
{
await db.DeleteAsync(messageToDelete);
}
}
public async Task DeleteItemAsync(int identifier)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
List<Item> childs = await context.Table<Item>().Where(p => p.Parent == identifier).ToListAsync();
foreach(Item child in childs)
{
await context.DeleteAsync(child);
}
Item item = await context.Table<Item>().Where(p => p.Identifier == identifier).FirstOrDefaultAsync();
if (item != null)
await context.DeleteAsync(item);
}
async public Task<ParentViewModel> GetParentAsync(int identifier)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
ParentViewModel trip = new ParentViewModel();
//trips have the parent null, items have a trip as parent
Item item = await context.Table<Item>().Where(p => p.Identifier == identifier && p.Parent == 0).FirstOrDefaultAsync();
trip = new ParentViewModel()
{
Title = item.Title,
Description = item.Description,
StartDate = Convert.ToDateTime(item.StartDate),
Category = (Int16)Generic.UI.Logic.Enumerations.Category.Trips,
Cost = item.Cost,
Identifier = item.Identifier,
Latitude = item.Latitude,
Longitude = item.Longitude,
LocalPathImage = item.Image == null ? loader.GetString("DefaultParentImage") : item.Image,
User = new Guid(item.User)
};
return trip;
}
async public Task DeleteTrashImageAsync(string imageName)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
TrashImage image = await context.Table<TrashImage>().Where(p => p.Name == imageName).FirstOrDefaultAsync();
if (image != null)
await context.DeleteAsync(image);
}
async public Task<List<TrashImage>> GetTrashImagesAsync()
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
await context.CreateTableAsync<Sugges.UI.Logic.DataModel.TrashImage>();
List<TrashImage> result = await context.Table<TrashImage>().ToListAsync();
return result;
}
async public void RegisterTrashImage(string imageName)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
TrashImage image = await context.Table<TrashImage>().Where(p => p.Name == imageName).FirstOrDefaultAsync();
if (image == null)
{
TrashImage newItem = new TrashImage()
{
Name = imageName,
};
await context.InsertAsync(newItem);
}
}
async public Task UpdateItem(ItemViewModel itemViewModel)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
List<ItemViewModel> result = new List<ItemViewModel>();
Item item = await context.Table<Item>().Where(p => p.Identifier == itemViewModel.Identifier).FirstOrDefaultAsync();
item.Title = itemViewModel.Title;
item.Description = itemViewModel.Description;
item.Cost = itemViewModel.Cost;
item.Category = itemViewModel.Category;
if (item != null)
{
await context.UpdateAsync(item);
}
}
async public Task UpdateTrip(TripViewModel trip)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
List<ItemViewModel> result = new List<ItemViewModel>();
Item item = await context.Table<Item>().Where(p => p.Identifier == trip.Identifier).FirstOrDefaultAsync();
item.Image = trip.LocalPathImage;
item.Title = trip.Title;
item.Description = trip.Description;
item.Cost = trip.Cost;
item.StartDate = trip.StartDate;
if (item != null)
{
await context.UpdateAsync(item);
}
}
async public Task<int> SaveItemAsync(ItemViewModel item)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
Item newItem = new Item()
{
Identifier = item.Identifier,
Title = item.Title,
Description = item.Description,
Cost = item.Cost,
Latitude = item.Latitude,
Longitude = item.Longitude,
Parent = item.Trip.Identifier,
Traveler = item.Traveler.ToString(),
Category = item.Category
};
await context.InsertAsync(newItem);
return newItem.Identifier;
}
public async Task<List<ItemViewModel>> GetItemsByTripAsync(int trip)
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
List<ItemViewModel> result = new List<ItemViewModel>();
List<Item> items = await context.Table<Item>().Where(p => p.Parent == trip).ToListAsync();
foreach (Item item in items)
{
result.Add(new ItemViewModel()
{
Title = item.Title,
Description = item.Description,
Cost = item.Cost,
Latitude = item.Latitude,
Longitude = item.Longitude,
Traveler = new Guid(item.Traveler),
Category = (byte)item.Category,
Identifier = item.Identifier,
LocalPathImage = item.Image,
});
}
return result;
}
public async Task<bool> DeleteAccount(int accountId)
{
var db = new SQLite.SQLiteAsyncConnection(app.DBPath);
var existingAccount = await (db.Table<Account>().Where(
a => a.Id == accountId)).FirstAsync();
return await db.DeleteAsync(existingAccount) > 0;
}
private void myGeolocator_PositionChanged(object sender, GeoPositionChangedEventArgs<GeoCoordinate> e)
{
progressBar.Visibility = Visibility.Collapsed;
if (_trackingOn)
{
string lat = myLocation.Latitude.ToString();
string lon = myLocation.Longitude.ToString();
if (lat.Length >= 8 && lon.Length >= 8)
{
lon = lon.Remove(8);
lat = lat.Remove(8);
}
string lon2 = myGeolocator.Position.Location.Longitude.ToString();
string lat2 = myGeolocator.Position.Location.Latitude.ToString();
if (lat2.Length >= 8 && lon2.Length >= 8)
{
lon2 = lon2.Remove(8);
lat2 = lat2.Remove(8);
}
if (lon == lon2 && lat == lat2)
{
return;
}
myLocation = myGeolocator.Position.Location;
GetLocationAddress(myLocation.Latitude, myLocation.Longitude);
stopsMap.Center = myLocation;
markUserLocation(myLocation);
conn = CreateDatabaseConnection();
getClosestStop(conn);
}
}
private async Task addOldMessage(OldMessageSettings settings)
{
var db = new SQLite.SQLiteAsyncConnection(this.DBPath);
OldMessageSettings existingMessage;
try
{
existingMessage = await (db.Table<OldMessageSettings>().Where(m => m.ID == settings.ID).FirstAsync());
}
catch
{
existingMessage = null;
}
if (existingMessage != null)
{
existingMessage.FontSize = settings.FontSize;
existingMessage.AnimateMessage = settings.AnimateMessage;
existingMessage.Duration = settings.Duration;
existingMessage.Message = settings.Message;
existingMessage.ShowCountdown = settings.ShowCountdown;
existingMessage.Added = DateTime.Now;
int success = await db.UpdateAsync(existingMessage);
}
else
{
settings.Added = DateTime.Now;
int success = await db.InsertAsync(OldMessageSettings.CreateOldMessageSettings(settings));
}
}
public async Task<List<TripViewModel>> GetSuggestionsAsync()
{
SQLite.SQLiteAsyncConnection context = new SQLite.SQLiteAsyncConnection(connectionString);
List<TripViewModel> suggestions = new List<TripViewModel>();
List<Item> result = await context.Table<Item>().Where(p => p.IsSuggestion == true).ToListAsync();
foreach (Item item in result)
{
suggestions.Add(new TripViewModel()
{
Title = item.Title,
Description = item.Description,
EndDate = Convert.ToDateTime(item.EndDate),
StartDate = Convert.ToDateTime(item.StartDate),
Category = (Int16)Sugges.UI.Logic.Enumerations.Category.Trips,
Cost = item.Cost,
Identifier = item.Identifier,
Latitude = item.Latitude,
Longitude = item.Longitude,
RemotePathImage = item.Image == null ? "/Assets/Suggestion.png" : item.Image,
LocalPathImage = item.Image == null ? "/Assets/Suggestion.png" : item.Image,
Traveler = new Guid(item.Traveler),
IsSuggestion = true
});
}
return suggestions;
}
public async Task ClearFavoriteMessages()
{
var db = new SQLite.SQLiteAsyncConnection(this.DBPath);
await db.DropTableAsync<FavoriteMessageSettings>();
await db.CreateTableAsync<FavoriteMessageSettings>();
await refreshFavoriteMessages();
}
private void CurrentLocationReverseGeocodeQuery_QC(object sender, QueryCompletedEventArgs<IList<MapLocation>> e)
{
progressBar.Visibility = Visibility.Collapsed;
if (e.Error == null)
{
if (e.Result.Count > 0)
{
MapAddress address = e.Result[0].Information.Address;
myLocationAddress = createAddressString(address);
CurrentLocationText.Text = "You are currently at " + myLocationAddress;
locationState = address.State.ToString();
conn = CreateDatabaseConnection();
getClosestStop(conn);
}
}
}
