/// <summary>
/// This will DELETE and then INSERT each setting
/// </summary>
/// <param name="shippingServiceId"></param>
/// <param name="settings"></param>
public void UpdateSettingsDictionary(Dictionary <string, string> settings)
{
using (esTransactionScope transaction = new esTransactionScope())
{
// DELETE all existing settings for this service
ShippingServiceSettingQuery qDelete = new ShippingServiceSettingQuery();
qDelete.Where(qDelete.ShippingServiceId == this.Id.Value);
ShippingServiceSettingCollection oldSettings = new ShippingServiceSettingCollection();
oldSettings.Load(qDelete);
oldSettings.MarkAllAsDeleted();
oldSettings.Save();
// INSERT new settings for this service
if (settings.Keys.Count > 0)
{
ShippingServiceSettingCollection newSettings = new ShippingServiceSettingCollection();
foreach (KeyValuePair <string, string> setting in settings)
{
ShippingServiceSetting newSetting = newSettings.AddNew();
newSetting.ShippingServiceId = this.Id.Value;
newSetting.Name = setting.Key;
newSetting.Value = setting.Value;
}
newSettings.Save();
}
transaction.Complete();
}
}
public void PgDataTypeTest()
{
DateTime testTime = Convert.ToDateTime("0001-01-01 01:23:45.678");
PgDataTypes datatypeTest = new PgDataTypes();
switch (datatypeTest.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.Npgsql2Provider":
using (esTransactionScope scope = new esTransactionScope())
{
datatypeTest.TimeType = testTime;
datatypeTest.Save();
long?tempKey = datatypeTest.Id;
datatypeTest = new PgDataTypes();
Assert.IsTrue(datatypeTest.LoadByPrimaryKey(tempKey.Value));
Assert.IsTrue(datatypeTest.TimeType.HasValue);
Assert.AreEqual(datatypeTest.TimeType.Value, testTime);
datatypeTest.MarkAsDeleted();
datatypeTest.Save();
}
break;
default:
Assert.Ignore("PostgreSQL only");
break;
}
}
public void SetGuidPrimaryKey()
{
GuidTest dataTest = new GuidTest();
dataTest.es.Connection.Name = "GuidTest";
switch (dataTest.es.Connection.ProviderMetadataKey)
{
case "esSqlCe":
case "esSqlCe4":
using (esTransactionScope scope = new esTransactionScope())
{
string testGuid = "b3883c65-ff94-47c4-8b0c-76896bedd45a";
dataTest = new GuidTest();
dataTest.es.Connection.Name = "GuidTest";
dataTest.GuidKey = new Guid(testGuid);
dataTest.Save();
Guid?tempKey = dataTest.GuidKey;
dataTest.MarkAsDeleted();
dataTest.Save();
Assert.AreEqual(testGuid, tempKey.Value.ToString());
}
break;
default:
Assert.Ignore("SqlCe only");
break;
}
}
private void UpdateTaxRates(List <TaxRateInfo> taxRateInfos)
{
using (esTransactionScope transaction = new esTransactionScope())
{
int storeId = StoreContext.CurrentStore.Id.Value;
//---- delete all tax regions for this store
TaxRegionQuery q = new TaxRegionQuery();
q.Where(q.StoreId == storeId);
TaxRegionCollection taxRegions = new TaxRegionCollection();
taxRegions.Load(q);
taxRegions.MarkAllAsDeleted();
taxRegions.Save();
//---- and re-insert them
// remove duplicate entries
taxRateInfos.RemoveDuplicates((left, right) => (left.CountryCode == right.CountryCode && left.Region == right.Region) ? 1 : -1);
foreach (TaxRateInfo taxRate in taxRateInfos)
{
TaxRegion newTaxRegion = taxRegions.AddNew();
newTaxRegion.StoreId = storeId;
newTaxRegion.CountryCode = taxRate.CountryCode;
newTaxRegion.Region = taxRate.Region;
newTaxRegion.TaxRate = taxRate.TaxRate;
}
taxRegions.Save();
transaction.Complete();
}
}
public void OracleXmlType()
{
OracleXmlTestCollection coll = new OracleXmlTestCollection();
switch (coll.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.OracleClientProvider":
using (esTransactionScope scope = new esTransactionScope())
{
string xmltypeCol = @"<?xml version=""1.0""?><EMAIL>SKING</EMAIL>";
OracleXmlTest entity = new OracleXmlTest();
entity.Id = "test1";
entity.XmlColumn = xmltypeCol;
entity.Save();
//entity.InsertOracleXml();
coll = new OracleXmlTestCollection();
//coll.LoadAll();
//Assert.IsTrue(coll.LoadOracleXml(), "Load");
coll.Query.SelectAllExcept(coll.Query.XmlColumn);
coll.Query.Select("<SYS.XMLTYPE.GETSTRINGVAL(\"XmlColumn\") AS \"XmlColumn\">");
coll.Query.Load();
//string xmlCol = coll[0].XmlColumn;
//string xmlId = coll[0].Id;
Assert.AreEqual(xmltypeCol, coll[0].XmlColumn, "Compare");
}
break;
default:
Assert.Ignore("Oracle only.");
break;
}
}
/// <summary>
/// Used to Save the data to the database
/// </summary>
/// <returns>True if Successful</returns>
public override bool Submit(ChangeSet changeSet)
{
try
{
using (esTransactionScope scope = new esTransactionScope())
{
bool success = base.Submit(changeSet);
if (success)
{
scope.Complete();
}
return(success);
}
}
catch (Exception ex)
{
if (!HandleError(ex))
{
throw;
}
return(true);
}
}
public static void UpdateSettingsDictionary(int storeId, short paymentProviderId, Dictionary <string, string> settings)
{
using (esTransactionScope transaction = new esTransactionScope())
{
// DELETE all existing settings for this store/provider
StorePaymentProviderSettingQuery qDelete = new StorePaymentProviderSettingQuery();
qDelete.Where(qDelete.StoreId == storeId, qDelete.PaymentProviderId == paymentProviderId);
StorePaymentProviderSettingCollection oldSettings = new StorePaymentProviderSettingCollection();
oldSettings.Load(qDelete);
oldSettings.MarkAllAsDeleted();
oldSettings.Save();
// INSERT new settings for this store/provider
if (settings.Keys.Count > 0)
{
StorePaymentProviderSettingCollection newSettings = new StorePaymentProviderSettingCollection();
foreach (KeyValuePair <string, string> setting in settings)
{
StorePaymentProviderSetting newSetting = newSettings.AddNew();
newSetting.StoreId = storeId;
newSetting.PaymentProviderId = paymentProviderId;
newSetting.Name = setting.Key;
newSetting.Value = setting.Value;
}
newSettings.Save();
}
transaction.Complete();
}
}
public void TestAttachDetachEntityAdded()
{
try
{
using (esTransactionScope scope = new esTransactionScope())
{
AggregateTestCollection aggTestColl = new AggregateTestCollection();
AggregateTestCollection aggCloneColl = new AggregateTestCollection();
aggCloneColl.LoadAll();
foreach (AggregateTest entity in aggCloneColl)
{
if (entity.LastName == "Doe")
{
entity.MarkAllColumnsAsDirty(esDataRowState.Added);
aggTestColl.AttachEntity(aggCloneColl.DetachEntity(entity));
break;
}
}
Assert.IsTrue(aggTestColl.IsDirty);
aggTestColl.Save();
Assert.IsFalse(aggTestColl.IsDirty, "Collection is still dirty");
aggTestColl.LoadAll();
Assert.AreEqual(31, aggTestColl.Count);
}
}
finally
{
UnitTestBase.RefreshDatabase();
}
}
public void UnsignedAutoIncrement()
{
Mysqltypetest2Collection coll = new Mysqltypetest2Collection();
// There is a bug in the 1.0.7 Connector/Net for unsigned types.
// It is fixed in 5.0.3.
switch (coll.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.MySqlClientProvider":
using (esTransactionScope scope = new esTransactionScope())
{
Mysqltypetest2 datatypeTest = new Mysqltypetest2();
datatypeTest.CharType = "X";
datatypeTest.VarCharType = "xxx";
datatypeTest.str().DateType = "2007-01-01";
datatypeTest.str().DateTimeType = "2006-12-31 11:59:30";
datatypeTest.TextType = "Some test text.";
datatypeTest.str().TimeType = "12:34:56.789";
datatypeTest.LongTextType = "Some more test text.";
datatypeTest.Save();
uint?tempKey = datatypeTest.Id;
Assert.IsTrue(datatypeTest.LoadByPrimaryKey(tempKey.Value));
datatypeTest.MarkAsDeleted();
datatypeTest.Save();
}
break;
default:
Assert.Ignore("MySQL only");
break;
}
}
public void TestAssociateDissociateNew()
{
int terrKey = -1;
int empKey = -1;
Employee emp = new Employee();
emp.es.Connection.Name = "ForeignKeyTest";
Territory terr = new Territory();
terr.es.Connection.Name = "ForeignKeyTest";
try
{
using (esTransactionScope scope = new esTransactionScope())
{
emp.LastName = "Test Last";
emp.FirstName = "Test First";
terr.Description = "Some New Territory";
terr.Save();
terrKey = terr.TerritoryID.Value;
emp.AssociateTerritoryCollection(terr);
emp.Save();
empKey = emp.EmployeeID.Value;
Assert.AreEqual(1, emp.UpToTerritoryCollection.Count);
foreach (EmployeeTerritory et in emp.EmployeeTerritoryCollectionByEmpID)
{
Assert.AreEqual(terr.TerritoryID.Value, et.TerrID.Value);
}
}
}
finally
{
// Clean up
emp = new Employee();
emp.es.Connection.Name = "ForeignKeyTest";
if (emp.LoadByPrimaryKey(empKey))
{
foreach (Territory t in emp.UpToTerritoryCollection)
{
emp.DissociateTerritoryCollection(t);
}
emp.MarkAsDeleted();
emp.Save();
}
terr = new Territory();
terr.es.Connection.Name = "ForeignKeyTest";
if (terr.LoadByPrimaryKey(terrKey))
{
terr.MarkAsDeleted();
terr.Save();
}
}
}
public void TestCollectionDeleteAll()
{
int prdId = -1;
Product prd = new Product();
prd.es.Connection.Name = "ForeignKeyTest";
try
{
using (esTransactionScope scope = new esTransactionScope())
{
prd.ProductName = "UnitTest";
prd.UnitPrice = 1;
prd.Discontinued = false;
for (int i = 0; i < 3; i++)
{
OrderItem oi = prd.OrderItemCollectionByProductID.AddNew();
oi.OrderID = i + 1;
oi.UnitPrice = prd.UnitPrice;
oi.Quantity = Convert.ToInt16(i);
oi.Discount = 0;
}
prd.Save();
prdId = prd.ProductID.Value;
// Test
ProductCollection collection = new ProductCollection();
collection.es.Connection.Name = "ForeignKeyTest";
Assert.IsTrue(collection.LoadAll());
Product entity = collection.FindByPrimaryKey(prdId);
Assert.AreEqual(3, entity.OrderItemCollectionByProductID.Count);
entity.OrderItemCollectionByProductID.MarkAllAsDeleted();
entity.MarkAsDeleted();
collection.Save();
prd = new Product();
prd.es.Connection.Name = "ForeignKeyTest";
Assert.IsFalse(prd.LoadByPrimaryKey(prdId));
OrderItemCollection oic = new OrderItemCollection();
oic.es.Connection.Name = "ForeignKeyTest";
oic.Query.Where(oic.Query.ProductID == prdId);
Assert.IsFalse(oic.Query.Load());
}
}
finally
{
prd = new Product();
prd.es.Connection.Name = "ForeignKeyTest";
if (prd.LoadByPrimaryKey(prdId))
{
prd.OrderItemCollectionByProductID.MarkAllAsDeleted();
prd.MarkAsDeleted();
prd.Save();
}
}
}
protected void lnkSaveIssue_Click(object sender, EventArgs e)
{
using (esTransactionScope scope = new esTransactionScope())
{
OMAMFundManager objFundManager = new OMAMFundManager();
if (fundManager == null)
{
//This is an add
objFundManager.FullName = txtFMName.Text.ToString();
objFundManager.Profile = Editor1.Text.ToString();
objFundManager.CreatedBy = UserId;
objFundManager.CreatedDate = DateTime.Now;
//MTW objFundManager.FMImage = ddlFundManager.SelectedValue.ToString();
objFundManager.Save();
}
else
{
//This is an update
objFundManager.Query.Where(objFundManager.Query.Id == Convert.ToInt32(fundManager.Id));
objFundManager.Query.Load();
objFundManager.FullName = txtFMName.Text.ToString();
objFundManager.Profile = Editor1.Text.ToString();
//MTW objFundManager.FMImage = ddlFundManager.SelectedValue.ToString();
objFundManager.Save();
}
//Remove all the assigned funds first
OMAMLNKManagerFundsCollection objManagerFunds = new OMAMLNKManagerFundsCollection();
objManagerFunds.Query
.Where(objManagerFunds.Query.ManagerId == objFundManager.Id);
objManagerFunds.Query.Load();
objManagerFunds.MarkAllAsDeleted();
objManagerFunds.Save();
//OK, Now add the newly assigned funds
for (int i = 0; i < cblFundsAssigned.Items.Count; i++)
{
OMAMLNKManagerFunds assignedFunds = new OMAMLNKManagerFunds();
assignedFunds.ManagerId = objFundManager.Id;
assignedFunds.FundId = Convert.ToInt16(cblFundsAssigned.Items[i].Value);
assignedFunds.Save();
}
scope.Complete();
divAddActivity.Visible = false;
divFMGrid.Visible = true;
LoadFMs();
}
}
public void AddProductToCart(int productId, int productQty, string jsonProductFieldData)
{
//UpdateCartItemInCart(null, productId, productQty, true, jsonProductFieldData);
DataModel.Cart cart = null;
using (esTransactionScope transaction = new esTransactionScope())
{
cart = GetCartFromDatabase(true);
CartItemCollection cartItemCollection = cart.CartItemCollectionByCartId;
List <CartItem> cartItems = cartItemCollection.ToList();
int index = cartItems.FindIndex(ci => (ci.ProductId.Value == productId) && (ci.ProductFieldData == jsonProductFieldData));
if (index >= 0)
{
// product is in the cart
if (productQty <= 0)
{
// remove from cart
cartItemCollection[index].MarkAsDeleted();
}
else
{
// add/update quantity
cartItemCollection[index].Quantity += productQty;
// update ProductFieldData
if (!string.IsNullOrEmpty(jsonProductFieldData))
{
cartItemCollection[index].ProductFieldData = jsonProductFieldData;
}
}
}
else if (productQty > 0)
{
// add to cart
CartItem newItem = cartItemCollection.AddNew();
newItem.ProductId = productId;
newItem.Quantity = productQty;
newItem.ProductFieldData = jsonProductFieldData;
}
//---- update some cart fields too...
if (storeContext.UserId.HasValue)
{
cart.UserId = storeContext.UserId.Value;
}
cart.Save();
transaction.Complete();
}
//return cart;
}
public void ConcurrencyOnDelete()
{
ComputedTestCollection collection = new ComputedTestCollection();
int testId = 0;
switch (collection.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.SybaseSqlAnywhereProvider":
try
{
using (esTransactionScope scope = new esTransactionScope())
{
// Setup
ComputedTest entity = new ComputedTest();
entity.Save();
testId = entity.Id.Value;
// Test
entity = new ComputedTest();
entity.LoadByPrimaryKey(testId);
entity.str().SomeDate = "2007-01-01";
ComputedTest entity2 = new ComputedTest();
entity2.LoadByPrimaryKey(testId);
entity2.MarkAsDeleted();
entity.Save();
entity2.Save();
Assert.Fail("Concurrency Exception not thrown.");
}
}
catch (EntitySpaces.Interfaces.esConcurrencyException cex)
{
string err = cex.InnerException.Message.Substring(0, 11);
Assert.AreEqual("Error", cex.Message.Substring(0, 5));
Assert.AreEqual("Concurrency", err);
}
finally
{
// Cleanup
ComputedTest entity = new ComputedTest();
if (entity.LoadByPrimaryKey(testId))
{
entity.MarkAsDeleted();
entity.Save();
}
}
break;
default:
Assert.Ignore("Sybase only.");
break;
}
}
static private DataTable SaveDynamicCollection_Deletes(esDataRequest request)
{
VistaDBCommand cmd = null;
DataTable dataTable = CreateDataTable(request);
using (esTransactionScope scope = new esTransactionScope())
{
using (VistaDBDataAdapter da = new VistaDBDataAdapter())
{
da.AcceptChangesDuringUpdate = false;
da.ContinueUpdateOnError = request.ContinueUpdateOnError;
try
{
cmd = da.DeleteCommand = Shared.BuildDynamicDeleteCommand(request, request.CollectionSavePacket[0].ModifiedColumns);
esTransactionScope.Enlist(cmd, request.ConnectionString, CreateIDbConnectionDelegate);
DataRow[] singleRow = new DataRow[1];
// Delete each record
foreach (esEntitySavePacket packet in request.CollectionSavePacket)
{
DataRow row = dataTable.NewRow();
dataTable.Rows.Add(row);
SetOriginalValues(request, packet, row, true);
row.AcceptChanges();
row.Delete();
singleRow[0] = row;
da.Update(singleRow);
if (row.HasErrors)
{
request.FireOnError(packet, row.RowError);
}
dataTable.Rows.Clear(); // ADO.NET won't let us reuse the same DataRow
}
}
finally
{
esTransactionScope.DeEnlist(cmd);
cmd.Dispose();
}
}
scope.Complete();
}
return(request.Table);
}
public void TestAssociateDissociateNewComposite()
{
Course c = new Course();
c.es.Connection.Name = "ForeignKeyTest";
Student s = new Student();
s.es.Connection.Name = "ForeignKeyTest";
switch (c.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.SqlClientProvider":
using (esTransactionScope scope = new esTransactionScope())
{
s.S1 = "a";
s.S2 = "b";
s.StudentName = "Test Student";
c.C1 = 1;
c.C2 = "b";
c.ClassName = "Test Class";
c.Save();
s.AssociateCourseCollection(c);
s.Save();
Assert.AreEqual(1, c.UpToStudentCollection.Count);
Assert.AreEqual(1, s.UpToCourseCollection.Count);
foreach (StudentClass sc in s.StudentClassCollectionBySid1)
{
Assert.AreEqual(c.C1.Value, sc.Cid1.Value);
Assert.AreEqual(c.C2.Trim(), sc.Cid2.Trim());
Assert.AreEqual(s.S1.Trim(), sc.Sid1.Trim());
Assert.AreEqual(s.S2.Trim(), sc.Sid2.Trim());
}
s.DissociateCourseCollection(c);
s.Save();
s.UpToCourseCollection = null;
c.UpToStudentCollection = null;
Assert.AreEqual(0, c.UpToStudentCollection.Count);
Assert.AreEqual(0, s.UpToCourseCollection.Count);
}
break;
default:
Assert.Ignore("Not tested");
break;
}
}
public void NoSeqConcurrencyOnUpdate()
{
OracleTest2Collection collection = new OracleTest2Collection();
string testId = "XXXXX";
switch (collection.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.OracleClientProvider":
try
{
using (esTransactionScope scope = new esTransactionScope())
{
// Setup
OracleTest2 entity = new OracleTest2();
entity.Id = testId;
entity.Save();
// Test
entity = new OracleTest2();
entity.LoadByPrimaryKey(testId);
entity.str().DateType = "2007-01-01";
OracleTest2 entity2 = new OracleTest2();
entity2.LoadByPrimaryKey(testId);
entity2.str().DateType = "1999-12-31";
entity.Save();
entity2.Save();
Assert.Fail("Concurrency Exception not thrown.");
}
}
catch (EntitySpaces.Interfaces.esConcurrencyException cex)
{
Assert.AreEqual("ORA-2", cex.Message.ToString().Substring(0, 5));
}
finally
{
// Cleanup
OracleTest2 entity = new OracleTest2();
if (entity.LoadByPrimaryKey(testId))
{
entity.MarkAsDeleted();
entity.Save();
}
}
break;
default:
Assert.Ignore("Oracle only.");
break;
}
}
static private void SaveEntity()
{
// The transaction isn't necessary here but demonstrates it's usage
using (esTransactionScope scope = new esTransactionScope())
{
Employees employee = new Employees();
employee.FirstName = "Mike";
employee.LastName = "Griffin";
employee.Save();
scope.Complete(); // last line of using statement
}
}
public void TestFailedTransaction()
{
switch (aggTest.es.Connection.Name)
{
case "SQLStoredProcEnterprise":
case "SQLDynamicEnterprise":
case "ORACLEStoredProcEnterprise":
case "ORACLEDynamicEnterprise":
case "VistaDBDynamic":
Assert.Ignore("Using esTransactionScope only");
break;
default:
try
{
aggTest = new AggregateTest();
AggregateTest aggTest2 = new AggregateTest();
int tempId1 = -1;
int tempId2 = -1;
aggTest2.str().HireDate = "1/1/1";
using (esTransactionScope scope = new esTransactionScope())
{
try
{
aggTest.Save();
tempId1 = aggTest.Id.Value;
aggTest2.Save();
tempId2 = aggTest2.Id.Value;
throw new Exception();
scope.Complete();
}
catch
{
}
}
aggTest = new AggregateTest();
Assert.IsFalse(aggTest.LoadByPrimaryKey(tempId1));
aggTest = new AggregateTest();
Assert.IsFalse(aggTest.LoadByPrimaryKey(tempId2));
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
break;
}
}
public void ConcurrencyOnUpdate()
{
ComputedTestCollection collection = new ComputedTestCollection();
int testId = 0;
switch (collection.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.SqlClientProvider":
try
{
using (esTransactionScope scope = new esTransactionScope())
{
// Setup
ComputedTest entity = new ComputedTest();
entity.Save();
testId = entity.Id.Value;
// Test
entity = new ComputedTest();
entity.LoadByPrimaryKey(testId);
entity.str().SomeDate = "2007-01-01";
ComputedTest entity2 = new ComputedTest();
entity2.LoadByPrimaryKey(testId);
entity2.str().SomeDate = "1999-12-31";
entity.Save();
entity2.Save();
Assert.Fail("Concurrency Exception not thrown.");
}
}
catch (EntitySpaces.Interfaces.esConcurrencyException cex)
{
Assert.AreEqual("Update failed", cex.Message.Substring(0, 13));
}
finally
{
ComputedTest entity = new ComputedTest();
if (entity.LoadByPrimaryKey(testId))
{
entity.MarkAsDeleted();
entity.Save();
}
}
break;
default:
Assert.Ignore("SQL Server only.");
break;
}
}
protected override void UpdateSingleTest()
{
using (var ts = new esTransactionScope())
{
var simplests = new SimplestsCollection();
simplests.LoadAll();
foreach (var o in simplests)
{
o.Value++;
o.Save();
}
ts.Complete();
}
}
protected override void DeleteSingleTest()
{
using (var ts = new esTransactionScope())
{
var simplests = new SimplestsCollection();
simplests.LoadAll();
for (int i = simplests.Count - 1; i >= 0; i--)
{
var o = simplests[0];
o.MarkAsDeleted();
o.Save();
}
ts.Complete();
}
}
public void TestSaveWithAutoKey()
{
int terrKey = -1;
Territory terr = new Territory();
terr.es.Connection.Name = "ForeignKeyTest";
TerritoryEx terrEx = new TerritoryEx();
terrEx.es.Connection.Name = "ForeignKeyTest";
try
{
using (esTransactionScope scope = new esTransactionScope())
{
terr.Description = "Some New Territory";
terrEx = terr.TerritoryEx;
terrEx.Notes = "Test Group";
terr.Save();
terrKey = terr.TerritoryID.Value;
Assert.IsTrue(terr.TerritoryEx.es.HasData);
Assert.AreEqual(terr.TerritoryID.Value, terrEx.TerritoryID.Value);
terr = new Territory();
terr.es.Connection.Name = "ForeignKeyTest";
Assert.IsTrue(terr.LoadByPrimaryKey(terrKey));
Assert.IsTrue(terr.TerritoryEx.es.HasData);
}
}
finally
{
// Clean up
terr = new Territory();
terr.es.Connection.Name = "ForeignKeyTest";
if (terr.LoadByPrimaryKey(terrKey))
{
terrEx = terr.TerritoryEx;
terrEx.MarkAsDeleted();
terr.MarkAsDeleted();
terr.Save();
}
}
}
public void TestDateTimeMicroSeconds()
{
int testId = -1;
AggregateTest test = new AggregateTest();
switch (test.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.MSAccessProvider":
Assert.Ignore("MS Access only resolves to MilliSeconds.");
break;
case "EntitySpaces.MySqlClientProvider":
Assert.Ignore("Not supported.");
break;
case "EntitySpaces.SqlServerCeProvider":
case "EntitySpaces.SqlServerCe4Provider":
case "EntitySpaces.SqlClientProvider":
Assert.Ignore("Requires SQL Server 2008 and datetime2 data type.");
break;
default:
try
{
using (esTransactionScope scope = new esTransactionScope())
{
test.HireDate = Convert.ToDateTime("1902-01-01 01:01:01.000001");
test.Save();
testId = test.Id.Value;
test = new AggregateTest();
Assert.IsTrue(test.LoadByPrimaryKey(testId));
Assert.AreEqual(Convert.ToDateTime("1902-01-01 01:01:01.000001"), test.HireDate.Value, "MicroSeconds");
}
}
finally
{
// Clean up
test = new AggregateTest();
if (test.LoadByPrimaryKey(testId))
{
test.MarkAsDeleted();
test.Save();
}
}
break;
}
}
public void MySQLNumericTypeTest()
{
MysqltypetestCollection datatypeTestColl = new MysqltypetestCollection();
Mysqltypetest datatypeTest = new Mysqltypetest();
// There is a bug in the 1.0.7 Connector/Net for unsigned types.
// It is fixed in 5.0.3.
switch (datatypeTestColl.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.MySqlClientProvider":
using (esTransactionScope scope = new esTransactionScope())
{
datatypeTest.BigIntType = -1;
datatypeTest.BigIntUType = 1;
datatypeTest.DblType = -1;
datatypeTest.DblUType = 1;
datatypeTest.DecType = (decimal)(-1.5);
datatypeTest.DecUType = (decimal)(1.5);
datatypeTest.FloatType = (float)(-1.5);
datatypeTest.FloatUType = (float)(1.5);
datatypeTest.IntType = -1;
datatypeTest.IntUType = 1;
datatypeTest.MedIntType = -1;
datatypeTest.MedIntUType = 1;
datatypeTest.NumType = (decimal)(-1.5);
datatypeTest.NumUType = (decimal)(1.5);
datatypeTest.RealType = -1.5;
datatypeTest.RealUType = 1.5;
datatypeTest.SmallIntType = -1;
datatypeTest.SmallIntUType = 1;
datatypeTest.TinyIntType = (sbyte)(1);
datatypeTest.TinyIntUType = Convert.ToByte(1);
datatypeTest.Save();
int?tempKey = datatypeTest.Id;
Assert.IsTrue(datatypeTest.LoadByPrimaryKey(tempKey.Value));
datatypeTest.MarkAsDeleted();
datatypeTest.Save();
}
break;
default:
Assert.Ignore("MySQL only");
break;
}
}
public void TestSaveSimpleCollection()
{
int empKey = -1;
EmployeeCollection empColl = new EmployeeCollection();
empColl.es.Connection.Name = "ForeignKeyTest";
Employee emp = new Employee();
emp.es.Connection.Name = "ForeignKeyTest";
try
{
using (esTransactionScope scope = new esTransactionScope())
{
empColl.LoadAll();
emp = empColl.AddNew();
emp.LastName = "LastName";
emp.FirstName = "FirstName";
Order ord = emp.OrderCollectionByEmployeeID.AddNew();
ord.CustID = "10001";
ord.CustSub = "001";
ord.str().OrderDate = "2007-01-01 00:00:00";
empColl.Save();
empKey = emp.EmployeeID.Value;
Assert.AreEqual(1, emp.OrderCollectionByEmployeeID.Count);
Assert.AreEqual(emp.EmployeeID.Value, ord.EmployeeID.Value);
}
}
finally
{
// Clean up
emp = new Employee();
emp.es.Connection.Name = "ForeignKeyTest";
if (emp.LoadByPrimaryKey(empKey))
{
OrderCollection ordColl = emp.OrderCollectionByEmployeeID;
ordColl.MarkAllAsDeleted();
emp.MarkAsDeleted();
emp.Save();
}
}
}
public void DataTypeLargeMoneyMax()
{
OrderItem dataTest = new OrderItem();
dataTest.es.Connection.Name = "ForeignKeyTest";
switch (dataTest.es.Connection.ProviderSignature.DataProviderName)
{
case "EntitySpaces.SqlClientProvider":
try
{
using (esTransactionScope scope = new esTransactionScope())
{
dataTest = new OrderItem();
dataTest.es.Connection.Name = "ForeignKeyTest";
dataTest.OrderID = 3;
dataTest.ProductID = 3;
dataTest.Quantity = 1;
dataTest.UnitPrice = 922337203685477.5807M;
dataTest.Save();
dataTest = new OrderItem();
dataTest.es.Connection.Name = "ForeignKeyTest";
Assert.IsTrue(dataTest.LoadByPrimaryKey(3, 3));
Assert.AreEqual(922337203685477.5807M, dataTest.UnitPrice.Value);
}
}
finally
{
// Clean up
dataTest = new OrderItem();
dataTest.es.Connection.Name = "ForeignKeyTest";
if (dataTest.LoadByPrimaryKey(3, 3))
{
dataTest.MarkAsDeleted();
dataTest.Save();
}
}
break;
default:
Assert.Ignore("Sql Server only");
break;
}
}
protected override void InsertSingleTest(int count)
{
using (var ts = new esTransactionScope())
{
for (int i = 0; i < count; i++)
{
var simplest = new Simplests
{
Id = i,
Value = i
};
simplest.Save();
}
ts.Complete();
}
InstanceCount = count;
}
protected override void CompiledLinqQueryTest(int count)
{
using (var ts = new esTransactionScope())
{
for (int i = 0; i < count; i++)
{
var id = i % InstanceCount;
var query = new SimplestsCollection();
query.Load(_db, _compiledQuery(_db, id));
foreach (var simplest in query)
{
// Doing nothing, just enumerate
}
}
ts.Complete();
}
}
public void TestSaveSelfReference()
{
int empKey = -1;
int supvKey = -1;
Employee emp = new Employee();
emp.es.Connection.Name = "ForeignKeyTest";
Employee supv = new Employee();
supv.es.Connection.Name = "ForeignKeyTest";
try
{
using (esTransactionScope scope = new esTransactionScope())
{
emp.LastName = "LastName";
emp.FirstName = "FirstName";
supv = emp.EmployeeCollectionBySupervisor.AddNew();
supv.LastName = "SupvLast";
supv.FirstName = "SupvFirst";
emp.Save();
empKey = emp.EmployeeID.Value;
supvKey = supv.EmployeeID.Value;
Assert.AreEqual(1, emp.EmployeeCollectionBySupervisor.Count);
Assert.AreEqual(emp.EmployeeID.Value, supv.Supervisor.Value);
}
}
finally
{
// Clean up
emp = new Employee();
emp.es.Connection.Name = "ForeignKeyTest";
if (emp.LoadByPrimaryKey(empKey))
{
EmployeeCollection empColl = emp.EmployeeCollectionBySupervisor;
empColl.MarkAllAsDeleted();
emp.MarkAsDeleted();
emp.Save();
}
}
}
