private void SetStateFlag()
{
ViewBag.Exception = null;
ViewBag.AlreadyCreated = false;
if (User.Identity.IsAuthenticated)
{
ViewBag.AlreadyCreated = true;
}
else
{
using (var con = SetupTools.DbTools.OpenConnection())
{
using (var uow = new AdoNetUnitOfWork(con))
{
var id = uow.ExecuteScalar("SELECT TOP 1 Id FROM Accounts");
if (id != null)
{
ViewBag.AlreadyCreated = true;
}
}
}
}
if (!ViewBag.AlreadyCreated)
{
ViewBag.NextLink = null;
}
}
public static async Task <AuthenticationTicket> CreateTicket(HttpRequest request, ApiKeyAuthOptions options)
{
var apiKeyHeader = request.Headers["X-Api-Key"];
var signatureHeader = request.Headers["X-Api-Signature"];
if (apiKeyHeader.Count == 0 ||
signatureHeader.Count == 0)
{
return(null);
}
var apiKey = apiKeyHeader[0];
var claims = new List <Claim>()
{
new Claim(ClaimTypes.NameIdentifier, apiKey),
new Claim(ClaimTypes.Name, "ApiKey"),
new Claim(ClaimTypes.Role, CoderrRoles.System)
};
var identity = new ClaimsIdentity(claims, options.AuthenticationScheme);
var claimsPrincipal = new ClaimsPrincipal(identity);
using (var con = options.OpenDb())
{
using (var uow = new AdoNetUnitOfWork(con, false))
{
var repos = new ApiKeyRepository(uow);
ApiKey key;
try
{
key = await repos.GetByKeyAsync(apiKey);
}
catch (EntityNotFoundException)
{
return(null);
}
request.EnableRewind();
var buf = new byte[request.ContentLength ?? 0];
var bytesRead = await request.Body.ReadAsync(buf, 0, buf.Length);
request.Body.Position = 0;
if (!key.ValidateSignature(signatureHeader[0], buf))
{
return(null);
}
if (key.Claims != null)
{
identity.AddClaims(key.Claims);
}
uow.SaveChanges();
}
}
return(new AuthenticationTicket(claimsPrincipal, options.AuthenticationScheme));
}
/// <summary>
/// Mains.
/// </summary>
/// <param name="args">The arguments.</param>
static void Main(string[] args)
{
CommandBuilderFactory.Assign(mapper => new SqliteCommandBuilder(mapper));
string cs = "URI=file:test.db";
var connection = new SQLiteConnection(cs);
connection.Open();
if (!connection.TableExists("Users"))
{
using (var uow = new AdoNetUnitOfWork(connection))
{
uow.Execute(
"CREATE TABLE Users (Id INTEGER PRIMARY KEY AUTOINCREMENT, FirstName TEXT, LastName text, CreatedAtUtc INTEGER)");
uow.SaveChanges();
}
}
var users = connection.ToList <User>("firstName = @FirstName", new { FirstName = "Gau%" });
try
{
var first = connection.First <User>(new { Id = 1 });
}
catch (EntityNotFoundException x)
{
Console.WriteLine("Expected to find user, since First was used instead of FirstOrDefault. User friendly error message: " + x.Message);
}
// clear old data
using (var uow = new AdoNetUnitOfWork(connection))
{
using (var cmd = uow.CreateCommand())
{
cmd.CommandText = "SELECT * FROM Users";
cmd.AddParameter("id", "983498043903");
foreach (var entity in cmd.ToEnumerable <User>())
{
Console.WriteLine(entity.FirstName);
}
}
uow.Truncate <User>();
for (int i = 0; i < 100; i++)
{
uow.Insert(new User {
FirstName = "Arne" + i
});
}
uow.SaveChanges();
}
Console.WriteLine("Press ENTER to quit.");
Console.ReadLine();
}
public void SaveChangesTwice()
{
bool isDisposed = false, isCommited = false;
var trans = Substitute.For <IDbTransaction>();
var uow = new AdoNetUnitOfWork(trans, x => isDisposed = true, x => isCommited = true);
uow.SaveChanges();
Assert.Throws <InvalidOperationException>(() => uow.SaveChanges());
}
public void SaveChangesTwice()
{
bool isDisposed = false, isCommited = false;
var trans = Substitute.For<IDbTransaction>();
var uow = new AdoNetUnitOfWork(trans, x => isDisposed = true, x => isCommited = true);
uow.SaveChanges();
Assert.Throws<InvalidOperationException>(() => uow.SaveChanges());
}
public IUnitOfWork CreateUnitOfWork()
{
var transaction = _connection.BeginTransaction();
var uow = new AdoNetUnitOfWork(transaction, RemoveTransaction, RemoveTransaction);
_rwLock.EnterWriteLock();
_uows.AddLast(uow);
_rwLock.ExitWriteLock();
return(uow);
}
/// <summary>
/// Create a new unit of work implementation
/// </summary>
/// <returns>
/// A unit of work
/// </returns>
public IUnitOfWork CreateUnitOfWork()
{
var transaction = _connection.BeginTransaction();
var uow = new AdoNetUnitOfWork(transaction, RemoveTransaction, RemoveTransaction);
_rwLock.EnterWriteLock();
_uows.AddLast(uow);
_rwLock.ExitWriteLock();
return uow;
}
public void RolledBack()
{
bool isDisposed = false, isCommited = false;
var trans = Substitute.For <IDbTransaction>();
var uow = new AdoNetUnitOfWork(trans, x => isDisposed = true, x => isCommited = true);
uow.Dispose();
Assert.False(isCommited);
Assert.True(isDisposed);
trans.Received().Rollback();
}
public void RolledBack()
{
bool isDisposed = false, isCommited = false;
var trans = Substitute.For<IDbTransaction>();
var uow = new AdoNetUnitOfWork(trans, x => isDisposed = true, x => isCommited = true);
uow.Dispose();
Assert.False(isCommited);
Assert.True(isDisposed);
trans.Received().Rollback();
}
public void rollback_transaction_if_savechanges_have_not_been_made()
{
var connection = new Griffin.AdoNetFakes.FakeConnection();
connection.CurrentState = ConnectionState.Open;
var sut = new AdoNetUnitOfWork(connection);
sut.Dispose();
connection.Transactions[0].IsRolledBack.Should().BeTrue();
}
public void attach_transaction_to_created_command()
{
var connection = new Griffin.AdoNetFakes.FakeConnection();
connection.CurrentState = ConnectionState.Open;
var sut = new AdoNetUnitOfWork(connection);
var actual = sut.CreateCommand();
actual.Transaction.Should().BeSameAs(connection.Transactions[0]);
actual.Connection.Should().BeSameAs(connection);
}
public void close_connection_if_owned_is_set()
{
var connection = new Griffin.AdoNetFakes.FakeConnection();
connection.CurrentState = ConnectionState.Open;
var sut = new AdoNetUnitOfWork(connection, true);
sut.Dispose();
connection.State.Should().Be(ConnectionState.Closed);
}
public void commit_successfully_if_no_commit_have_been_previously_made()
{
var connection = new Griffin.AdoNetFakes.FakeConnection();
connection.CurrentState = ConnectionState.Open;
var sut = new AdoNetUnitOfWork(connection);
sut.SaveChanges();
connection.Transactions[0].IsCommitted.Should().BeTrue();
}
public void dont_close_connection_per_default()
{
var connection = new Griffin.AdoNetFakes.FakeConnection();
connection.CurrentState = ConnectionState.Open;
var sut = new AdoNetUnitOfWork(connection);
sut.Dispose();
connection.State.Should().Be(ConnectionState.Open);
}
public void use_the_specified_isolation_level()
{
var connection = new Griffin.AdoNetFakes.FakeConnection();
connection.CurrentState = ConnectionState.Open;
var sut = new AdoNetUnitOfWork(connection, true, IsolationLevel.Chaos);
connection.Transactions[0].IsolationLevel.Should().Be(IsolationLevel.Chaos);
connection.State.Should().Be(ConnectionState.Open);
}
public void throw_if_commit_have_been_previously_made()
{
var connection = new Griffin.AdoNetFakes.FakeConnection();
connection.CurrentState = ConnectionState.Open;
var sut = new AdoNetUnitOfWork(connection);
sut.SaveChanges();
Action actual = sut.SaveChanges;
actual.Should().Throw <TransactionAlreadyClosedException>();
}
public EmanetlerRepository(IUnitOfWork uow)
{
if (uow == null)
{
throw new ArgumentNullException("uow");
}
_unitOfWork = uow as AdoNetUnitOfWork;
if (_unitOfWork == null)
{
throw new NotSupportedException("Ohh my, change that UnitOfWorkFactory, will you?");
}
}
public AsyncUnitOfWorkExtensionsTests()
{
CommandBuilderFactory.Assign(mapper => new SqliteCommandBuilder(mapper));
_dbFile = Path.GetTempFileName();
var cs = "URI=file:" + _dbFile;
_connection = new SQLiteConnection(cs);
_connection.Open();
_uow = new AdoNetUnitOfWork(_connection);
_userTable.Create(_connection);
}
public AsyncUnitOfWorkExtensionsTests()
{
CommandBuilderFactory.Assign(mapper => new SqliteCommandBuilder(mapper));
_dbFile = Path.GetTempFileName();
var cs = "URI=file:" + _dbFile;
_connection = new SQLiteConnection(cs);
_connection.Open();
_uow = new AdoNetUnitOfWork(_connection);
_userTable.Create(_connection);
}
static void Main(string[] args)
{
CommandBuilderFactory.Assign(mapper => new SqliteCommandBuilder(mapper));
string cs = "URI=file:test.db";
var connection = new SQLiteConnection(cs);
connection.Open();
if (!connection.TableExists("Users"))
{
using (var uow = new AdoNetUnitOfWork(connection))
{
uow.Execute(
"CREATE TABLE Users (Id INTEGER PRIMARY KEY AUTOINCREMENT, FirstName TEXT, LastName text, CreatedAtUtc INTEGER)");
uow.SaveChanges();
}
}
var users = connection.ToList<User>(new {FirstName = "Gau%"});
var first = connection.First<User>(new {Id = 1});
// clear old data
using (var uow = new AdoNetUnitOfWork(connection))
{
using (var cmd = uow.CreateCommand())
{
cmd.CommandText = "SELECT * FROM Users";
cmd.AddParameter("id", "983498043903");
foreach (var entity in cmd.ToEnumerable<User>())
{
Console.WriteLine(entity.FirstName);
}
}
uow.Truncate<User>();
for (int i = 0; i < 100; i++)
{
uow.Insert(new User { FirstName = "Arne" + i });
}
uow.SaveChanges();
}
}
static void Main(string[] args)
{
CommandBuilderFactory.Assign(mapper => new SqliteCommandBuilder(mapper));
string cs = "URI=file:test.db";
var connection = new SQLiteConnection(cs);
connection.Open();
if (!connection.TableExists("Users"))
{
using (var uow = new AdoNetUnitOfWork(connection))
{
uow.Execute(
"CREATE TABLE Users (Id INTEGER PRIMARY KEY AUTOINCREMENT, FirstName TEXT, LastName text, CreatedAtUtc INTEGER)");
uow.SaveChanges();
}
}
var users = connection.ToList <User>(new { FirstName = "Gau%" });
var first = connection.First <User>(new { Id = 1 });
// clear old data
using (var uow = new AdoNetUnitOfWork(connection))
{
using (var cmd = uow.CreateCommand())
{
cmd.CommandText = "SELECT * FROM Users";
cmd.AddParameter("id", "983498043903");
foreach (var entity in cmd.ToEnumerable <User>())
{
Console.WriteLine(entity.FirstName);
}
}
uow.Truncate <User>();
for (int i = 0; i < 100; i++)
{
uow.Insert(new User {
FirstName = "Arne" + i
});
}
uow.SaveChanges();
}
}
static void Main(string[] args)
{
//ADORepository<Course> courseRepository = new ADORepository<Course>();
AdoNetUnitOfWork unitOfWork = new AdoNetUnitOfWork();
var data = unitOfWork.Courses.GetAll();
foreach (var course in data)
{
Console.WriteLine(course.Title);
}
Console.Read();
}
public void close_connection_on_dispose_even_if_savechanges_have_been_called()
{
var connection = new Griffin.AdoNetFakes.FakeConnection();
connection.CurrentState = ConnectionState.Open;
var sut = new AdoNetUnitOfWork(connection, true);
sut.SaveChanges();
sut.Dispose();
connection.Transactions[0].IsCommitted.Should().BeTrue();
connection.State.Should().Be(ConnectionState.Closed);
}
public AsyncUnitOfWorkExtensionsTests()
{
CommandBuilderFactory.Assign(mapper => new SqliteCommandBuilder(mapper));
var provider = new AssemblyScanningMappingProvider();
provider.Scan(Assembly.GetExecutingAssembly());
EntityMappingProvider.Provider = provider;
_dbFile = Path.GetTempFileName();
var cs = "URI=file:" + _dbFile;
_connection = new SQLiteConnection(cs);
_connection.Open();
_uow = new AdoNetUnitOfWork(_connection);
_userTable.Create(_connection);
}
public CityRepository(IDbConnection connection, AdoNetUnitOfWork uow)
{
this._connection = connection;
this._uow = uow;
}
public async Task <ActionResult> Admin(AccountViewModel model)
{
SetStateFlag();
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var account = new Account(model.UserName, model.Password);
account.Activate();
account.IsSysAdmin = true;
var con = SetupTools.DbTools.OpenConnection();
var uow = new AdoNetUnitOfWork(con);
var repos = new AccountRepository(uow);
if (await repos.IsUserNameTakenAsync(model.UserName))
{
return(Redirect(Url.GetNextWizardStep()));
}
account.SetVerifiedEmail(model.EmailAddress);
await repos.CreateAsync(account);
var user = new User(account.Id, account.UserName)
{
EmailAddress = account.Email
};
var userRepos = new UserRepository(uow);
await userRepos.CreateAsync(user);
var repos2 = new ApplicationRepository(uow);
var app = new Application(user.AccountId, "DemoApp")
{
ApplicationType = TypeOfApplication.DesktopApplication
};
await repos2.CreateAsync(app);
var tm = new ApplicationTeamMember(app.Id, account.Id, "System")
{
Roles = new[] { ApplicationRole.Admin, ApplicationRole.Member },
UserName = account.UserName
};
await repos2.CreateAsync(tm);
uow.SaveChanges();
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, account.Id.ToString(), ClaimValueTypes.Integer32),
new Claim(ClaimTypes.Name, account.UserName, ClaimValueTypes.String),
new Claim(ClaimTypes.Email, account.Email, ClaimValueTypes.String),
new Claim(CoderrClaims.Application, app.Id.ToString(), ClaimValueTypes.Integer32),
new Claim(CoderrClaims.ApplicationAdmin, app.Id.ToString(), ClaimValueTypes.Integer32),
new Claim(ClaimTypes.Role, CoderrClaims.RoleSysAdmin, ClaimValueTypes.String)
};
var identity = new ClaimsIdentity(claims, "Cookie", ClaimTypes.Name, ClaimTypes.Role);
var properties = new AuthenticationProperties {
IsPersistent = false
};
HttpContext.GetOwinContext().Authentication.SignIn(properties, identity);
return(Redirect(Url.GetNextWizardStep()));
}
catch (Exception ex)
{
ViewBag.Exception = ex;
ModelState.AddModelError("", ex.Message);
return(View(model));
}
}
private void RemoveTransaction(AdoNetUnitOfWork obj)
{
_rwLock.EnterWriteLock();
_uows.Remove(obj);
_rwLock.ExitWriteLock();
}
public async Task <ActionResult> Admin(AccountViewModel model)
{
SetStateFlag();
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var account = new Account(model.UserName, model.Password);
account.Activate();
var con = SetupTools.DbTools.OpenConnection();
var uow = new AdoNetUnitOfWork(con);
var repos = new AccountRepository(uow);
if (await repos.IsUserNameTakenAsync(model.UserName))
{
return(Redirect(Url.GetNextWizardStep()));
}
account.SetVerifiedEmail(model.EmailAddress);
await repos.CreateAsync(account);
var user = new User(account.Id, account.UserName)
{
EmailAddress = account.Email
};
var userRepos = new UserRepository(uow);
await userRepos.CreateAsync(user);
var repos2 = new ApplicationRepository(uow);
var app = new Application(user.AccountId, "DemoApp")
{
ApplicationType = TypeOfApplication.DesktopApplication
};
await repos2.CreateAsync(app);
/*insert into ApplicationMembers (AccountId, ApplicationId, EmailAddress, AddedAtUtc, AddedByName, Roles) SELECT 1, 1, (SELECT TOP 1 email FROM accounts), GetUtcDate(), 'admin', 'Admin,Member';
*/
var tm = new ApplicationTeamMember(app.Id, account.Email)
{
AccountId = account.Id,
AddedByName = "system",
Roles = new[] { "Admin, Member" },
UserName = account.UserName
};
await repos2.CreateAsync(tm);
uow.SaveChanges();
SessionUser.Current = new SessionUser(account.Id, model.UserName);
return(Redirect(Url.GetNextWizardStep()));
}
catch (Exception ex)
{
ViewBag.Exception = ex;
ModelState.AddModelError("", ex.Message);
return(View(model));
}
}
private void RemoveTransaction(AdoNetUnitOfWork obj)
{
_rwLock.EnterWriteLock();
_uows.Remove(obj);
_rwLock.ExitWriteLock();
}
