public static LockState SafeReleaseLock(ReVersion_DatabaseContext db, string repoName, string branchName, string username)
{
Branch branchEntity =
(from repository in db.Repositories
join branch in db.Branches on repository.Id equals branch.RepositoryId
where repository.Name == repoName &&
branch.Name == branchName
select branch)
.Single();
if (!branchEntity.Locked)
{
return(LockState.AlreadyUnlockedConflict);
}
string usernameQuery =
(from log in db.EventLogs
where branchEntity.Id == log.BranchId &&
log.Type == "place_lock"
join user in db.Users on log.UserId equals user.Id
orderby log.LoggedAt descending, log.Id descending
select user.UserName)
.First();
if (username != usernameQuery)
{
return(LockState.LockedByDifferentUser);
}
branchEntity.Locked = false;
return(LockState.SuccessfulLockOperation);
}
// NOT FULLY TESTED
// updated version not yet tested, should work fine
// (except maybe the case with the "versionId" parameter specified
public static HierarchyNode QueryHierarchy(ReVersion_DatabaseContext db, string repoName, string branchName, string versionId = null)
{
var latestHierarchyJson =
from repository in db.Repositories
join branch in db.Branches on repository.Id equals branch.RepositoryId
where repository.Name == repoName &&
branch.Name == branchName
select branch.LatestFileHierarchy;
var versionHierarchyJson =
from repository in db.Repositories
join branch in db.Branches on repository.Id equals branch.RepositoryId
join version in db.Versions on branch.Id equals version.BranchId
where repository.Name.Equals(repoName) &&
branch.Name.Equals(branchName) &&
version.VersionNumber.Equals(versionId ?? "-1")
select version.FileHierarchy;
string hierarchyJson = string.IsNullOrEmpty(versionId) ?
latestHierarchyJson.Single() :
versionHierarchyJson.Single();
FileHierarchyData hierarchyData = new FileHierarchyData(hierarchyJson);
return(hierarchyData.GetHierarchyList());
}
public static List <string> QueryPermissions(ReVersion_DatabaseContext db, string username) =>
(from user in db.Users
where user.UserName == username
join permission in db.RepositoryPermissions on user.Id equals permission.PermittedUser
join repository in db.Repositories on permission.RepositoryId equals repository.Id
select repository.Name)
.ToList();
public static int QueryLastEventIdByUser(ReVersion_DatabaseContext db, string username) =>
(from log in db.EventLogs
join user in db.Users on log.UserId equals user.Id
where user.UserName == username
orderby log.LoggedAt descending, log.Id descending
select log.Id)
.First();
public static bool BranchIsLocked(ReVersion_DatabaseContext db, string repoName, string branchName) =>
(from repository in db.Repositories
join branch in db.Branches on repository.Id equals branch.RepositoryId
where repository.Name == repoName &&
branch.Name == branchName
select branch.Locked)
.Single();
public static void DeleteAllFromVersionsTable(ReVersion_DatabaseContext db, string repoName) =>
db.Versions.RemoveRange(
from repository in db.Repositories
where repository.Name == repoName
join branch in db.Branches on repository.Id equals branch.RepositoryId
join version in db.Versions on branch.Id equals version.BranchId
select version);
public static int QueryMainTrunkFromRequest(ReVersion_DatabaseContext db, int requestId) =>
(from request in db.PermissionRequests
where request.Id == requestId
join log in db.EventLogs on request.EventId equals log.Id
join branch in db.Branches on log.BranchId equals branch.Id
select branch.Id)
.Single();
public static List <RepositoryLookup> QueryRepositories(ReVersion_DatabaseContext db) =>
(from repository in db.Repositories
join user in db.Users on repository.Owner equals user.Id
select new RepositoryLookup {
Name = repository.Name, Owner = user.UserName
})
.ToList();
private void TestPermissionInsertion(ReVersion_DatabaseContext db, List <string> users, List <string> repos)
{
SQLOperations.InsertIntoRepoPermissionsTable(db, "firstRepo", "imaUser");
SQLOperations.InsertIntoRepoPermissionsTable(db, "yetAnotherRepo", "imaUser");
SQLOperations.InsertIntoRepoPermissionsTable(db, "yetAnotherRepo", "imanotherUser");
db.SaveChanges();
foreach (var item in repos.Zip(users, (r, u) => new { RepositoryName = r, Username = u }))
{
if (item.Username.Equals("imanotherUser") && item.RepositoryName.Equals("firstRepo"))
{
Assert.IsFalse(SQLOperations.UserCanAccessRepository(db, item.Username, item.RepositoryName));
}
else
{
Assert.IsTrue(SQLOperations.UserCanAccessRepository(db, item.Username, item.RepositoryName));
}
}
List <string> permsActual = SQLOperations.QueryPermissions(db, "imaUser");
List <string> permsExpected = new List <string> {
"firstRepo", "yetAnotherRepo"
};
SameListContents(permsActual, permsExpected);
}
public void TestVersions()
{
using (ReVersion_DatabaseContext db = new ReVersion_DatabaseContext())
{
FileHierarchyData hierData = new FileHierarchyData(hierarchy);
hierData.AddNode("/A/B/alpha/beTa");
hierData.DeleteNode("F/");
VersionData data = new VersionData
{
RepositoryName = "yetAnotherRepo",
BranchName = "yetAnotherBranch",
ParentBranchName = "yetAnotherOtherBranch",
NewBranch = true,
DeltaContent = "here's Delta!",
//FileHierarchy = hierData.GetHierarchyList(),
EventId = 5
};
SQLOperations.InsertIntoVersionsTable(db, data);
db.SaveChanges();
List <int> versionsActual = SQLOperations.QueryVersions(db, "yetAnotherRepo", "yetAnotherBranch");
List <int> versionsExpected = new List <int> {
1
};
SameListContents(versionsActual, versionsExpected);
}
}
public static List <int> QueryVersions(ReVersion_DatabaseContext db, string repoName, string branchName) =>
(from repository in db.Repositories
join branch in db.Branches on repository.Id equals branch.RepositoryId
where repository.Name == repoName && branch.Name == branchName
join version in db.Versions on branch.Id equals version.BranchId
select version.VersionNumber)
.ToList();
public void TestBranch()
{
using (ReVersion_DatabaseContext db = new ReVersion_DatabaseContext())
{
SQLOperations.InsertIntoBranchTable(db, "firstRepo", "imaNewBranch");
SQLOperations.InsertIntoBranchTable(db, "firstRepo", "imanotherBranch");
SQLOperations.InsertIntoRepoTable(db, "helloRepo", "imanotherUser");
db.SaveChanges();
SQLOperations.InsertIntoBranchTable(db, "helloRepo", "helloBranch");
db.SaveChanges();
List <BranchLookup> branchesActual = SQLOperations.QueryBranches(db, "firstRepo");
List <BranchLookup> branchesExpected = new List <BranchLookup>
{
new BranchLookup {
BranchName = "imaNewBranch", Locked = false
},
new BranchLookup {
BranchName = "imanotherBranch", Locked = false
}
};
SameListContents(branchesActual, branchesExpected);
}
}
public void TestBranchIdQuery()
{
using (ReVersion_DatabaseContext db = new ReVersion_DatabaseContext())
{
int actualId = SQLOperations.QueryBranchId(db, "helloRepo", "helloBranch");
Assert.AreEqual(actualId, 3);
}
}
public static void InsertIntoPermissionRequestTable(ReVersion_DatabaseContext db, string repoName, int eventId) =>
db.PermissionRequests.Add(new PermissionRequest
{
EventId = eventId,
RepositoryId = (from repository in db.Repositories
where repository.Name == repoName
select repository.Id).Single()
});
public void TestVersionDelete()
{
using (ReVersion_DatabaseContext db = new ReVersion_DatabaseContext())
{
SQLOperations.DeleteAllFromVersionsTable(db, "yetAnotherRepo");
db.SaveChanges();
}
}
public static bool UserCanAccessBranch(ReVersion_DatabaseContext db, string repoName, string branchName, string username) =>
(from repository in db.Repositories
join branch in db.Branches on repository.Id equals branch.RepositoryId
join permission in db.RepositoryPermissions on repository.Id equals permission.RepositoryId
join user in db.Users on permission.PermittedUser equals user.Id
where repository.Name.Equals(repoName) &&
branch.Name.Equals(branchName) &&
user.UserName.Equals(username)
select user.Id).Any();
public static List <BranchLookup> QueryBranches(ReVersion_DatabaseContext db, string repoName) =>
(from repository in db.Repositories
join branch in db.Branches
on repository.Id equals branch.RepositoryId
where repository.Name == repoName
select new BranchLookup {
Locked = branch.Locked, BranchName = branch.Name
})
.ToList();
public static void InsertIntoRepoTable(ReVersion_DatabaseContext db, string repoName, string username) =>
db.Repositories.AddAsync(new Repository
{
Name = repoName,
Owner = (from user in db.Users
where user.UserName == username
select user.Id)
.Single()
});
public void TestEmptyPermissionRequests()
{
using (var db = new ReVersion_DatabaseContext())
{
List <PermissionLookup> actual = SQLOperations.QueryPermissionRequests(db, "adam");
List <PermissionLookup> expected = new List <PermissionLookup>();
Assert.AreEqual(actual.Count, expected.Count);
}
}
public static void InsertIntoBranchTable(ReVersion_DatabaseContext db, string repoName, string branchName) =>
db.Branches.Add(
(from repository in db.Repositories
where repository.Name == repoName
select new Branch
{
RepositoryId = repository.Id,
Name = branchName
})
.Single()
);
public static string QueryRepositoryNameFromRequest(ReVersion_DatabaseContext db, int requestId)
{
int trunkId = QueryMainTrunkFromRequest(db, requestId);
return
((from repository in db.Repositories
join request in db.PermissionRequests on repository.Id equals request.RepositoryId
where request.Id.Equals(requestId)
select repository.Name)
.Single());
}
// Untested
public static bool PermissionRequestIsLogged(ReVersion_DatabaseContext db, string repoName, string username) =>
(from request in db.PermissionRequests
join repository in db.Repositories on request.RepositoryId equals repository.Id
join branch in db.Branches on repository.Id equals branch.RepositoryId
join log in db.EventLogs on branch.Id equals log.BranchId
join user in db.Users on log.UserId equals user.Id
where repository.Name.Equals(repoName) &&
branch.Name.Equals("main") &&
user.UserName.Equals(username) &&
log.Type.Equals("request_permission")
select log.Id)
.Any();
public static void InsertIntoRepoPermissionsTable(ReVersion_DatabaseContext db, string repoName, string username) =>
db.RepositoryPermissions.Add(
(from repository in db.Repositories
where repository.Name == repoName
from user in db.Users
where user.UserName == username
select new RepositoryPermission
{
PermittedUser = user.Id,
RepositoryId = repository.Id
})
.Single()
);
public static void UpdateHierarchyDatumInBranchesTable(ReVersion_DatabaseContext db, string repoName, string branchName, string hierarchyDatum)
{
Branch branchEntity =
(from repository in db.Repositories
where repository.Name == repoName
join branch in db.Branches on repository.Id equals branch.RepositoryId
where branch.Name == branchName
select branch)
.Single();
branchEntity.VersionNumber += 1;
branchEntity.LatestFileHierarchy = hierarchyDatum;
}
public static LockData QueryLockEventByBranch(ReVersion_DatabaseContext db, string repoName, string branchName) =>
(from repository in db.Repositories
join branch in db.Branches on repository.Id equals branch.RepositoryId
join log in db.EventLogs on branch.Id equals log.BranchId
join user in db.Users on log.UserId equals user.Id
where repository.Name.Equals(repoName) &&
branch.Name.Equals(branchName)
orderby log.LoggedAt descending, log.Id descending
select new LockData
{
UserName = user.UserName,
Message = log.Message,
Timestamp = log.LoggedAt,
LockedBranchId = branch.Name
}).First();
public static void InsertIntoVersionsTable(ReVersion_DatabaseContext db, VersionData data) =>
db.Versions.Add((from thisBranch in db.Branches
from parentBranch in db.Branches
join repository in db.Repositories on thisBranch.RepositoryId equals repository.Id
where thisBranch.Name == data.BranchName &&
parentBranch.Name == (data.NewBranch ? data.ParentBranchName : data.BranchName) &&
repository.Name == data.RepositoryName
select new Version
{
VersionNumber = thisBranch.VersionNumber,
BranchId = thisBranch.Id,
ParentBranch = parentBranch.Id,
RollbackDelta = data.DeltaContent,
FileHierarchy = data.FileHierarchyString(),
UpdateEventId = data.EventId
})
.Single());
private void TestPermissionDeletion(ReVersion_DatabaseContext db, List <string> users, List <string> repos)
{
SQLOperations.DeleteAllFromPermissionsTable(db, "yetAnotherRepo");
db.SaveChanges();
foreach (var item in repos.Zip(users, (r, u) => new { RepositoryName = r, Username = u }))
{
if (item.RepositoryName.Equals("firstRepo") && item.Username.Equals("imaUser"))
{
Assert.IsTrue(SQLOperations.UserCanAccessRepository(db, item.Username, item.RepositoryName));
}
else
{
Assert.IsFalse(SQLOperations.UserCanAccessRepository(db, item.Username, item.RepositoryName));
}
}
}
public static LockState ReleaseLock(ReVersion_DatabaseContext db, string repoName, string branchName)
{
Branch branchEntity =
(from repository in db.Repositories
where repository.Name == repoName
join branch in db.Branches on repository.Id equals branch.RepositoryId
where branch.Name == branchName
select branch)
.Single();
if (!branchEntity.Locked)
{
return(LockState.AlreadyUnlockedConflict);
}
branchEntity.Locked = false;
return(LockState.SuccessfulLockOperation);
}
public static void InsertIntoEventLog(ReVersion_DatabaseContext db, string repoName, string branchName, string username, string message, string type)
{
db.EventLogs.Add(
(from user in db.Users
from branch in db.Branches
join repository in db.Repositories on branch.RepositoryId equals repository.Id
where user.UserName == username &&
branch.Name == branchName &&
repository.Name == repoName
select new EventLog
{
Type = type,
BranchId = branch.Id,
UserId = user.Id,
Message = message
})
.Single()
);
}
public static List <PermissionLookup> QueryPermissionRequests(ReVersion_DatabaseContext db, string username)
{
var query =
from user in db.Users
where user.UserName == username
join repository in db.Repositories on user.Id equals repository.Owner
join request in db.PermissionRequests on repository.Id equals request.RepositoryId
join log in db.EventLogs on request.EventId equals log.Id
join requestUser in db.Users on log.UserId equals requestUser.Id
select new PermissionLookup
{
RequestId = request.Id,
RequestingUser = requestUser.UserName,
RepositoryName = repository.Name,
Message = log.Message,
LogTimestamp = log.LoggedAt
};
return(query.ToList());
}
