public bool Create(RepositoryModel model)
{
if (model == null) throw new ArgumentException("model");
if (model.Name == null) throw new ArgumentException("name");
using (var database = new DataEntities())
{
var repository = new Repository
{
Name = model.Name,
Description = model.Description,
Anonymous = model.AnonymousAccess,
};
database.AddToRepository(repository);
AddMembers(model.Users, model.Administrators, model.Teams, repository, database);
try
{
database.SaveChanges();
}
catch (UpdateException)
{
return false;
}
}
return true;
}
public bool Create(TeamModel model)
{
if (model == null) throw new ArgumentException("team");
if (model.Name == null) throw new ArgumentException("name");
using (var database = new DataEntities())
{
var team = new Team
{
Name = model.Name,
Description = model.Description
};
database.AddToTeam(team);
if (model.Members != null)
{
AddMembers(model.Members, team, database);
}
try
{
database.SaveChanges();
}
catch (UpdateException)
{
return false;
}
}
return true;
}
public bool CreateUser(string username, string password, string name, string surname, string email)
{
if (String.IsNullOrEmpty(username)) throw new ArgumentException("Value cannot be null or empty.", "userName");
if (String.IsNullOrEmpty(password)) throw new ArgumentException("Value cannot be null or empty.", "password");
if (String.IsNullOrEmpty(name)) throw new ArgumentException("Value cannot be null or empty.", "name");
if (String.IsNullOrEmpty(surname)) throw new ArgumentException("Value cannot be null or empty.", "surname");
if (String.IsNullOrEmpty(email)) throw new ArgumentException("Value cannot be null or empty.", "email");
using (var database = new DataEntities())
{
var user = new User
{
Username = username,
Password = EncryptPassword(password),
Name = name,
Surname = surname,
Email = email,
};
database.AddToUser(user);
try
{
database.SaveChanges();
}
catch (UpdateException)
{
return false;
}
}
return true;
}
public IList<UserModel> GetAllUsers()
{
using (var db = new DataEntities())
{
return db.User.Include("Roles")
.Select(this.CreateViewModel)
.ToList();
}
}
public override void CreateRole(string roleName)
{
using (var database = new DataEntities())
{
database.AddToRole(new Role
{
Name = roleName,
});
}
}
public IList<TeamModel> GetAllTeams()
{
using (var db = new DataEntities())
{
return db.Team.Include("Members")
.Include("Repositories")
.Select(this.CreateViewModel)
.ToList();
}
}
public IList<Models.RepositoryModel> GetAllRepositories()
{
using (var db = new DataEntities())
{
return db.Repository.Include("Users")
.Include("Administrators")
.Include("Teams")
.Select(this.ConvertToModel)
.ToList();
}
}
public UserModel GetUser(string username)
{
if (String.IsNullOrEmpty(username)) throw new ArgumentException("Value cannot be null or empty.", "userName");
using (var db = new DataEntities())
{
return db.User.Include("Roles")
.Where(user => user.Username == username)
.Select(this.CreateViewModel)
.FirstOrDefault();
}
}
public IList<Models.RepositoryModel> GetAllRepositories()
{
using (var db = new DataEntities())
{
var result = new List<RepositoryModel>();
foreach (var item in db.Repository)
{
result.Add(ConvertToModel(item));
}
return result;
}
}
public TeamModel GetTeam(string name)
{
if (name == null) throw new ArgumentException("name");
using (var db = new DataEntities())
{
return db.Team.Include("Members")
.Include("Repositories")
.Where(team => team.Name == name)
.Select(this.CreateViewModel)
.FirstOrDefault();
}
}
public IList<RepositoryModel> GetAdministratedRepositories(string username)
{
if (username == null) throw new ArgumentException("username");
using (var db = new DataEntities())
{
return db.Repository.Include("Users")
.Include("Administrators")
.Include("Teams")
.Where(repo => repo.Administrators.Any(admin => admin.Name == username))
.Select(this.ConvertToModel)
.ToList();
}
}
public TeamModel GetTeam(string name)
{
if (name == null) throw new ArgumentException("name");
using (var db = new DataEntities())
{
var team = db.Team.FirstOrDefault(i => i.Name == name);
return team == null ? null : new TeamModel
{
Name = team.Name,
Description = team.Description,
Members = team.Members.Select(m => m.Username).ToArray(),
Repositories = team.Repositories.Select(m => m.Name).ToArray(),
};
}
}
public void DeleteUser(string username)
{
using (var database = new DataEntities())
{
var user = database.User.FirstOrDefault(i => i.Username == username);
if (user != null)
{
user.AdministratedRepositories.Clear();
user.Roles.Clear();
user.Repositories.Clear();
user.Teams.Clear();
database.DeleteObject(user);
database.SaveChanges();
}
}
}
public void Delete(string name)
{
if (name == null) throw new ArgumentException("name");
using (var db = new DataEntities())
{
var team = db.Team.FirstOrDefault(i => i.Name == name);
if (team != null)
{
team.Repositories.Clear();
team.Members.Clear();
db.DeleteObject(team);
db.SaveChanges();
}
}
}
public void Delete(string name)
{
if (name == null) throw new ArgumentException("name");
using (var db = new DataEntities())
{
var repo = db.Repository.FirstOrDefault(i => i.Name == name);
if (repo != null)
{
repo.Administrators.Clear();
repo.Users.Clear();
repo.Teams.Clear();
db.DeleteObject(repo);
db.SaveChanges();
}
}
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
var result = new HashSet<string>();
using (var database = new DataEntities())
{
var matchingRoles = database.Role.Where(i => i.Name == roleName && i.Users.Where(user => user.Username.Contains(usernameToMatch)).Count() > 0);
var usernames = matchingRoles.Select(i => i.Users.Select(u => u.Username));
foreach (var roleUsernames in usernames)
{
foreach (var username in roleUsernames)
{
result.Add(username);
}
}
}
return result.ToArray();
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
using (var database = new DataEntities())
{
var roles = database.Role.Where(i => roleNames.Contains(i.Name));
var users = database.User.Where(i => usernames.Contains(i.Username));
foreach (var role in roles)
{
foreach (var user in users)
{
role.Users.Add(user);
}
}
database.SaveChanges();
}
}
public IList<UserModel> GetAllUsers()
{
using (var db = new DataEntities())
{
var result = new List<UserModel>();
foreach (var item in db.User)
{
result.Add(new UserModel
{
Username = item.Username,
Name = item.Name,
Surname = item.Surname,
Email = item.Email,
Roles = item.Roles.Select(i => i.Name).ToArray(),
});
}
return result;
}
}
public IList<TeamModel> GetAllTeams()
{
using (var db = new DataEntities())
{
var result = new List<TeamModel>();
foreach (var item in db.Team)
{
result.Add(new TeamModel
{
Name = item.Name,
Description = item.Description,
Members = item.Members.Select(i => i.Username).ToArray(),
Repositories = item.Repositories.Select(m => m.Name).ToArray(),
});
}
return result;
}
}
public void Delete(string name)
{
if (name == null)
{
throw new ArgumentException("name");
}
using (var db = new DataEntities())
{
var repo = db.Repository.FirstOrDefault(i => i.Name == name);
if (repo != null)
{
repo.Administrators.Clear();
repo.Users.Clear();
repo.Teams.Clear();
db.DeleteObject(repo);
db.SaveChanges();
}
}
}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
using (var database = new DataEntities())
{
var role = database.Role.FirstOrDefault(i => i.Name == roleName);
if (role != null)
{
if (throwOnPopulatedRole)
{
if (role.Users.Count > 0)
{
throw new InvalidOperationException("Can't delete role with members.");
}
}
database.DeleteObject(role);
database.SaveChanges();
return true;
}
return false;
}
}
private void AddMembers(string[] users, string[] admins, string[] teams, Repository repo, DataEntities database)
{
if (admins != null)
{
var administrators = database.User.Where(i => admins.Contains(i.Username));
foreach (var item in administrators)
{
repo.Administrators.Add(item);
}
}
if (users != null)
{
var permittedUsers = database.User.Where(i => users.Contains(i.Username));
foreach (var item in permittedUsers)
{
repo.Users.Add(item);
}
}
if (teams != null)
{
var permittedTeams = database.Team.Where(i => teams.Contains(i.Name));
foreach (var item in permittedTeams)
{
repo.Teams.Add(item);
}
}
}
private void AddMembers(string[] members, Team team, DataEntities database)
{
var users = database.User.Where(i => members.Contains(i.Username));
foreach (var item in users)
{
team.Members.Add(item);
}
}
public void Update(TeamModel model)
{
if (model == null) throw new ArgumentException("team");
if (model.Name == null) throw new ArgumentException("name");
using (var db = new DataEntities())
{
var team = db.Team.FirstOrDefault(i => i.Name == model.Name);
if (team != null)
{
team.Description = model.Description;
team.Members.Clear();
if (model.Members != null)
{
AddMembers(model.Members, team, db);
}
db.SaveChanges();
}
}
}
public IList<RepositoryModel> GetPermittedRepositories(string username, string[] teams)
{
if (username == null) throw new ArgumentException("username");
using (var db = new DataEntities())
{
return db.Repository.Include("Users")
.Include("Administrators")
.Include("Teams")
.Where(repo => repo.Administrators.Any(admin => admin.Name == username)
|| repo.Users.Any(user => user.Name == username)
|| repo.Teams.Any(team => teams.Contains(team.Name))
|| repo.Anonymous)
.Select(this.ConvertToModel)
.ToList();
}
}
public override string[] GetAllRoles()
{
using (var database = new DataEntities())
{
return database.Role.Select(i => i.Name).ToArray();
}
}
public void Update(RepositoryModel model)
{
if (model == null) throw new ArgumentException("model");
if (model.Name == null) throw new ArgumentException("name");
using (var db = new DataEntities())
{
var repo = db.Repository.FirstOrDefault(i => i.Name == model.Name);
if (repo != null)
{
repo.Description = model.Description;
repo.Anonymous = model.AnonymousAccess;
repo.Users.Clear();
repo.Teams.Clear();
repo.Administrators.Clear();
AddMembers(model.Users, model.Administrators, model.Teams, repo, db);
db.SaveChanges();
}
}
}
public RepositoryModel GetRepository(string name)
{
if (name == null) throw new ArgumentException("name");
using (var db = new DataEntities())
{
return db.Repository.Include("Users")
.Include("Administrators")
.Include("Teams")
.Where(repo => repo.Name == name)
.Select(this.ConvertToModel)
.FirstOrDefault();
}
}
public void UpdateUser(string username, string name, string surname, string email, string password)
{
using (var database = new DataEntities())
{
var user = database.User.FirstOrDefault(i => i.Username == username);
if (user != null)
{
user.Name = name ?? user.Name;
user.Surname = surname ?? user.Surname;
user.Email = email ?? user.Email;
user.Password = password != null ? EncryptPassword(password) : user.Password;
database.SaveChanges();
}
}
}
public UserModel GetUser(string username)
{
if (String.IsNullOrEmpty(username)) throw new ArgumentException("Value cannot be null or empty.", "userName");
using (var db = new DataEntities())
{
var user = db.User.FirstOrDefault(i => i.Username == username);
return user == null ? null : new UserModel
{
Username = user.Username,
Name = user.Name,
Surname = user.Surname,
Email = user.Email,
Roles = user.Roles.Select(i => i.Name).ToArray(),
};
}
}
private void AddMembers(string[] users, string[] admins, string[] teams, Repository repo, DataEntities database)
{
if (admins != null)
{
var administrators = database.User.Where(i => admins.Contains(i.Username));
foreach (var item in administrators)
{
repo.Administrators.Add(item);
}
}
if (users != null)
{
var permittedUsers = database.User.Where(i => users.Contains(i.Username));
foreach (var item in permittedUsers)
{
repo.Users.Add(item);
}
}
if (teams != null)
{
var permittedTeams = database.Team.Where(i => teams.Contains(i.Name));
foreach (var item in permittedTeams)
{
repo.Teams.Add(item);
}
}
}
public bool ValidateUser(string username, string password)
{
if (String.IsNullOrEmpty(username)) throw new ArgumentException("Value cannot be null or empty.", "userName");
if (String.IsNullOrEmpty(password)) throw new ArgumentException("Value cannot be null or empty.", "password");
using (var database = new DataEntities())
{
var user = database.User.FirstOrDefault(i => i.Username == username);
return user != null && ComparePassword(password, user.Password);
}
}
