private void OpenDataStore()
{
try
{
if (string.IsNullOrEmpty(Path) || string.IsNullOrEmpty(pwdBox.Password))
{
throw new Exception("A path and password are required.");
}
else if (!Path.EndsWith(Extension))
{
Path += Extension;
}
IDataStore ds = new SQLiteDataStore(Path, pwdBox.Password);
ds.Open();
DataStore = ds;
pathHistory.AddItem(Path);
settings.History = pathHistory.SerializeToString();
settings.Save();
Cancelled = false;
openDatabaseWindow.Close();
}
catch (Exception e)
{
MessageBoxFactory.ShowError(e);
}
}
private void btnDeleteDataStore_Click(object sender, EventArgs e)
{
try
{
this.lblSize.Text = "0 Kb";
this.lblCreatedOn.Text = "-";
this.dbsStructure.DataStore = null;
this.dbtTests.DataStore = null;
if (this._DataStore != null)
{
this._DataStore.Dispose();
this._DataStore = null;
}
if (this.txtFileName.Text.Length > 0 && System.IO.File.Exists(this.txtFileName.Text))
{
System.Threading.Thread.Sleep(500);
System.IO.File.Delete(this.txtFileName.Text);
}
}
catch (Exception ex)
{
OpenNETCF.ORM.MainDemo.Logger.LogException(System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
}
}
public void ManyToOneReferenceTest()
{
var driver = new Driver()
{
Name = "Speed Racer"
};
driver.Vehicles.AddRange(
new Vehicle[]
{
new Vehicle()
{
Model = "Super Fast"
},
new Vehicle()
{
Model = "Sorta Fast"
}
});
var Order = new Order()
{
Number = "1234",
Driver = driver
};
var store = new SQLiteDataStore("test.sqlite");
store.AddType <Order>();
store.AddType <Driver>();
store.AddType <Vehicle>();
store.CreateStore();
store.Insert(Order, true);
}
private void Test()
{
IDataStore client = new SQLiteDataStore("test.db", "test", false);
client.Open();
var pwd = new PasswordItem()
{
Name = "test", Username = "******", Password = "******"
};
(var passwords, var entries) = GetData(client);
client.AddPassword(pwd);
client.AddEntry(new Entry()
{
Name = "test", CredentialId = pwd.ID
});
(passwords, entries) = GetData(client);
client.DeletePassword(pwd);
(passwords, entries) = GetData(client);
}
public void SingleEntityFetchTest()
{
var drivers = new Driver[]
{
new Driver()
{
Name = "Speed Racer"
},
new Driver()
{
Name = "Shaggy"
},
new Driver()
{
Name = "Mario"
},
new Driver()
{
Name = "Luigi"
},
};
var store = new SQLiteDataStore("test.sqlite");
store.AddType <Driver>();
store.CreateStore();
foreach (var driver in drivers)
{
store.Insert(driver);
}
var items = store.Fetch <Driver>(2).ToArray();
Assert.AreEqual(2, items.Length);
}
public void SimpleCRUDTest()
{
var store = new SQLiteDataStore("test.db");
store.AddType <TestItem>();
store.CreateStore();
var itemA = new TestItem("ItemA");
var itemB = new TestItem("ItemB");
var itemC = new TestItem("ItemC");
// INSERT
store.Insert(itemA);
store.Insert(itemB);
store.Insert(itemC);
// COUNT
var count = store.Count <TestItem>();
Assert.AreEqual(3, count);
// SELECT
var item = store.Select <TestItem>("Name", itemB.Name).FirstOrDefault();
Assert.IsTrue(item.Equals(itemB));
item = store.Select <TestItem>(3);
Assert.IsTrue(item.Equals(itemC));
// FETCH
// UPDATE
itemC.Name = "NewItem";
itemC.Address = "Changed Address";
itemC.TS = new TimeSpan(8, 23, 30);
store.Update(itemC);
item = store.Select <TestItem>("Name", "ItemC").FirstOrDefault();
Assert.IsNull(item);
item = store.Select <TestItem>("Name", itemC.Name).FirstOrDefault();
Assert.IsTrue(item.Equals(itemC));
// CONTAINS
var exists = store.Contains(itemA);
Assert.IsTrue(exists);
// DELETE
store.Delete(itemA, false);
item = store.Select <TestItem>("Name", itemA.Name).FirstOrDefault();
Assert.IsNull(item);
// CONTAINS
exists = store.Contains(itemA);
Assert.IsFalse(exists);
// COUNT
count = store.Count <TestItem>();
Assert.AreEqual(2, count);
}
public void Run()
{
var store = new SQLiteDataStore(Path.Combine(Application.StartupPath, "northwind.db"));
// get all orders, with the associated (reference) customer for each
var orders = store.Select <Orders>(true).ToArray();
var oldOrder = orders.Last();
// create a new order for the same customer as the last in the list
var newOrder = new Orders()
{
OrderID = oldOrder.OrderID + 1, // this database does not use auto-incrementing keys
CustomerID = oldOrder.CustomerID,
ShipName = "ATTN: John Steinbeck",
ShipAddress = "7 Rue de M",
ShipCity = "Paris",
ShipCountry = "France",
ShippedDate = new DateTime(1955, 6, 1)
};
// insert that order
store.Insert(newOrder);
// select that order back out by PK
var order = store.Select <Orders>(o => o.ShipName.Contains("Steinbeck")).First();
// now delete that order by PK value
store.Delete <Orders>(order.OrderID);
}
public void BitTest()
{
var store = new SQLiteDataStore(@"E:\d\shared\TFS01\orm\Tests\OpenNETCF.ORM.SQLite.Integration.Test\testdb.sqlite");
store.AddType <OSATestSettings>();
var settings = store.Select <OSATestSettings>().ToArray();
}
public void LongIDTest()
{
var store = new SQLiteDataStore("test2.db");
store.AddType <BigID>();
store.CreateStore();
store.Insert(new BigID("Foo"));
var bid = store.Select <BigID>();
}
public void InitializeObjects()
{
try
{
this.txtFileName.Text = "demo.db3";
if (System.IO.File.Exists(this.txtFileName.Text))
{
var fi = new System.IO.FileInfo(this.txtFileName.Text);
this.lblSize.Text = String.Format("{0} Kb", (fi.Length / 1024));
this.lblCreatedOn.Text = String.Format("{0}", fi.CreationTime.ToString());
if (this._DataStore != null)
{
this._DataStore.Dispose();
}
this._DataStore = new SQLiteDataStore(this.txtFileName.Text);
if (chkAutoVacuum.Checked)
{
this._DataStore.SetAutoVacuumBehavior(SQLiteDataStore.AutoVacuum.FULL);
}
else
{
this._DataStore.SetAutoVacuumBehavior(SQLiteDataStore.AutoVacuum.OFF);
}
if (chkTransactionSynchronization.Checked)
{
this._DataStore.SetTransactionSynchronization(SQLiteDataStore.TransactionSynchronization.FULL);
}
else
{
this._DataStore.SetTransactionSynchronization(SQLiteDataStore.TransactionSynchronization.OFF);
}
this._DataStore.MaxDatabaseSizeInMB = 500;
this._DataStore.ConnectionBehavior = ConnectionBehavior.Persistent;
this._DataStore.DiscoverTypes(System.Reflection.Assembly.GetAssembly(typeof(OpenNETCF.ORM.Model.basictable)));
this.dbsStructure.DataStore = this._DataStore;
this.dbtTests.DataStore = this._DataStore;
this.deTests.DataStore = this._DataStore;
this.dbsStructure.DataStoreChanged += new EventHandler(dbsStructure_DataStoreChanged);
this.deTests.DataStoreChanged += new EventHandler(deTests_DataStoreChanged);
}
}
catch (Exception ex)
{
OpenNETCF.ORM.MainDemo.Logger.LogException(System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
throw ex;
}
}
public void DisposalTest()
{
try
{
var path = Path.Combine(TestContext.TestResultsDirectory, "test.sqlite");
var store = new SQLiteDataStore(path);
store.CreateStore();
store.Dispose();
var fs = new FileStream(path, FileMode.Open);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public void SimpleGuidIDEntityTest()
{
var store = new SQLiteDataStore("test.db");
store.AddType <GuidItem>();
store.CreateStore();
var item = new GuidItem();
store.Insert(item);
var existing = store.Select <GuidItem>(item.ID);
Assert.IsNotNull(existing);
Assert.AreEqual(item.ID, existing.ID);
store.Delete <GuidItem>(item.ID);
existing = store.Select <GuidItem>(item.ID);
Assert.IsNull(existing);
}
private SQLiteDataStore GetTestStore()
{
// var info = new MySQLConnectionInfo("192.168.10.246", 3306, "TestDB", "root", "password");
var store = new SQLiteDataStore("test.db");
if (store.StoreExists)
{
store.DeleteStore();
}
if (!store.StoreExists)
{
store.CreateStore();
}
else
{
store.EnsureCompatibility();
}
return(store);
}
public void SimpleReferenceTest()
{
var store = new SQLiteDataStore("simpleReferenceTest.db");
store.AddType <Author>();
store.AddType <Book>();
store.CreateOrUpdateStore();
// insert an author
var dumas = new Author()
{
Name = "Alexadre Dumas"
};
store.Insert(dumas);
// insert a couple books.
// note that we're inserting the foreign key value
store.Insert(
new Book()
{
AuthorID = dumas.ID,
Title = "The Count of Monte Cristo"
});
store.Insert(
new Book()
{
AuthorID = dumas.ID,
Title = "The Three Musketeers"
});
// now get the authors back, telling ORM to fill the references
var authors = store.Select <Author>(true).ToArray();
// at this point you will have 1 Author instance, with the Books property hydrated and containing two Book instances
}
public void SimpleReferenceTest2()
{
var store = new SQLiteDataStore("simpleReferenceTest.db");
store.AddType <Location>();
store.AddType <Position>();
store.CreateOrUpdateStore();
var position1 = new Position()
{
Description = "Position 1"
};
store.Insert(position1);
store.Insert(
new Location()
{
Description = "Description A",
positionId = position1.positionId
});
var positions = store.Select <Position>(true).ToArray();
}
private void btnCreateDataStore_Click(object sender, EventArgs e)
{
try
{
this.lblSize.Text = "0 Kb";
this.lblCreatedOn.Text = "-";
if (this.txtFileName.Text.Length > 0)
{
String path = System.IO.Path.GetDirectoryName(this.txtFileName.Text);
if (path.Length == 0 || System.IO.Directory.Exists(path))
{
if (this._DataStore != null)
{
this._DataStore.Dispose();
}
this._DataStore = new SQLiteDataStore(this.txtFileName.Text);
if (chkAutoVacuum.Checked)
{
this._DataStore.SetAutoVacuumBehavior(SQLiteDataStore.AutoVacuum.FULL);
}
else
{
this._DataStore.SetAutoVacuumBehavior(SQLiteDataStore.AutoVacuum.OFF);
}
if (chkTransactionSynchronization.Checked)
{
this._DataStore.SetTransactionSynchronization(SQLiteDataStore.TransactionSynchronization.FULL);
}
else
{
this._DataStore.SetTransactionSynchronization(SQLiteDataStore.TransactionSynchronization.OFF);
}
this._DataStore.MaxDatabaseSizeInMB = 500;
this._DataStore.ConnectionBehavior = ConnectionBehavior.Persistent;
this._DataStore.DiscoverTypes(System.Reflection.Assembly.GetAssembly(typeof(OpenNETCF.ORM.Model.basictable)));
if (System.IO.File.Exists(this.txtFileName.Text))
{
this._DataStore.CreateOrUpdateStore();
}
else
{
this._DataStore.CreateStore();
}
this.dbtTests.DataStore = this._DataStore;
this.dbsStructure.DataStore = this._DataStore;
if (System.IO.File.Exists(this.txtFileName.Text))
{
var fi = new System.IO.FileInfo(this.txtFileName.Text);
this.lblSize.Text = String.Format("{0} Kb", (fi.Length / 1024));
this.lblCreatedOn.Text = String.Format("{0}", fi.CreationTime.ToString());
}
}
else
{
throw new Exception("Directory Path doesn't exist!");
}
}
}
catch (Exception ex)
{
OpenNETCF.ORM.MainDemo.Logger.LogException(System.Reflection.MethodBase.GetCurrentMethod().Name, ex);
}
}
/// <summary>
/// App Constructor
/// </summary>
public App()
{
HaccpAppSettings.SharedInstance.IsWindows = Device.OS == TargetPlatform.Windows ||
Device.OS == TargetPlatform.WinPhone;
if (HaccpAppSettings.SharedInstance.IsWindows)
{
Task.Run(
async() =>
{
HaccpAppSettings.SharedInstance.ResourceString =
await DependencyService.Get <IResourceFileHelper>().LoadResourceAsync("ResourceFile.xml");
});
}
else
{
try
{
HaccpAppSettings.SharedInstance.ResourceString =
DependencyService.Get <IResourceFileHelper>().LoadResource("ResourceFile.xml");
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
IDataStore dataStore = new SQLiteDataStore();
dataStore.LoadAppSettings(HaccpAppSettings.SharedInstance);
Localization.SetLocale();
HACCPUtil.PreCalculateSlopes();
var netLanguage = DependencyService.Get <ILocale>().GetCurrent();
AppResources.Culture = netLanguage;
Styles.LoadStyles();
if (string.IsNullOrEmpty(HaccpAppSettings.SharedInstance.SiteSettings.ServerAddress))
{
MainPage = new NavigationPage(new ServerSettings())
{
BarBackgroundColor = Color.FromRgb(20, 34, 43),
BarTextColor = Color.FromRgb(225, 225, 225),
HeightRequest = 41
};
}
else
{
MainPage = new NavigationPage(new Home())
{
BarBackgroundColor = Color.FromRgb(20, 34, 43),
BarTextColor = Color.FromRgb(225, 225, 225),
HeightRequest = 41
};
}
}
public void PrimaryKeyWrongTypeTest2()
{
var store = new SQLiteDataStore("test.db");
store.AddType <BadKeyTypeBItem>();
}
public void SetUpDatabase()
{
dataStore = new SQLiteDataStore();
}
public void NoPrimaryKeyTest()
{
var store = new SQLiteDataStore("test.db");
store.AddType <NoPKGuidItem>();
}
public void SimpleCRUDTest()
{
var path = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "test.db");
var store = new SQLiteDataStore(path);
store.AddType <TestItem>();
TestItem itemA;
TestItem itemB;
TestItem itemC;
if (store.StoreExists)
{
store.DeleteStore();
}
store.CreateStore();
itemA = new TestItem("ItemA");
itemB = new TestItem("ItemB");
itemC = new TestItem("ItemC");
// INSERT
store.Insert(itemA);
store.Insert(itemB);
store.Insert(itemC);
// COUNT
var count = store.Count <TestItem>();
//Assert.AreEqual(3, count);
if (count != 3)
{
Debugger.Break();
}
// SELECT
var item = store.Select <TestItem>("Name", itemB.Name).FirstOrDefault();
//Assert.IsTrue(item.Equals(itemB));
item = store.Select <TestItem>(3);
//Assert.IsTrue(item.Equals(itemC));
// FETCH
// UPDATE
itemC.Name = "NewItem";
itemC.Address = "Changed Address";
itemC.TS = new TimeSpan(8, 23, 30);
store.Update(itemC);
item = store.Select <TestItem>("Name", "ItemC").FirstOrDefault();
//Assert.IsNull(item);
item = store.Select <TestItem>("Name", itemC.Name).FirstOrDefault();
//Assert.IsTrue(item.Equals(itemC));
// CONTAINS
var exists = store.Contains(itemA);
//Assert.IsTrue(exists);
// DELETE
store.Delete(itemA);
item = store.Select <TestItem>("Name", itemA.Name).FirstOrDefault();
//Assert.IsNull(item);
// CONTAINS
exists = store.Contains(itemA);
//Assert.IsFalse(exists);
// COUNT
count = store.Count <TestItem>();
//Assert.AreEqual(2, count);
}
