public void BasicCrud()
{
using (var trans = DataSource.BeginTransaction())
{
var repo = new Repository<Employee, int>(trans, EmployeeTableName);
var emp1 = new Employee() { FirstName = "Tom", LastName = "Jones", Title = "President" };
var echo1 = repo.Insert(emp1);
Assert.AreNotEqual(0, echo1.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp1.FirstName, echo1.FirstName, "FirstName");
Assert.AreEqual(emp1.LastName, echo1.LastName, "LastName");
Assert.AreEqual(emp1.Title, echo1.Title, "Title");
echo1.MiddleName = "G";
repo.Update(echo1);
var emp2 = new Employee() { FirstName = "Lisa", LastName = "Green", Title = "VP Transportation", ManagerKey = echo1.EmployeeKey };
var echo2 = repo.Insert(emp2);
Assert.AreNotEqual(0, echo2.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp2.FirstName, echo2.FirstName, "FirstName");
Assert.AreEqual(emp2.LastName, echo2.LastName, "LastName");
Assert.AreEqual(emp2.Title, echo2.Title, "Title");
Assert.AreEqual(emp2.ManagerKey, echo2.ManagerKey, "ManagerKey");
var list = repo.GetAll();
Assert.IsTrue(list.Any(e => e.EmployeeKey == echo1.EmployeeKey), "Employee 1 is missing");
Assert.IsTrue(list.Any(e => e.EmployeeKey == echo2.EmployeeKey), "Employee 2 is missing");
var get1 = repo.Get(echo1.EmployeeKey.Value);
Assert.AreEqual(echo1.EmployeeKey, get1.EmployeeKey);
var whereSearch1 = repo.Query("FirstName = @FN", new { FN = "Tom" });
Assert.IsTrue(whereSearch1.Any(x => x.EmployeeKey == echo1.EmployeeKey), "Emp1 should have been returned");
Assert.IsTrue(whereSearch1.All(x => x.FirstName == "Tom"), "Checking for incorrect return values");
var whereSearch2 = repo.Query(new { FirstName = "Tom" });
Assert.IsTrue(whereSearch2.Any(x => x.EmployeeKey == echo1.EmployeeKey), "Emp1 should have been returned");
Assert.IsTrue(whereSearch2.All(x => x.FirstName == "Tom"), "Checking for incorrect return values");
repo.Delete(echo2.EmployeeKey.Value);
repo.Delete(echo1.EmployeeKey.Value);
var list2 = repo.GetAll();
Assert.AreEqual(list.Count - 2, list2.Count);
trans.Commit();
}
}
public void DeleteComment(Comment comment)
{
using (var repository1 = new Repository())
{
repository1.Delete(comment);
}
}
public ActionResult About()
{
// Generiskt Repository - Här skapas ett repository för Category
// Repositoryt kräver typer som implementerar IEntity
Repository<Category> categoryRepo = new Repository<Category>();
// Samtliga metoder som finns med i det generiska repositoriet
var categories = categoryRepo.FindAll();
var filteredCategories = categoryRepo.FindAll(c => c.Name.Contains("sport"));
var category = categoryRepo.FindByID(0);
category.Name = "New Name!";
categoryRepo.Save(category);
categoryRepo.Delete(category);
ProductRepository productRepo = new ProductRepository();
var products = productRepo.FindAll(); // + övriga "grund"-metoder
// Metoder implementerade i ProductRepository:
var productsForCategory = productRepo.FindProductsByCategoryID(0);
var productsWithEmptyName = productRepo.FindAll(ProductRepository
.FilterProductsWithEmptyDescription);
return View();
}
public void DeleteArticle(Article article)
{
using (var repository1 = new Repository())
{
repository1.Delete(article);
}
}
static void Main(string[] args)
{
var soapShopDb = new SoapShopDb();
var component = new Repository(soapShopDb);
// Adding some entity
component.Add(new Customer { CustomerName = "Nata", CustomerPhone = "679011198" });
component.Save();
component.Add(new SoapProduct { Tittle = "Eucalyptus", Mass = 100, Price = 25.2M });
component.Save();
// Delating some entity
var comp = soapShopDb.Set<Customer>().FirstOrDefault(i => i.CustomerName == "Nata");
component.Delete(comp);
component.Save();
// Reading some entity
var list = component.Get<Customer>();
foreach (var item in list)
{
Console.WriteLine(item.Id + " " + item.CustomerName + " " + item.CustomerPhone + "\n");
}
// Find one
var comp2 = component.Get<Customer>(3);
Console.WriteLine(comp2.CustomerName);
}
public void Delete(string slug)
{
using (var repository = new Repository<Entry>())
{
var entry = repository.Find(slug);
repository.Delete(entry);
}
}
public void Should_throw_ArgumentNullException_if_null_passed_in()
{
using (var context = new RepositoryTestDataContext())
{
var repo = new Repository<Order>(context);
Assert.Throws<ArgumentNullException>(() => repo.Delete(null));
}
}
public void SetUp()
{
//_repository = A.Fake<IRepository<Category>>();
_repository = new Repository<Category>(() => new JudgifyContext());
foreach (var category in _repository.GetAll())
{
_repository.Delete(category);
}
}
public void DeleteEducation()
{
var repo = new Repository<EducationModel>(DbCollection.Education);
var contacts = repo.Gets().Where(m => m.UserId == "5709a5b24a549a1a9873a19b");
foreach (var item in contacts)
{
repo.Delete(item.Id);
}
}
public void TestDeleteWorks()
{
Repository repository = new Repository(new SqlConnectionDev());
Club club = new Club();
club.clubId = 1;
bool result = repository.Delete(club);
Assert.IsNotNull(result);
}
internal void DeleteTestAggregate(TestAggregate aggregate)
{
var repository = new Repository<TestAggregate, TestEntity>();
using (var unitOfWork = new UnitOfWorkFactory(TestSettings.BoilerMongoConfiguration).CreateUnitOfWork())
{
repository.UnitOfWork = unitOfWork;
repository.Delete(aggregate);
unitOfWork.Commit();
}
}
public void ShouldDelete()
{
// arrange
Repository<string> r = new Repository<string>(m_session.Object);
string s = "this";
// act
r.Delete(s);
// assert
m_session.Verify(x => x.Delete((object)s));
}
public ActionResult Delete(string id, AdminSetting model)
{
try
{
var repo = new Repository<AdminSetting>(DbCollection.AdminSetting);
repo.Delete(new ObjectId(id));
return RedirectToAction("Index");
}
catch
{
return View();
}
}
public void Should_Delete_An_Entity()
{
var repository = new Repository<Author>();
var author = repository.Insert(new Author()
{
FirstName = "Bruce",
LastName = "Wayne"
});
repository.Delete(author.Id);
author = repository.GetById(author.Id);
Assert.IsNull(author);
}
public void Add_User_Fails_If_UserName_Not_Unique()
{
string userName = Guid.NewGuid().ToString();
User user1 = new User
{
FirstName = "First",
LastName = "User1",
UserName = userName,
Email = "*****@*****.**"
};
User user2 = new User
{
FirstName = "Second",
LastName = "User2",
UserName = userName,
Email = "*****@*****.**"
};
NHibernateHelper helper = new NHibernateHelper();
// create
using (UnitOfWork unitOfWork = new UnitOfWork(helper.SessionFactory))
{
Repository<User> userRepo = new Repository<User>(unitOfWork.Session);
Assert.IsTrue(userRepo.Add(user1));
unitOfWork.Commit();
}
try
{
using (UnitOfWork unitOfWork = new UnitOfWork(helper.SessionFactory))
{
Repository<User> userRepo = new Repository<User>(unitOfWork.Session);
Assert.IsTrue(userRepo.Add(user2));
unitOfWork.Commit();
}
}
catch (NHibernate.Exceptions.GenericADOException ex)
{
// expected this
}
finally
{
// delete
using (UnitOfWork unitOfWork = new UnitOfWork(helper.SessionFactory))
{
Repository<User> userRepo = new Repository<User>(unitOfWork.Session);
Assert.IsTrue(userRepo.Delete(user1));
unitOfWork.Commit();
}
}
}
public void Should_delete_the_record_when_given_a_valid_entity_on_the_same_data_context()
{
using (var context = new RepositoryTestDataContext())
{
var repo = new Repository<Order>(context);
var original = repo.GetById(10287);
repo.Delete(original);
}
Assert.IsTrue(CheckRecordDeleted());
TestScriptHelper.InsertDeletedRecord();
}
public void Be_Able_To_Delete_Entity()
{
var oldValue = SetHelperFactory(_mockFactory.Object);
var repo = new Repository();
var cust = new Customer {Int32Id = 4};
repo.Delete(cust);
_mockSession.Verify(ms => ms.Delete(cust));
SetHelperFactory(oldValue);
repo.Dispose();
}
public void InsertWithDictionary()
{
var repo = new Repository<Employee, int>(StrictDataSource, EmployeeTableName);
var emp1 = new Dictionary<string, object>() { { "FirstName", "Tom" }, { "LastName", "Jones" }, { "Title", "President" } };
var echo1 = repo.Insert(emp1);
Assert.AreNotEqual(0, echo1.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp1["FirstName"], echo1.FirstName, "FirstName");
Assert.AreEqual(emp1["LastName"], echo1.LastName, "LastName");
Assert.AreEqual(emp1["Title"], echo1.Title, "Title");
repo.Delete(echo1.EmployeeKey.Value);
}
private static void NoDecoratorNoProxy()
{
Console.WriteLine("***\r\n Begin program - no logging\r\n");
IRepository<Customer> customerRepository =
new Repository<Customer>();
var customer = new Customer
{
Id = 1,
Name = "Customer 1",
Address = "Address 1"
};
customerRepository.Add(customer);
customerRepository.Delete(customer);
Console.WriteLine("\r\nEnd program - no logging\r\n***");
Console.ReadLine();
}
public void CanDelete()
{
using (var database = new MongoDbTest())
{
var repository = new Repository<ToDoItem>(database.Database);
var item = new ToDoItem() { Item = "Item", Title = "Title" };
item = repository.Insert(item);
Assert.NotNull(item);
Assert.NotNull(repository.Delete(item));
Assert.Null(repository.ById(item.Id));
}
}
public void Join_example_with_transaction_insert()
{
Repository.DefaultConnectionString = @"Data source=.\SQLEXPRESS;Initial Catalog=WeenyMapper;Trusted_Connection=true";
Repository.DefaultConvention = new BlogConvention();
var myBlog = new Blog("My blog");
var steve = new User("Steve", "password");
var post1 = new BlogPost("Title 1", "Content 1 goes here") { Blog = myBlog, Author = steve };
var post2 = new BlogPost("Title 2", "Content 2 goes here") { Blog = myBlog, Author = steve };
var post3 = new BlogPost("Title 3", "Content 3 goes here") { Blog = myBlog, Author = steve };
var post4 = new BlogPost("Title 4", "Content 4 goes here") { Blog = myBlog, Author = steve };
using (var repository = new Repository())
{
using (var transaction = repository.BeginTransaction())
{
repository.Insert(myBlog);
repository.Insert(steve);
repository.Insert(post1, post2, post3, post4);
transaction.Commit();
}
repository.Update<BlogPost>()
.Set(x => x.Title, "Updated title 2")
.Where(x => x.Id == post2.Id)
.Execute();
repository.Delete<BlogPost>()
.Where(x => x.Id == post3.Id || x.Title == "Title 4")
.Execute();
var actualBlog = repository.Find<Blog>().Where(x => x.Id == myBlog.Id)
.Join(x => x.Posts, x => x.Blog)
.OrderBy<BlogPost>(x => x.Title)
.Execute();
Assert.AreEqual("My blog", actualBlog.Name);
Assert.AreEqual(2, actualBlog.Posts.Count);
Assert.AreEqual("Title 1", actualBlog.Posts[0].Title);
Assert.AreEqual("Updated title 2", actualBlog.Posts[1].Title);
}
}
public void DatabaseAccess()
{
try
{
using(var db = new WeddingDb())
{
Repository<Group> repository = new Repository<Group>(db);
var t = repository.Find(m => m.Id == 3).FirstOrDefault();
repository.Delete(t);
//var list = d
}
}
catch (Exception ex)
{
}
}
public string Delete(string argument)
{
AjaxResult ajaxResult = new AjaxResult();
string errorMsg = string.Empty;
DoResult doResult = DoResult.Failed;
string actionMessage = string.Empty;
try
{
if (!string.IsNullOrWhiteSpace(argument))
{
string roleID = argument;
IRepository<string> repository = new Repository<string>();
IDictionary<string, object> parameters = new Dictionary<string, object>();
parameters.SafeAdd("RoleID", roleID);
IList<ObjectRole> objectRoleList = repository.FindAll<ObjectRole>(parameters);
if (objectRoleList.Count == 0)
{
repository.Delete<Role>(roleID);
repository.ExecuteSql<RolePrivilege>(string.Format("Delete from AC_RolePrivilege where RoleID='{0}'", roleID));
doResult = DoResult.Success;
actionMessage = RemarkAttribute.GetEnumRemark(doResult);
}
else
{
doResult = DoResult.Failed;
actionMessage = "请先解除该角色与操作员的关联！";
}
ajaxResult.RetValue = CurrentId;
ajaxResult.PromptMsg = actionMessage;
}
ajaxResult.Result = doResult;
}
catch (Exception ex)
{
actionMessage = RemarkAttribute.GetEnumRemark(doResult);
log.Error(actionMessage, ex);
}
return JsonConvert.SerializeObject(ajaxResult);
}
public void Delete_ProductIsDeleted_NoProductsInDatabase()
{
var testProduct = new Product("Kildevand", 18, true);
using (var context = new CashRegisterContext())
{
context.Products.Add(testProduct);
context.SaveChanges();
}
using (var context = new CashRegisterContext())
{
var uut = new Repository<Product>(context);
uut.Delete(testProduct);
context.SaveChanges();
var result = context.Products.AsEnumerable();
Assert.That(result, Is.Empty);
}
}
public void add_user_returns_valid_user_with_id ()
{
var dbName = "quad";
var connectionString = "mongodb://localhost";
var server = MongoDB.Driver.MongoServer.Create (connectionString);
var dStore = new Repository (new RepositoryConfiguration () {DBName = dbName,
ConnectionString=connectionString,Server = server});
var user = dStore.Add(new User () { Email="*****@*****.**" });
Assert.IsNotNull (user.Id);
var newUser = dStore.GetById<User>(user.Id);
Assert.IsNotNull (user);
Assert.AreEqual (user.Email, newUser.Email);
Assert.AreEqual (user.Id, newUser.Id);
dStore.Delete<User>(user.Id);
Assert.IsNull (dStore.GetById<User>(user.Id));
}
public MessageResultDto DeleteGroup(Guid id)
{
var result = new MessageResultDto();
using (ISession session = _sessionFactory.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
IRepository<Group> groupRepository = new Repository<Group>(session);
var group = groupRepository.FindOne(id);
if (group.Users.Count > 0)
{
result.ErrorMessage("Group has got users registered. Please remove the user(s) from the group first.");
}
else
{
groupRepository.Delete(id);
transaction.Commit();
result.Message = "Group deleted successfully";
}
}
return result;
}
public void Run()
{
using (var sut = new Repository(SERVER, TokenRepository.LoadFrom("ftp.credentials.txt"), "AppZwitschern_TweetStore"))
{
Console.WriteLine("storing...");
var versandaufträge = new[]
{
new Versandauftrag()
{Id = "1", Termin = new DateTime(2012, 3, 26, 12, 21, 0), Text = "a"},
new Versandauftrag()
{Id = "2", Termin = new DateTime(2011, 10, 27, 14, 17, 0), Text = "b"}
,
null
};
var versandt = false;
versandaufträge.ToList().ForEach(_ => sut.Store(_, () => versandt = true));
Console.WriteLine(" stored!");
Assert.IsTrue(versandt);
Console.WriteLine("listing...");
var filenames = new List<string>();
sut.List(filenames.Add);
filenames.ForEach(fn => Console.WriteLine("list {0}", fn));
Assert.AreEqual(3, filenames.Count);
Console.WriteLine("loading...");
var results = new List<Versandauftrag>();
filenames.ForEach(fn => sut.Load(fn, results.Add));
Console.WriteLine(" loaded!");
Assert.That(results.Select(_ => _ == null ? null : _.Id).ToArray(),
Is.EquivalentTo(new[] {"1", "2", null}));
Console.WriteLine("deleting...");
var deleted = false;
results.ForEach(va => sut.Delete(va, () => deleted = true));
Console.WriteLine(" deleted!");
Assert.IsTrue(deleted);
}
}
public void DBBasicOperationValidation()
{
// Setups container and session factory
Program.SetSessionFactory(true);
// Creates new user
var user = UserFactory.MockUser();
var userRepository = new Repository<User>();
// Fetches user from db
var fetchedUser = userRepository.Get(user.Id);
// Checks if they are equal
Assert.Equal(user.Id, fetchedUser.Id);
Assert.Equal(user.Email, fetchedUser.Email);
// Deletes created user
userRepository.Delete(user);
// Checks that user is deleted
Assert.Throws<NHibernate.ObjectNotFoundException>(() => userRepository.Get(user.Id));
}
public void Run()
{
const string TEST_REPO_PATH = @"c:\appzwitschern";
if (Directory.Exists(TEST_REPO_PATH)) Directory.Delete(TEST_REPO_PATH, true);
var repo = new Repository(TEST_REPO_PATH);
var va1 = new Versandauftrag() { Text = "a", Termin = new DateTime(2012, 6, 21), Id = Guid.NewGuid().ToString() };
repo.Store(va1, null);
var endOfStream = false;
var va2 = new Versandauftrag() { Text = "b", Termin = new DateTime(2012, 6, 20), Id = Guid.NewGuid().ToString() };
repo.Store(va2, null);
repo.Store(null, () => endOfStream = true);
Assert.IsTrue(endOfStream);
endOfStream = false;
var results = new List<string>();
repo.List(results.Add);
Assert.That(results.Select(fn => fn==null ? null : Path.GetFileName(fn)).ToArray(),
Is.EquivalentTo(new[] { va1.Id + ".tweet", va2.Id + ".tweet", null }));
var resultVAs = new List<Versandauftrag>();
foreach(var fn in results)
repo.Load(fn, resultVAs.Add);
Assert.That(resultVAs.Select(_ => _==null ? null : _.Text).ToArray(),
Is.EquivalentTo(new[]{"a", "b", null}));
resultVAs.ForEach(va => repo.Delete(va, () => endOfStream = true));
Assert.AreEqual(0, Directory.GetFiles(TEST_REPO_PATH).Length);
Assert.IsTrue(endOfStream);
Directory.Delete(TEST_REPO_PATH);
}
public void Delete(int id)
{
_repository.Delete(id);
}
public ActionResult DeleteConfirmed(int id)
{
Repository.Delete(id);
return(RedirectToAction("ListResponse"));
}
protected override void ExecuteCommand()
{
Repository
.Delete(_recipe)
.SaveChanges();
}
public override void Delete(CategoryInfo record)
{
Repository.Delete(record);
LanguageCode = record.LanguageCode;
ResetCache();
}
public void Delete(T entity)
{
_repository.Delete(entity);
_uow.SaveChanges();
}
public IActionResult Delete(int id)
{
prijave.Delete(id);
return(Ok());
}
public void Delete()
{
Repository.Delete(this);
}
public int Delete(Person _Person)
{
return(PersonDaoRepository.Delete(_Person));
}
public void Delete(data.Solicitudes t)
{
_repository.Delete(t);
_repository.Commit();
}
public void DeleteEmployee(int id)
{
Repository.Delete(id);
}
protected override void Execute()
{
Repository.Delete(Entity);
Repository.SaveChanges();
}
/// <summary>
/// 任务删除
/// </summary>
/// <param name="conn">数据库连接</param>
/// <param name="taskID">任务ID</param>
/// <param name="trans">事务</param>
internal bool Delete(IDbConnection conn, long taskID, IDbTransaction trans)
{
return(Repository.Delete <TaskEntity>(conn, taskID, trans));
}
protected override void Delete(Guid id)
{
Repository.Delete(id);
}
public virtual bool Delete(long id) => Repository.Delete(id);
public void DeleteByDataId(int dataId)
{
_repository.Delete(Q.Where(Attr.DataId, dataId));
}
public void Delete(Product product)
{
Repository.Delete(product);
CacheService.Remove(CacheKey(product.Id));
}
private void DeleteCategory(Category category)
{
Categories.Remove(category);
Task.Run(() => _categoryRepository.Delete(category));
}
private void RemoveRecord(Record tx)
{
Repository.Delete <Record>("Broadcasts", tx.Transaction.GetHash().ToString());
Repository.UpdateOrInsert <Transaction>("CachedTransactions", tx.Transaction.GetHash().ToString(), tx.Transaction, (a, b) => a);
}
public bool Delete(Invoice invoice)
{
return(Repository.Delete(invoice));
}
public virtual int Delete(T obj)
{
return(repo.Delete(obj));
}
public int DeleteBook(int id)
{
_booksRepository.Delete(id);
return(id);
}
public static void Delete(int teamID) => Repository.Delete <Team>(teamID);
public void SBCRUDDelete()
{
rps.Delete((SBSprint)SBCRUDInput);
}
public string Delete(string id)
{
_supplier.Delete(id);
return("success");
}
public void Delete(data.Suppliers t)
{
_repository.Delete(t);
_repository.Commit();
}
public virtual void Delete(T entity)
{
_repository.Delete(entity);
}
public void Delete(data.AspNetRoles t)
{
_repo.Delete(t);
_repo.Commit();
}
public int Delete(int userId)
{
var result = Repository.Delete(userId);
return(result);
}
public void Delete(data.Persona t)
{
_repository.Delete(t);
_repository.Commit();
}
public void UpdateWithDictionary()
{
var repo = new Repository<Employee, int>(StrictDataSource, EmployeeTableName);
var emp1 = new Dictionary<string, object>() { { "FirstName", "Tom" }, { "LastName", "Jones" }, { "Title", "President" } };
var echo1 = repo.Insert(emp1);
Assert.AreNotEqual(0, echo1.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp1["FirstName"], echo1.FirstName, "FirstName");
Assert.AreEqual(emp1["LastName"], echo1.LastName, "LastName");
Assert.AreEqual(emp1["Title"], echo1.Title, "Title");
var emp2 = new Dictionary<string, object>() { { "EmployeeKey", echo1.EmployeeKey }, { "LastName", "Brown" } };
repo.Update(emp2);
var echo2 = repo.Get(echo1.EmployeeKey.Value);
//these were changed
Assert.AreEqual(echo1.EmployeeKey, echo2.EmployeeKey, "EmployeeKey was not set");
Assert.AreEqual(emp2["LastName"], echo2.LastName, "LastName");
//these should be unchanged
Assert.AreEqual(emp1["FirstName"], echo2.FirstName, "FirstName");
Assert.AreEqual(emp1["Title"], echo2.Title, "Title");
repo.Delete(echo1.EmployeeKey.Value);
}
public int Delete(SalesOrderHeader _SalesOrderHeader)
{
return(SalesOrderHeaderDaoRepository.Delete(_SalesOrderHeader));
}
