public async Task Post([FromBody] Contact contact)
{
//using filter to validate model state
addressBookService.CreateContact(contact);
addressBookDbContext.SaveChanges();
await addressBookBroadcaster.BroadcastContactsChanged(contact);
}
private void CreateEditions()
{
var defaultEdition = _context.Editions.IgnoreQueryFilters().FirstOrDefault(e => e.Name == EditionManager.DefaultEditionName);
if (defaultEdition == null)
{
defaultEdition = new Edition {
Name = EditionManager.DefaultEditionName, DisplayName = EditionManager.DefaultEditionName
};
_context.Editions.Add(defaultEdition);
_context.SaveChanges();
/* Add desired features to the standard edition, if wanted... */
}
}
public void Get_ReturnsGroupedValues()
{
// arrange
var options = new DbContextOptionsBuilder <AddressBookDbContext>()
.UseInMemoryDatabase(databaseName: "AddressBook")
.Options;
using (var context = new AddressBookDbContext(options))
{
context.AddressBook.Add(new AddressBook {
FirstName = "Jane", LastName = "Jones", StreetAddress = "Test Rd 1", City = "Rome", Country = "Italy"
});
context.AddressBook.Add(new AddressBook {
FirstName = "Tim", LastName = "Smith", StreetAddress = "Test Rd 2", City = "Paris", Country = "France"
});
context.AddressBook.Add(new AddressBook {
FirstName = "John", LastName = "Doe", StreetAddress = "Test Rd 3", City = "Paris", Country = "France"
});
context.SaveChanges();
}
using (var context = new AddressBookDbContext(options))
{
// act
var controller = new AddressBookController(context);
OkObjectResult result = controller.Get() as OkObjectResult;
var content = result.Value as IDictionary <string, List <AddressBook> >;
// assert
Assert.Equal(3, context.AddressBook.Count());
Assert.IsType <OkObjectResult>(result);
Assert.Equal(200, result.StatusCode);
Assert.Equal(2, content.Count());
}
}
public void TestDeleteContact()
{
var options = new DbContextOptionsBuilder <AddressBookDbContext>()
.UseInMemoryDatabase(databaseName: "DeleteContact")
.Options;
Contact contact = CreateNewContact();
using (var dbContext = new AddressBookDbContext(options))
{
var contactsDataAccess = new ContactsDataAccess(dbContext);
contactsDataAccess.Create(contact);
dbContext.SaveChanges();
}
using (var dbContext = new AddressBookDbContext(options))
{
var contactsDataAccess = new ContactsDataAccess(dbContext);
Contact c = contactsDataAccess.GetById(contact.Id);
contactsDataAccess.Delete(c);
dbContext.SaveChanges();
}
using (var dbContext = new AddressBookDbContext(options))
{
Assert.Equal(0, dbContext.Contacts.Count());
Assert.Equal(0, dbContext.Addresses.Count());
Assert.Equal(0, dbContext.PhoneNumbers.Count());
}
}
public static void Seed(AddressBookDbContext context)
{
context.Database.EnsureCreated();
if (context.AddressBook.Any())
{
return;
}
List <AddressBook> addresses = new List <AddressBook>
{
new AddressBook {
FirstName = "John", LastName = "Smith", StreetAddress = "Test St 1", City = "London", Country = "England"
},
new AddressBook {
FirstName = "Jane", LastName = "Doe", StreetAddress = "Test St 2", City = "london", Country = "England"
},
new AddressBook {
FirstName = "Tim", LastName = "Jones", StreetAddress = "Test St 3", City = "New York", Country = "USA"
}
};
foreach (AddressBook address in addresses)
{
context.AddressBook.Add(address);
}
context.SaveChanges();
}
public void Create()
{
new DefaultEditionCreator(_context).Create();
new DefaultLanguagesCreator(_context).Create();
new HostRoleAndUserCreator(_context).Create();
new DefaultSettingsCreator(_context).Create();
_context.SaveChanges();
}
private void AddLanguageIfNotExists(ApplicationLanguage language)
{
if (_context.Languages.IgnoreQueryFilters().Any(l => l.TenantId == language.TenantId && l.Name == language.Name))
{
return;
}
_context.Languages.Add(language);
_context.SaveChanges();
}
private void AddSettingIfNotExists(string name, string value, int?tenantId = null)
{
if (_context.Settings.IgnoreQueryFilters().Any(s => s.Name == name && s.TenantId == tenantId && s.UserId == null))
{
return;
}
_context.Settings.Add(new Setting(tenantId, null, name, value));
_context.SaveChanges();
}
public ContactRepositoryTests()
{
var dbContextOptions = new DbContextOptionsBuilder <AddressBookDbContext>()
.UseInMemoryDatabase("AddressBookDatabase")
.Options;
_dbContext = new AddressBookDbContext(dbContextOptions);
_dbContext.Contacts.AddRange(new List <Contact>
{
new Contact
{
ContactId = 1,
FirstName = "Test First Name 1",
MiddleName = "Test Middle Name 1",
LastName = "Test Last Name 1",
DisplayName = "Test Display Name 1",
StreetAddress = "Test Street Address 1",
City = "Test City 1",
Region = "TO",
PostalCode = "12345",
Country = "Test Country 1",
PhoneNumber = "(012) 345-6789",
EmailAddress = "*****@*****.**"
},
new Contact
{
ContactId = 2,
FirstName = "Test First Name 2",
MiddleName = "Test Middle Name 2",
LastName = "Test Last Name 2",
DisplayName = "Test Display Name 2",
StreetAddress = "Test Street Address 2",
City = "Test City 2",
Region = "TT",
PostalCode = "67890",
Country = "Test Country 2",
PhoneNumber = "(123) 456-7890",
EmailAddress = "*****@*****.**"
}
});
_dbContext.SaveChanges();
var mapperConfig = new MapperConfiguration(
config => config.CreateMap <ContactDto, Contact>()
);
var mapper = mapperConfig.CreateMapper();
var sieveProcessorOptions = Options.Create(new SieveOptions());
var sieveProcessor = new SieveProcessor(sieveProcessorOptions);
_contactRepository = new ContactRepository(_dbContext, mapper, sieveProcessor);
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
var allContacts = _dbContext.Contacts.ToList();
_dbContext.Contacts.RemoveRange(allContacts);
_dbContext.SaveChanges();
}
disposed = true;
}
}
private void CreateDefaultTenant()
{
// Default tenant
var defaultTenant = _context.Tenants.IgnoreQueryFilters().FirstOrDefault(t => t.TenancyName == AbpTenantBase.DefaultTenantName);
if (defaultTenant == null)
{
defaultTenant = new Tenant(AbpTenantBase.DefaultTenantName, AbpTenantBase.DefaultTenantName);
var defaultEdition = _context.Editions.IgnoreQueryFilters().FirstOrDefault(e => e.Name == EditionManager.DefaultEditionName);
if (defaultEdition != null)
{
defaultTenant.EditionId = defaultEdition.Id;
}
_context.Tenants.Add(defaultTenant);
_context.SaveChanges();
}
}
public void TestIsInAddressBook()
{
var options = new DbContextOptionsBuilder <AddressBookDbContext>()
.UseInMemoryDatabase(databaseName: "CreateContact")
.Options;
using (var dbContext = new AddressBookDbContext(options))
{
var contactsDataAccess = new ContactsDataAccess(dbContext);
contactsDataAccess.Create(CreateNewContact());
dbContext.SaveChanges();
}
using (var dbContext = new AddressBookDbContext(options))
{
Assert.Equal(1, dbContext.Contacts.Count());
Assert.Equal(1, dbContext.Addresses.Count());
Assert.Equal(1, dbContext.PhoneNumbers.Count());
Assert.True(dbContext.Contacts.First().Id > 0);
}
Contact sameContact = CreateNewContact();
using (var dbContext = new AddressBookDbContext(options))
{
var contactsDataAccess = new ContactsDataAccess(dbContext);
bool isInAddressBook = contactsDataAccess.IsInAddressBook(sameContact);
Assert.True(isInAddressBook);
sameContact.Name += "_Changed";
isInAddressBook = contactsDataAccess.IsInAddressBook(sameContact);
Assert.False(isInAddressBook);
}
}
public void ContactPhoneNumber(int id, [FromBody] PhoneNumber phoneNumber)
{
addressBookService.AddNewPhoneNumberToContact(id, phoneNumber);
context.SaveChanges();
}
protected void Save() => _context.SaveChanges();
public bool Add(Person person)
{
_db.Address.Add(person);
return(_db.SaveChanges() > 0);
}
private void CreateRolesAndUsers()
{
// Admin role
var adminRole = _context.Roles.IgnoreQueryFilters().FirstOrDefault(r => r.TenantId == _tenantId && r.Name == StaticRoleNames.Tenants.Admin);
if (adminRole == null)
{
adminRole = _context.Roles.Add(new Role(_tenantId, StaticRoleNames.Tenants.Admin, StaticRoleNames.Tenants.Admin)
{
IsStatic = true
}).Entity;
_context.SaveChanges();
}
// Grant all permissions to admin role
var grantedPermissions = _context.Permissions.IgnoreQueryFilters()
.OfType <RolePermissionSetting>()
.Where(p => p.TenantId == _tenantId && p.RoleId == adminRole.Id)
.Select(p => p.Name)
.ToList();
var permissions = PermissionFinder
.GetAllPermissions(new AddressBookAuthorizationProvider())
.Where(p => p.MultiTenancySides.HasFlag(MultiTenancySides.Tenant) &&
!grantedPermissions.Contains(p.Name))
.ToList();
if (permissions.Any())
{
_context.Permissions.AddRange(
permissions.Select(permission => new RolePermissionSetting
{
TenantId = _tenantId,
Name = permission.Name,
IsGranted = true,
RoleId = adminRole.Id
})
);
_context.SaveChanges();
}
// Admin user
var adminUser = _context.Users.IgnoreQueryFilters().FirstOrDefault(u => u.TenantId == _tenantId && u.UserName == AbpUserBase.AdminUserName);
if (adminUser == null)
{
adminUser = User.CreateTenantAdminUser(_tenantId, "*****@*****.**");
adminUser.Password = new PasswordHasher <User>(new OptionsWrapper <PasswordHasherOptions>(new PasswordHasherOptions())).HashPassword(adminUser, "123qwe");
adminUser.IsEmailConfirmed = true;
adminUser.IsActive = true;
_context.Users.Add(adminUser);
_context.SaveChanges();
// Assign Admin role to admin user
_context.UserRoles.Add(new UserRole(_tenantId, adminUser.Id, adminRole.Id));
_context.SaveChanges();
}
}
private void CreateHostRoleAndUsers()
{
// Admin role for host
var adminRoleForHost = _context.Roles.IgnoreQueryFilters().FirstOrDefault(r => r.TenantId == null && r.Name == StaticRoleNames.Host.Admin);
if (adminRoleForHost == null)
{
adminRoleForHost = _context.Roles.Add(new Role(null, StaticRoleNames.Host.Admin, StaticRoleNames.Host.Admin)
{
IsStatic = true, IsDefault = true
}).Entity;
_context.SaveChanges();
}
// Grant all permissions to admin role for host
var grantedPermissions = _context.Permissions.IgnoreQueryFilters()
.OfType <RolePermissionSetting>()
.Where(p => p.TenantId == null && p.RoleId == adminRoleForHost.Id)
.Select(p => p.Name)
.ToList();
var permissions = PermissionFinder
.GetAllPermissions(new AddressBookAuthorizationProvider())
.Where(p => p.MultiTenancySides.HasFlag(MultiTenancySides.Host) &&
!grantedPermissions.Contains(p.Name))
.ToList();
if (permissions.Any())
{
_context.Permissions.AddRange(
permissions.Select(permission => new RolePermissionSetting
{
TenantId = null,
Name = permission.Name,
IsGranted = true,
RoleId = adminRoleForHost.Id
})
);
_context.SaveChanges();
}
// Admin user for host
var adminUserForHost = _context.Users.IgnoreQueryFilters().FirstOrDefault(u => u.TenantId == null && u.UserName == AbpUserBase.AdminUserName);
if (adminUserForHost == null)
{
var user = new User
{
TenantId = null,
UserName = AbpUserBase.AdminUserName,
Name = "admin",
Surname = "admin",
EmailAddress = "*****@*****.**",
IsEmailConfirmed = true,
IsActive = true
};
user.Password = new PasswordHasher <User>(new OptionsWrapper <PasswordHasherOptions>(new PasswordHasherOptions())).HashPassword(user, "123qwe");
user.SetNormalizedNames();
adminUserForHost = _context.Users.Add(user).Entity;
_context.SaveChanges();
// Assign Admin role to admin user
_context.UserRoles.Add(new UserRole(null, adminUserForHost.Id, adminRoleForHost.Id));
_context.SaveChanges();
_context.SaveChanges();
}
}
