public void CloneShouldNotBeSameObject()
{
dynamic target = new SimpleRecord();
var actual = target.Clone();
Assert.AreNotSame(target, actual);
}
public void DynamicRecordSetterTest()
{
dynamic target = new SimpleRecord();
target.Name = "Bob";
Assert.AreEqual("Bob", target.Name);
}
public void BulkInsertRecordsWithDifferentColumnsAndFewerColumnsInFirstRecordProperlyInsertsData()
{
DatabaseHelper.Reset();
var db = DatabaseHelper.Open();
dynamic r1 = new SimpleRecord();
r1.FirstName = "Bob";
r1.LastName = "Dole";
dynamic r2 = new SimpleRecord();
r2.FirstName = "Bob";
r2.MiddleInitial = "L";
r2.LastName = "Saget";
db.OptionalColumnTest.Insert(new[] { r1, r2 });
var objs = db.OptionalColumnTest.All().ToList <OptionalColumnTestObject>();
var expected = new[] { new OptionalColumnTestObject("Bob", "Dole"), new OptionalColumnTestObject("Bob", "Saget", "L"), };
Assert.That(objs, Is.EquivalentTo(expected));
}
public void DynamicRecordIndexerTest()
{
dynamic target = new SimpleRecord();
target.Name = "Bob";
Assert.AreEqual("Bob", target["Name"]);
}
private InternalEntityEntry GetEntityEntry(EntityState entityState, SimpleRecord simpleRecord)
{
var mockStateManager = new Mock <IStateManager>();
var mockValueGenerationManager = new Mock <IValueGenerationManager>();
var mockInternalEntityEntryNotifier = new Mock <IInternalEntityEntryNotifier>();
mockStateManager.SetupGet(stateManager => stateManager.ValueGeneration)
.Returns(() => mockValueGenerationManager.Object);
mockStateManager.SetupGet(stateManager => stateManager.Notify)
.Returns(() => mockInternalEntityEntryNotifier.Object);
var model = new Model(new CoreConventionSetBuilder().CreateConventionSet());
EntityType entityType = model.AddEntityType(typeof(SimpleRecord));
entityType.Builder
.GetOrCreateProperties(typeof(SimpleRecord).GetTypeInfo().GetProperties(), ConfigurationSource.Convention);
entityType.Builder
.MongoDb(ConfigurationSource.Convention)
.FromCollection(collectionName: "simpleRecords");
var entityEntry = new InternalClrEntityEntry(mockStateManager.Object, entityType, simpleRecord);
entityEntry.SetEntityState(entityState, acceptChanges: true);
return(entityEntry);
}
/// <summary>
/// 更新关键字
/// </summary>
/// <param name="model">关键字对象</param>
/// <returns>返回true时,表示更新成功；反之,表示更新失败</returns>
/// <remarks>added by jimmy,2015-7-8</remarks>
public ResultModel Update(FloorKeywordModel model)
{
var result = new ResultModel();
try
{
var fk = _database.Db.FloorKeyword.Find(_database.Db.FloorKeyword.KeyWordName == model.KeyWordName.Trim() &&
_database.Db.FloorKeyword.LanguageID == model.LanguageID &&
_database.Db.FloorKeyword.FloorKeywordId != model.FloorKeywordId);
if (fk != null && fk.FloorKeywordId > 0)
{
result.IsValid = false;
result.Messages.Add("Has the same name as the key word, can not repeat the change!");//已存在相同名称的关键字,不能重复修改！
}
else
{
var fc = this._database.Db.FloorKeyword;
dynamic record = new SimpleRecord();
record.FloorKeywordId = model.FloorKeywordId;
record.PlaceCode = model.PlaceCode;
record.KeyWordName = model.KeyWordName;
record.UpdateBy = model.UpdateBy;
record.UpdateDT = model.UpdateDT;
result.Data = fc.UpdateByFloorKeywordId(record);
}
}
catch (System.Exception ex)
{
//todo错误日志
throw;
}
return(result);
}
public void CanConvertWithSubItemToFoo()
{
dynamic source = new SimpleRecord(new Dictionary<string, object> {{"X", "Bar"}, {"Y", new Dictionary<string,object> { {"X", "Quux"}}}});
Foo actual = source;
Assert.AreEqual("Bar", actual.X);
Assert.IsNotNull(actual.Y);
Assert.AreEqual("Quux", actual.Y.X);
}
public static SimpleRecord UpdateSimpleRecord(this SimpleRecord simpleRecord, IQueryable <SimpleRecord> allSimpleRecords, string name)
{
var updatedSr = simpleRecord with {
Name = name
};
return(updatedSr);
}
public void Can_write_simple_record()
{
var simpleRecord = new SimpleRecord();
_testMongoDbContext.Add(simpleRecord);
_testMongoDbContext.SaveChanges(acceptAllChangesOnSuccess: true);
Assert.Equal(simpleRecord, _testMongoDbContext.SimpleRecords.Single());
}
public void CloneShouldNotChangeWhenOriginalChanges()
{
dynamic target = new SimpleRecord();
target.Name = "Foo";
var actual = target.Clone();
target.Name = "Bar";
Assert.AreEqual("Foo", actual.Name);
}
public void CloneShouldContainSameValues()
{
dynamic target = new SimpleRecord();
target.Name = "Foo";
var actual = target.Clone();
Assert.AreNotSame(target, actual);
Assert.AreEqual(target.Name, actual.Name);
}
public void Creates_insert_one_model_for_added_entity()
{
var simpleRecord = new SimpleRecord();
var insertOneModel = GetEntityEntry(EntityState.Added, simpleRecord)
.ToMongoDbWriteModel <SimpleRecord>() as InsertOneModel <SimpleRecord>;
Assert.NotNull(insertOneModel);
}
public void CanConvertToFoo()
{
dynamic source = new SimpleRecord(new Dictionary <string, object> {
{ "X", "Bar" }
});
Foo actual = source;
Assert.AreEqual("Bar", actual.X);
}
public static (SimpleRecord, SimpleRecord) UpdateAndPersistSimpleRecord(this SimpleRecord simpleRecord, IQueryable <SimpleRecord> allSimpleRecords, string name)
{
var updatedSr = simpleRecord with
{
Name = name
};
return(updatedSr, updatedSr);
}
public void CloneShouldNotChangeWhenOriginalChanges()
{
dynamic target = new SimpleRecord();
target.Name = "Foo";
var actual = target.Clone();
target.Name = "Bar";
Assert.AreEqual("Foo", actual.Name);
}
public void CloneShouldContainSameValues()
{
dynamic target = new SimpleRecord();
target.Name = "Foo";
var actual = target.Clone();
Assert.AreNotSame(target, actual);
Assert.AreEqual(target.Name, actual.Name);
}
/// 更新商品品牌状态
/// </summary>
/// <param name="brandID">商品品牌ID</param>
/// <param name="brandState">状态</param>
/// <returns>返回true时,表示更新成功；反之,表示更新失败</returns>
/// <remarks>added by jimmy,2015-7-7</remarks>
public ResultModel UpdateState(int brandID, int brandState)
{
var result = new ResultModel();
var brand = this._database.Db.Brand;
dynamic record = new SimpleRecord();
record.BrandID = brandID;
record.BrandState = brandState;
result.Data = brand.UpdateByBrandID(record);
return(result);
}
public void Creates_delete_one_model_for_deleted_entity()
{
var simpleRecord = new SimpleRecord(ObjectId.GenerateNewId());
var deleteOneModel = GetEntityEntry(EntityState.Deleted, simpleRecord)
.ToMongoDbWriteModel <SimpleRecord>() as DeleteOneModel <SimpleRecord>;
FilterDefinition <SimpleRecord> filter = Builders <SimpleRecord> .Filter.Eq(
record => record.Id, simpleRecord.Id);
Assert.NotNull(deleteOneModel);
Assert.Equal(filter.ToBsonDocument(), deleteOneModel.Filter.ToBsonDocument());
}
/// <summary>
/// 构建规格值 动态记录
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private dynamic BuildAttributeItemValueReocrd(SKU_AttributeValuesModel model)
{
dynamic valueRecord = new SimpleRecord();
valueRecord.ValueId = model.ValueId;
valueRecord.DisplaySequence = model.DisplaySequence;
valueRecord.ValueStr = model.ValueStr;
valueRecord.ImageUrl = model.ImageUrl;
valueRecord.ValuesGroup = model.ValuesGroup;
return(valueRecord);
}
/// <summary>
/// 更新排序位置
/// </summary>
/// <param name="SalesProductId">广告促销商品Id</param>
/// <param name="place">位置</param>
/// <returns>返回true时,表示更新成功；反之,表示更新失败</returns>
/// <remarks>added by jimmy,2015-7-13</remarks>
public ResultModel UpdatePlace(long SalesProductId, int place)
{
var result = new ResultModel();
var fc = this._database.Db.SalesProduct;
dynamic record = new SimpleRecord();
record.SalesProductId = SalesProductId;
record.Sorts = place;
result.Data = fc.UpdateBySalesProductId(record);
return(result);
}
/// <summary>
/// 更新排序位置
/// </summary>
/// <param name="floorKeywordId">关键字管理Id</param>
/// <param name="place">位置</param>
/// <returns>返回true时,表示更新成功；反之,表示更新失败</returns>
/// <remarks>added by jimmy,2015-7-27</remarks>
public ResultModel UpdatePlace(long productImageId, int place)
{
var result = new ResultModel();
var fc = this._database.Db.ProductImage;
dynamic record = new SimpleRecord();
record.productImageId = productImageId;
record.place = place;
result.Data = fc.UpdateByProductImageId(record);
return(result);
}
/// <summary>
/// 更新排序位置
/// </summary>
/// <param name="floorKeywordId">关键字管理Id</param>
/// <param name="place">位置</param>
/// <returns>返回true时,表示更新成功；反之,表示更新失败</returns>
/// <remarks>added by jimmy,2015-7-13</remarks>
public ResultModel UpdatePlace(long floorKeywordId, int place)
{
var result = new ResultModel();
var fc = this._database.Db.FloorKeyword;
dynamic record = new SimpleRecord();
record.FloorKeywordId = floorKeywordId;
record.Sorts = place;
result.Data = fc.UpdateByFloorKeywordId(record);
return(result);
}
public void TestUpdate()
{
dynamic record = new SimpleRecord();
record.Id = 4;
record.Email = "quux";
Database.Default.Users.Update(record);
var element = _mockAdapter.Data.Element("Users").Elements().Where(e => e.Attribute("Id") != null && e.Attribute("Id").Value == "4").Single();
Assert.AreEqual("quux", element.Attribute("Email").Value);
}
/// <summary>
/// 更新楼层显示分类
/// </summary>
/// <param name="model">楼层显示分类对象</param>
/// <returns>返回true时,表示更新成功；反之,表示更新失败</returns>
/// <remarks>added by jimmy,2015-7-13</remarks>
public ResultModel Update(FloorCategoryModel model)
{
var result = new ResultModel();
var fc = this._database.Db.FloorCategory;
dynamic record = new SimpleRecord();
record.FloorCategoryId = model.FloorCategoryId;
record.CategoryId = model.CategoryId;
record.DCategoryId = model.DCategoryId;
result.Data = fc.UpdateByFloorCategoryId(record);
return(result);
}
public void TestUpdateWithDynamicObject()
{
dynamic record = new SimpleRecord();
record.Id = 1;
record.Name = "Steve";
record.Age = 50;
_db.Users.Update(record);
GeneratedSqlIs("update [dbo].[Users] set [Name] = @p1, [Age] = @p2 where [dbo].[Users].[Id] = @p3");
Parameter(0).Is("Steve");
Parameter(1).Is(50);
Parameter(2).Is(1);
}
public void DynamicRecordDictionaryConstructorTest()
{
IDictionary <string, object> data = new Dictionary <string, object>
{
{ "Name", "Bob" },
{ "Age", 42 }
};
dynamic target = new SimpleRecord(data);
Assert.AreEqual("Bob", target.Name);
Assert.AreEqual(42, target.Age);
}
public void DynamicCastTest()
{
dynamic target = new SimpleRecord();
target.Name = "Bob";
target.Age = 42;
User user = target;
Assert.AreEqual("Bob", user.Name);
Assert.AreEqual(42, user.Age);
}
public void DynamicCastShouldReturnSameObjectOnSubsequentCalls()
{
dynamic target = new SimpleRecord();
target.Name = "Bob";
target.Age = 42;
User user1 = target;
User user2 = target;
Assert.AreSame(user1, user2);
}
/// <summary>更新当前用户的数据库购物车.</summary>
/// <remarks></remarks>
/// <author>Yun 2015-04-19 10:16:35</author>
/// <param name="lstGoodsInfoNew">The LST goods information new.</param>
/// <returns>Boolean.</returns>
public Boolean updateCartInDb(List <ShoppingCartModel> lstGoodsInfoNew, string userid = null)
{
lstGoodsInfoNew = lstGoodsInfoNew.Distinct(new GoodsInfoEqualityComparer()).ToList();
//YH_User u = _database.Db.YH_User.FindByUserID(userid);
var Index = 0;
var result = new ResultModel();
foreach (var newGood in lstGoodsInfoNew)
{
using (var transaction = _database.Db.BeginTransaction())
{
var resultq = new ResultModel
{
Data =
_database.Db.ShoppingCart.All()
.Select(_database.Db.ShoppingCart.ShoppingCartId)
.Where(_database.Db.ShoppingCart.ProductID == newGood.ProductID && _database.Db.ShoppingCart.SKU_ProducId == newGood.SKU_ProducId && _database.Db.ShoppingCart.UserID == userid)
.ToList <ShoppingCartModel>()
};
var id = resultq.Data.Count > 0 ? resultq.Data[0].ShoppingCartId : null;
if (id != null)
{
// 更新
dynamic updateRecord = new SimpleRecord();
updateRecord.ShoppingCartId = id;
updateRecord.ProductID = newGood.ProductID;
updateRecord.SKU_ProducId = newGood.SKU_ProducId;
updateRecord.UserID = userid;
updateRecord.Quantity = newGood.Quantity;
updateRecord.IsCheck = newGood.IsCheck;
transaction.ShoppingCart.UpdateByShoppingCartId(updateRecord);
}
else
{
//添加
dynamic insertRecord = new SimpleRecord();
insertRecord.ShoppingCartId = MemCacheFactory.GetCurrentMemCache().Increment("commonId");
insertRecord.ProductID = newGood.ProductID;
insertRecord.SKU_ProducId = newGood.SKU_ProducId;
insertRecord.UserID = userid;
insertRecord.Quantity = newGood.Quantity;
insertRecord.CartDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
insertRecord.IsCheck = newGood.IsCheck;
transaction.ShoppingCart.Insert(insertRecord);
}
transaction.Commit();
}
}
return(result.IsValid);
}
public void CanConvertWithSubItemToFoo()
{
dynamic source = new SimpleRecord(new Dictionary <string, object> {
{ "X", "Bar" }, { "Y", new Dictionary <string, object> {
{ "X", "Quux" }
} }
});
Foo actual = source;
Assert.AreEqual("Bar", actual.X);
Assert.IsNotNull(actual.Y);
Assert.AreEqual("Quux", actual.Y.X);
}
public void TestUpdateWithDynamicObject()
{
dynamic record = new SimpleRecord();
record.Id = 1;
record.Name = "Steve";
record.Age = 50;
_db.Users.Update(record);
GeneratedSqlIs("update [dbo].[Users] set [Name] = @p1, [Age] = @p2 where [dbo].[Users].[Id] = @p3");
Parameter(0).Is("Steve");
Parameter(1).Is(50);
Parameter(2).Is(1);
}
public void Should_not_serialize_null_or_empty_strings(string value)
{
var bsonClassMap = new BsonClassMap <SimpleRecord>();
BsonMemberMap bsonMemberMap = bsonClassMap.MapMember(cr => cr.StringProperty);
var ignoreNullOrEmptyStringsConvention = new IgnoreNullOrEmptyStringsConvention();
ignoreNullOrEmptyStringsConvention.Apply(bsonMemberMap);
var simpleRecord = new SimpleRecord
{
StringProperty = value
};
Assert.Equal(!string.IsNullOrEmpty(value), bsonMemberMap.ShouldSerialize(simpleRecord, simpleRecord.StringProperty));
}
/// <summary>
/// 更新部门
/// </summary>
/// <param name="model">部门模型</param>
/// <returns>是否修改成功</returns>
public ResultModel UpdateAC_Department(AC_DepartmentModel model)
{
var result = new ResultModel();
dynamic updateRecord = new SimpleRecord();
updateRecord.ID = model.ID;
updateRecord.DeptName = model.DeptName;
updateRecord.IsActive = model.IsActive;
updateRecord.OrderNumber = model.OrderNumber;
updateRecord.UpdateBy = model.UpdateBy;
updateRecord.UpdateDT = model.UpdateDT;
_database.Db.AC_Department.UpdateByID(updateRecord);
return(result);
}
public DictionaryRecordDialog(DictionaryKind dictionary, SimpleRecord record)
{
InitializeComponent();
DictionaryRecordViewModel viewModel =
new DictionaryRecordViewModel(dictionary, this, record);
InputBoxes.ItemsSource = GenerateContent(dictionary, record);
viewModel.MessageBoxDisplayRequested += (sender, e) =>
{
CustomMessageBox.Show(e.Title, e.Text);
};
DataContext = viewModel;
}
public void CanConvertWithSubItemAndCollectionToFoo()
{
dynamic source =
new SimpleRecord(new Dictionary<string, object>
{{"X", "Bar"},
{"Y", new Dictionary<string, object> {{"X", "Quux"}}},
{"Z", new[] { new Dictionary<string, object> {{"X", "Wibble"}}}}
});
Foo actual = source;
Assert.AreEqual("Bar", actual.X);
Assert.IsNotNull(actual.Y);
Assert.AreEqual("Quux", actual.Y.X);
Assert.IsNotNull(actual.Z);
Assert.AreEqual(1, actual.Z.Count);
Assert.AreEqual("Wibble", actual.Z.Single().X);
}
public void TestUpdateWithDynamicObjectsAndOriginalValues()
{
dynamic newRecord = new SimpleRecord();
newRecord.Id = 1;
newRecord.Name = "Steve";
newRecord.Age = 50;
dynamic originalRecord = new SimpleRecord();
originalRecord.Id = 2;
originalRecord.Name = "Steve";
originalRecord.Age = 50;
_db.Users.Update(new[] {newRecord}, new[] {originalRecord});
GeneratedSqlIs("update [dbo].[Users] set [Id] = @p1 where [dbo].[Users].[Id] = @p2");
Parameter(0).Is(1);
Parameter(1).Is(2);
}
public void TestUpdateByWithDynamicObjectList()
{
dynamic record1 = new SimpleRecord();
record1.Id = 1;
record1.Name = "Steve";
record1.Age = 50;
dynamic record2 = new SimpleRecord();
record2.Id = 2;
record2.Name = "Bob";
record2.Age = 42;
_db.Users.UpdateById(new[] { record1, record2 });
GeneratedSqlIs("update [dbo].[Users] set [Name] = @p1, [Age] = @p2 where [dbo].[Users].[Id] = @p3");
Parameter(0).Is("Bob");
Parameter(1).Is(42);
Parameter(2).Is(2);
}
public void BulkInsertRecordsWithDifferentColumnsProperlyInsertsData()
{
DatabaseHelper.Reset();
var db = DatabaseHelper.Open();
dynamic r1 = new SimpleRecord();
r1.FirstName = "Bob";
r1.LastName = "Dole";
dynamic r2 = new SimpleRecord();
r2.FirstName = "Bob";
r2.MiddleInitial = "L";
r2.LastName = "Saget";
db.OptionalColumnTest.Insert(new[] { r2, r1 });
var objs = db.OptionalColumnTest.All().ToList<OptionalColumnTestObject>();
var expected = new[] {new OptionalColumnTestObject("Bob", "Dole"), new OptionalColumnTestObject("Bob", "Saget", "L"),};
Assert.That(objs, Is.EquivalentTo(expected));
}
public void TestUpdateByWithDynamicObject()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
dynamic record = new SimpleRecord();
record.Id = 1;
record.Name = "Steve";
record.Age = 50;
database.foo.Users.UpdateById(record);
Assert.AreEqual("update [foo].[Users] set [Name] = @p1, [Age] = @p2 where [foo].[Users].[Id] = @p3".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual("Steve", mockDatabase.Parameters[0]);
Assert.AreEqual(50, mockDatabase.Parameters[1]);
Assert.AreEqual(1, mockDatabase.Parameters[2]);
}
public void CloneShouldNotBeSameObject()
{
dynamic target = new SimpleRecord();
var actual = target.Clone();
Assert.AreNotSame(target, actual);
}
public void CastToGenericCreatesTypedListWithSubTypes()
{
var firstRecord = new SimpleRecord(new Dictionary<string, object>
{
{ "Data", "First" },
{ "List", new List<string> { "First-One", "First-Two" } }
});
var list = new SimpleResultSet(new List<dynamic> { firstRecord });
var result = list.Cast<TestType2>().First();
Assert.AreEqual(2, result.List.Count);
}
public void TestUpdateWithDynamicObjectAndOriginalValues()
{
dynamic newRecord = new SimpleRecord();
newRecord.Id = 1;
newRecord.Name = "Steve-o";
newRecord.Age = 50;
dynamic originalRecord = new SimpleRecord();
originalRecord.Id = 1;
originalRecord.Name = "Steve";
originalRecord.Age = 50;
_db.Users.Update(newRecord, originalRecord);
GeneratedSqlIs("update [dbo].[Users] set [Name] = @p1 where ([dbo].[Users].[Id] = @p2 and [dbo].[Users].[Name] = @p3)");
Parameter(0).Is("Steve-o");
Parameter(1).Is(1);
Parameter(2).Is("Steve");
}
public void TestUpdate()
{
dynamic record = new SimpleRecord();
record.Id = 4;
record.Email = "quux";
Database.Default.Users.Update(record);
var element = _mockAdapter.Data.Element("Users").Elements().Where(e => e.Attribute("Id") != null && e.Attribute("Id").Value == "4").Single();
Assert.AreEqual("quux", element.Attribute("Email").Value);
}
public void TestUpdateWithDynamicObject()
{
var mockDatabase = new MockDatabase();
dynamic database = CreateDatabase(mockDatabase);
dynamic record = new SimpleRecord();
record.Id = 1;
record.Name = "Steve";
record.Age = 50;
using (var transaction = database.BeginTransaction())
{
transaction.Users.Update(record);
transaction.Commit();
}
Assert.AreEqual("update [dbo].[Users] set [Name] = @p1, [Age] = @p2 where [dbo].[Users].[Id] = @p3".ToLowerInvariant(), mockDatabase.Sql.ToLowerInvariant());
Assert.AreEqual("Steve", mockDatabase.Parameters[0]);
Assert.AreEqual(50, mockDatabase.Parameters[1]);
Assert.AreEqual(1, mockDatabase.Parameters[2]);
Assert.IsTrue(MockDbTransaction.CommitCalled);
}
public void CanConvertToFoo()
{
dynamic source = new SimpleRecord(new Dictionary<string, object> {{"X", "Bar"}});
Foo actual = source;
Assert.AreEqual("Bar", actual.X);
}
