public UserRepositoryRole RepositoryAddUser(string reponame, string username)
{
using (var ctx = new GitCandyContext())
{
var pair = (from r in ctx.Repositories
from u in ctx.Users
where r.Name == reponame && u.Name == username &&
r.UserRepositoryRoles.All(s => s.User.Name != username)
select new { RepoID = r.ID, UserID = u.ID })
.FirstOrDefault();
if (pair == null)
{
return(null);
}
var role = new UserRepositoryRole
{
RepositoryID = pair.RepoID,
UserID = pair.UserID,
AllowRead = true,
AllowWrite = true,
IsOwner = false,
};
ctx.UserRepositoryRoles.Add(role);
ctx.SaveChanges();
return(role);
}
}
public TeamRepositoryRole RepositoryAddTeam(string reponame, string teamname)
{
using (var ctx = new GitCandyContext())
{
var pair = (from r in ctx.Repositories
from t in ctx.Teams
where r.Name == reponame && t.Name == teamname &&
r.TeamRepositoryRoles.All(s => s.Team.Name != teamname)
select new { RepoID = r.ID, TeamID = t.ID })
.FirstOrDefault();
if (pair == null)
{
return(null);
}
var role = new TeamRepositoryRole
{
RepositoryID = pair.RepoID,
TeamID = pair.TeamID,
AllowRead = true,
AllowWrite = true,
};
ctx.TeamRepositoryRoles.Add(role);
ctx.SaveChanges();
return(role);
}
}
public TeamListModel GetTeamList(string keyword, int page, int pagesize = 20)
{
using (var ctx = new GitCandyContext())
{
var query = ctx.Teams.AsQueryable();
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(s => s.Name.Contains(keyword) ||
s.Description.Contains(keyword));
}
query = query.OrderBy(s => s.Name);
var model = new TeamListModel
{
Teams = query
.Skip((page - 1) * pagesize)
.Take(pagesize)
.Select(s => new TeamModel
{
Name = s.Name,
Description = s.Description,
})
.ToArray(),
CurrentPage = page,
ItemCount = query.Count(),
};
return(model);
}
}
public User Login(string id, string password)
{
using (var ctx = new GitCandyContext())
{
var user = ctx.Users.FirstOrDefault(s => s.Name == id || s.Email == id);
if (user != null)
{
using (var pp1 = PasswordProviderPool.Take(user.PasswordVersion))
if (user.Password == pp1.Compute(user.ID, user.Name, password))
{
if (user.PasswordVersion != PasswordProviderPool.LastVersion)
{
using (var pp2 = PasswordProviderPool.Take())
{
user.Password = pp2.Compute(user.ID, user.Name, password);
user.PasswordVersion = pp2.Version;
ctx.SaveChanges();
}
}
return(user);
}
}
return(null);
}
}
public TeamModel GetTeamModel(string name, bool withMembers = false, string viewUser = null)
{
using (var ctx = new GitCandyContext())
{
var team = ctx.Teams.FirstOrDefault(s => s.Name == name);
if (team == null)
{
return(null);
}
var model = new TeamModel
{
Name = team.Name,
Description = team.Description,
};
if (withMembers)
{
model.MembersRole = ctx.UserTeamRoles
.Where(s => s.TeamID == team.ID)
.Select(s => new TeamModel.UserRole
{
Name = s.User.Name,
IsAdministrator = s.IsAdministrator
})
.AsEnumerable()
.OrderBy(s => s.Name, new StringLogicalComparer())
.ToArray();
model.Members = model.MembersRole
.Select(s => s.Name)
.ToArray();
model.RepositoriesRole = ctx.TeamRepositoryRoles
// belong team
.Where(s => s.TeamID == team.ID)
// can view for viewUser
.Where(s => !s.Repository.IsPrivate ||
viewUser != null &&
(ctx.Users.Any(t => t.Name == viewUser && t.IsSystemAdministrator) ||
ctx.UserRepositoryRoles.Any(t => t.RepositoryID == s.RepositoryID &&
t.User.Name == viewUser &&
t.AllowRead) ||
ctx.TeamRepositoryRoles.Any(t => t.RepositoryID == s.RepositoryID &&
t.Team.UserTeamRoles.Any(r => r.User.Name == viewUser) &&
t.AllowRead)))
.Select(s => new TeamModel.RepositoryRole
{
Name = s.Repository.Name,
AllowRead = s.AllowRead,
AllowWrite = s.AllowWrite,
})
.AsEnumerable()
.OrderBy(s => s.Name, new StringLogicalComparer())
.ToArray();
model.Repositories = model.RepositoriesRole
.Select(s => s.Name)
.ToArray();
}
return(model);
}
}
public UserListModel GetUserList(string keyword, int page, int pagesize = 20)
{
using (var ctx = new GitCandyContext())
{
var query = ctx.Users.AsQueryable();
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(s => s.Name.Contains(keyword) ||
s.Nickname.Contains(keyword) ||
s.Email.Contains(keyword) ||
s.Description.Contains(keyword));
}
query = query.OrderBy(s => s.Name);
var model = new UserListModel
{
Users = query
.Skip((page - 1) * pagesize)
.Take(pagesize)
.Select(user => new UserModel
{
Name = user.Name,
Nickname = user.Nickname,
Email = user.Email,
Description = user.Description,
IsSystemAdministrator = user.IsSystemAdministrator,
})
.ToArray(),
CurrentPage = page,
ItemCount = query.Count(),
};
return(model);
}
}
public bool HasSshKey(string fingerprint)
{
using (var ctx = new GitCandyContext())
{
return(ctx.SshKeys.Any(s => s.Fingerprint == fingerprint));
}
}
public string AddSshKey(string name, string sshkey)
{
var seg = sshkey.Split();
var type = seg[0];
sshkey = seg[1];
var fingerprint = KeyUtils.GetFingerprint(sshkey);
using (var ctx = new GitCandyContext())
{
var user = ctx.Users.FirstOrDefault(s => s.Name == name);
if (user == null)
{
return(null);
}
var key = new SshKey
{
UserID = user.ID,
KeyType = type,
Fingerprint = fingerprint,
PublicKey = sshkey,
ImportData = DateTime.UtcNow,
LastUse = DateTime.UtcNow,
};
ctx.SshKeys.Add(key);
ctx.SaveChanges();
}
return(fingerprint);
}
public bool RepositoryTeamSetValue(string reponame, string teamname, string field, bool value)
{
using (var ctx = new GitCandyContext())
{
var role = ctx.TeamRepositoryRoles.FirstOrDefault(s => s.Repository.Name == reponame && s.Team.Name == teamname);
if (role == null)
{
return(false);
}
if (field == "read")
{
role.AllowRead = value;
}
else if (field == "write")
{
role.AllowWrite = value;
}
else
{
return(false);
}
ctx.SaveChanges();
return(true);
}
}
public RepositoryModel GetRepositoryModel(string name, bool withShipment = false)
{
using (var ctx = new GitCandyContext())
{
var repo = ctx.Repositories.FirstOrDefault(s => s.Name == name);
if (repo == null)
{
return(null);
}
var model = new RepositoryModel
{
Name = repo.Name,
Description = repo.Description,
IsPrivate = repo.IsPrivate,
AllowAnonymousRead = repo.AllowAnonymousRead,
AllowAnonymousWrite = repo.AllowAnonymousWrite,
};
if (withShipment)
{
model.Collaborators = repo.UserRepositoryRoles
.Select(s => s.User.Name)
.OrderBy(s => s, new StringLogicalComparer())
.ToArray();
model.Teams = repo.TeamRepositoryRoles
.Select(s => s.Team.Name)
.OrderBy(s => s, new StringLogicalComparer())
.ToArray();
}
return(model);
}
}
public Token GetToken(Guid authCode)
{
using (var ctx = new GitCandyContext())
{
var meta = ctx.AuthorizationLogs
.Where(s => s.AuthCode == authCode && s.IsValid)
.Select(s => new
{
s.AuthCode,
s.Expires,
s.User.ID,
s.User.Name,
s.User.Nickname,
s.User.IsSystemAdministrator,
s.LastIp,
})
.FirstOrDefault();
return(meta == null
? null
: new Token(meta.AuthCode, meta.ID, meta.Name, meta.Nickname, meta.IsSystemAdministrator, meta.Expires)
{
LastIp = meta.LastIp
});
}
}
public bool IsTeamAdministrator(string teamname, string username)
{
using (var ctx = new GitCandyContext())
{
var role = ctx.UserTeamRoles.FirstOrDefault(s => s.Team.Name == teamname && s.User.Name == username);
return(role != null && role.IsAdministrator);
}
}
public bool IsRepositoryAdministrator(string reponame, string username)
{
using (var ctx = new GitCandyContext())
{
var role = ctx.UserRepositoryRoles.FirstOrDefault(s => s.Repository.Name == reponame && s.User.Name == username);
return(role != null && role.IsOwner);
}
}
public void DeleteSshKey(string name, string sshkey)
{
using (var ctx = new GitCandyContext())
{
var key = ctx.SshKeys.FirstOrDefault(s => s.User.Name == name && s.Fingerprint == sshkey);
ctx.SshKeys.Remove(key);
ctx.SaveChanges();
}
}
public void SetAuthorizationAsInvalid(Guid authCode)
{
using (var ctx = new GitCandyContext())
{
var auth = ctx.AuthorizationLogs.FirstOrDefault(s => s.AuthCode == authCode);
if (auth != null)
{
auth.IsValid = false;
ctx.SaveChanges();
}
}
}
public void UpdateAuthorization(Guid authCode, DateTime expires, string lastIp)
{
using (var ctx = new GitCandyContext())
{
var auth = ctx.AuthorizationLogs.FirstOrDefault(s => s.AuthCode == authCode);
if (auth != null)
{
auth.Expires = expires;
auth.LastIp = lastIp;
ctx.SaveChanges();
}
}
}
public string[] SearchTeam(string query)
{
using (var ctx = new GitCandyContext())
{
var length = query.Length + 0.5;
return(ctx.Teams
.Where(s => s.Name.Contains(query))
.OrderByDescending(s => length / s.Name.Length)
.ThenBy(s => s.Name)
.Take(10)
.Select(s => s.Name)
.ToArray());
}
}
public bool UpdateTeam(TeamModel model)
{
using (var ctx = new GitCandyContext())
{
var team = ctx.Teams.FirstOrDefault(s => s.Name == model.Name);
if (team != null)
{
team.Description = model.Description;
ctx.SaveChanges();
return(true);
}
return(false);
}
}
public RepositoryModel GetRepositoryModel(string reponame, bool withShipment = false, string username = null)
{
using (var ctx = new GitCandyContext())
{
var repo = ctx.Repositories.FirstOrDefault(s => s.Name == reponame);
if (repo == null)
{
return(null);
}
var model = new RepositoryModel
{
Name = repo.Name,
Description = repo.Description,
IsPrivate = repo.IsPrivate,
AllowAnonymousRead = repo.AllowAnonymousRead,
AllowAnonymousWrite = repo.AllowAnonymousWrite,
};
if (withShipment || username != null)
{
var tempList = ctx.UserRepositoryRoles
.Where(s => s.Repository.Name == reponame)
.Select(s => new { s.User.Name, s.IsOwner, Kind = true })
.Concat(ctx.TeamRepositoryRoles
.Where(s => s.Repository.Name == reponame)
.Select(s => new { s.Team.Name, IsOwner = false, Kind = false }))
.ToList();
if (withShipment)
{
model.Collaborators = tempList
.Where(s => s.Kind)
.Select(s => s.Name)
.OrderBy(s => s, new StringLogicalComparer())
.ToArray();
model.Teams = tempList
.Where(s => !s.Kind)
.Select(s => s.Name)
.OrderBy(s => s, new StringLogicalComparer())
.ToArray();
}
if (username != null)
{
model.CurrentUserIsOwner = tempList
.Any(s => s.Kind && s.IsOwner && s.Name == username);
}
}
return(model);
}
}
public void Delete(string name)
{
using (var ctx = new GitCandyContext())
{
var repo = ctx.Repositories.FirstOrDefault(s => s.Name == name);
if (repo != null)
{
repo.TeamRepositoryRoles.Clear();
repo.UserRepositoryRoles.Clear();
ctx.Repositories.Remove(repo);
ctx.SaveChanges();
}
}
}
public void DeleteTeam(string name)
{
using (var ctx = new GitCandyContext())
{
var team = ctx.Teams.FirstOrDefault(s => s.Name == name);
if (team != null)
{
team.UserTeamRoles.Clear();
team.TeamRepositoryRoles.Clear();
ctx.Teams.Remove(team);
ctx.SaveChanges();
}
}
}
public UserModel GetUserModel(string name, bool withMembers = false, string viewUser = null)
{
using (var ctx = new GitCandyContext())
{
var user = ctx.Users.FirstOrDefault(s => s.Name == name);
if (user == null)
{
return(null);
}
var model = new UserModel
{
Name = user.Name,
Nickname = user.Nickname,
Email = user.Email,
Description = user.Description,
IsSystemAdministrator = user.IsSystemAdministrator,
};
if (withMembers)
{
model.Teams = ctx.UserTeamRoles
.Where(s => s.User.ID == user.ID)
.Select(s => s.Team.Name)
.AsEnumerable()
.OrderBy(s => s, new StringLogicalComparer())
.ToArray();
model.Respositories = ctx.UserRepositoryRoles
// belong user
.Where(s => s.User.ID == user.ID && s.IsOwner)
// can view for viewUser
.Where(s => !s.Repository.IsPrivate ||
viewUser != null &&
(ctx.Users.Any(t => t.Name == viewUser && t.IsSystemAdministrator) ||
ctx.UserRepositoryRoles.Any(t => t.RepositoryID == s.RepositoryID &&
t.User.Name == viewUser &&
t.AllowRead) ||
ctx.TeamRepositoryRoles.Any(t => t.RepositoryID == s.RepositoryID &&
t.Team.UserTeamRoles.Any(r => r.User.Name == viewUser) &&
t.AllowRead)))
.Select(s => s.Repository.Name)
.AsEnumerable()
.OrderBy(s => s, new StringLogicalComparer())
.ToArray();
}
return(model);
}
}
public bool CanWriteRepository(string reponame, string username)
{
using (var ctx = new GitCandyContext())
{
var q0 = ctx.Repositories.Where(s => s.Name == reponame && s.AllowAnonymousRead && s.AllowAnonymousWrite).Select(s => 0);
if (string.IsNullOrEmpty(username))
{
return(q0.Any());
}
var q1 = ctx.UserRepositoryRoles.Where(s => s.Repository.Name == reponame && s.User.Name == username && s.AllowRead && s.AllowWrite).Select(s => 0);
var q2 = ctx.TeamRepositoryRoles.Where(s => s.Repository.Name == reponame && s.Team.UserTeamRoles.Any(t => t.User.Name == username) && s.AllowRead && s.AllowWrite).Select(s => 0);
return(q0.Concat(q1).Concat(q2).Any());
}
}
public bool RepositoryRemoveTeam(string reponame, string teamname)
{
using (var ctx = new GitCandyContext())
{
var role = ctx.TeamRepositoryRoles.FirstOrDefault(s => s.Repository.Name == reponame && s.Team.Name == teamname);
if (role == null)
{
return(false);
}
ctx.TeamRepositoryRoles.Remove(role);
ctx.SaveChanges();
return(true);
}
}
public void DeleteUser(string name)
{
using (var ctx = new GitCandyContext())
{
var user = ctx.Users.FirstOrDefault(s => s.Name == name);
if (user != null)
{
user.UserTeamRoles.Clear();
user.UserRepositoryRoles.Clear();
user.AuthorizationLogs.Clear();
ctx.Users.Remove(user);
ctx.SaveChanges();
}
}
}
public User CreateAccount(string name, string nickname, string password, string email, string description, out bool badName, out bool badEmail)
{
badName = false;
badEmail = false;
using (var ctx = new GitCandyContext())
//using (TransactionScope transaction = new TransactionScope()) // I don't know why Sqlite not support for TransactionScope
{
try
{
var list = ctx.Users.Where(s => s.Name == name || s.Email == email).ToList();
badName = list.Any(s => string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase));
badEmail = list.Any(s => string.Equals(s.Email, email, StringComparison.OrdinalIgnoreCase));
if (badName || badEmail)
{
return(null);
}
var user = new User
{
Name = name,
Nickname = nickname,
Email = email,
PasswordVersion = -1,
Password = "",
Description = description,
CreationDate = DateTime.UtcNow,
};
ctx.Users.Add(user);
ctx.SaveChanges();
using (var pp = PasswordProviderPool.Take())
{
user.PasswordVersion = pp.Version;
user.Password = pp.Compute(user.ID, name, password);
}
ctx.SaveChanges();
//transaction.Complete();
return(user);
}
catch
{
return(null);
}
}
}
public bool TeamUserSetAdministrator(string teamname, string username, bool isAdmin)
{
using (var ctx = new GitCandyContext())
{
var role = ctx.UserTeamRoles.FirstOrDefault(s => s.Team.Name == teamname && s.User.Name == username);
if (role == null)
{
return(false);
}
role.IsAdministrator = isAdmin;
ctx.SaveChanges();
return(true);
}
}
public bool TeamRemoveUser(string teamname, string username)
{
using (var ctx = new GitCandyContext())
{
var role = ctx.UserTeamRoles.FirstOrDefault(s => s.Team.Name == teamname && s.User.Name == username);
if (role == null)
{
return(false);
}
ctx.UserTeamRoles.Remove(role);
ctx.SaveChanges();
return(true);
}
}
public SshModel GetSshList(string name)
{
using (var ctx = new GitCandyContext())
{
var keys = ctx.SshKeys
.Where(s => s.User.Name == name)
.Select(s => new SshModel.SshKey {
Name = s.Fingerprint
})
.ToArray();
return(new SshModel {
Username = name, SshKeys = keys
});
}
}
public bool UpdateUser(UserModel model)
{
using (var ctx = new GitCandyContext())
{
var user = ctx.Users.FirstOrDefault(s => s.Name == model.Name);
if (user != null)
{
user.Nickname = model.Nickname;
user.Email = model.Email;
user.Description = model.Description;
user.IsSystemAdministrator = model.IsSystemAdministrator;
ctx.SaveChanges();
return(true);
}
return(false);
}
}
