public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
// Die Bearbeitenfunktion für Projekte steht nur Admins und Projektowner zur Verfügung
var roles = _context.ProjectRoles.ToList().FindAll(i => i.ProjectId == id);
ProjectRoles owner = roles.Find(o => o.ProjectRole == "Owner");
IdentityUser user = await _userManager.FindByIdAsync(owner.UserId);
bool isAdmin = await _userManager.IsInRoleAsync(user, "Admin");
// Fehlermeldung, falls der User kein Admin oder Projektowner ist
if (user.UserName != this.User.Identity.Name && !isAdmin)
{
return(RedirectToAction("ErrorMessage", new { ID = 1 }));
}
IvA.Models.ProjekteModel projekte = await _context.Projekte.FindAsync(id);
if (projekte == null)
{
return(NotFound());
}
return(View(projekte));
}
public async Task <IActionResult> CreateRole([FromBody] ProjectRoleDto role)
{
if (role == null)
{
return(BadRequest());
}
var newRole = new ProjectRoles {
Name = role.Name, System = false
};
_db.ProjectRoles.Add(newRole);
await _db.SaveChangesAsync();
if (role.Permissions != null)
{
var permissionSlugs = role.Permissions.Select(p => p.ProjectPermissionSlug);
var existingPermissions = await _db.ProjectPermissions.Where(p => permissionSlugs.Contains(p.ProjectPermissionSlug)).ToListAsync();
_db.ProjectRolePermissions.AddRange(existingPermissions.Select(p => new ProjectRolePermissions {
ProjectRoleId = newRole.ProjectRoleId, ProjectPermissionSlug = p.ProjectPermissionSlug
}));
await _db.SaveChangesAsync();
}
return(Ok(new ProjectRoleDto(newRole)));
}
private static object CreateProjectRoles(ProjectRoles projectRoles)
{
return(projectRoles.Rights.Select(kvp => new
{
name = kvp.Key,
rights = kvp.Value.Select(r => r.Domain + (int)r.Operation).ToArray()
}).ToArray());
}
public ProjectRoleShortDto(ProjectRoles role)
{
if (role != null)
{
ProjectRoleId = role.ProjectRoleId;
Name = role.Name;
System = role.System;
}
}
public async Task <IActionResult> Create(ProjectRoles role)
{
var roleExist = await roleManager.RoleExistsAsync(role.RoleName);
if (!roleExist)
{
var result = await roleManager.CreateAsync(new IdentityRole(role.RoleName));
}
return(View());
}
// Weißt einem Nutzer eine neue Rolle innerhalb eines Projektes zu
public void ChangeUserProjectRole(string userId, int projectId, string role)
{
DeleteUserFromProjectRoles(userId, projectId);
ProjectRoles newRole = new ProjectRoles()
{
ProjectId = projectId,
ProjectRole = role,
UserId = userId
};
_context.Add(newRole);
}
public override Project GetModel(User currentUser)
{
return(new Project()
{
UserId = currentUser.UserId,
Name = Name,
ExternalSystemKey = ExternalSystemKey,
Archived = Archived,
ProjectRoles = ProjectRoles.Select(pr => pr.GetModel(currentUser)).ToList(),
ProjectTasks = ProjectTasks.Select(pt => pt.GetModel(currentUser)).ToList()
});
}
private async Task <IEnumerable <Claim> > getProjectRoleClaims(string projectName, string userName)
{
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
return(null);
}
string claimType = ProjectRoles.GetClaimType(projectName);
return((await _userManager.GetClaimsAsync(user)).Where(ll => ll.Type == claimType).ToList());
}
private async Task <Claim> getProjectRoleClaim(string projectName, string userName, eProjectRoles role)
{
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
return(null);
}
string claimType = ProjectRoles.GetClaimType(projectName);
var foo = await _userManager.GetClaimsAsync(user);
return(foo.FirstOrDefault(ll => ll.Type == claimType && ll.Value == role.ToString()));
}
public ProjectRoleDto(ProjectRoles role)
{
if (role != null)
{
ProjectRoleId = role.ProjectRoleId;
Name = role.Name;
System = role.System;
if (role.ProjectRolePermissions != null)
{
Permissions = role.ProjectRolePermissions.Where(rp => rp.ProjectPermissionSlugNavigation != null).Select(rp => new ProjectPermissionDto(rp.ProjectPermissionSlugNavigation));
}
}
}
public string AddProjectRole(ProjectRoleDto projectRoleDto)
{
using (UnitOfWork unitOfWork = new UnitOfWork(masterContext))
{
ProjectRoles projectRoles = new ProjectRoles()
{
Id = projectRoleDto.Id,
Projectid = projectRoleDto.Projectid,
Userid = projectRoleDto.Userid
};
unitOfWork.GetRepository <ProjectRoles>().Add(projectRoles);
unitOfWork.SaveChanges();
return("Kayıt başarılı");
}
}
public AddUserToProjectResponse AddUserToProject(AddUserToProjectRequest request)
{
var projectRoles = new ProjectRoles();
projectRoles.CreatedAt = DateTime.Now;
projectRoles.CreatedBy = 1;
projectRoles.IdentityId = request.IdentityId;
projectRoles.IdentityType = request.IdentityType;
projectRoles.ProjectId = request.ProjectId;
projectRoles.RoleId = request.RoleId;
_unitOfWork.ProjectRoleRepository.Insert(projectRoles);
_unitOfWork.ProjectRepository.Save();
return(new AddUserToProjectResponse());
}
public async Task <bool> AuthorizeProjectRole(eProjectRoles projectRole, string project, string author = "", ClaimsPrincipal user = null)
{
if (user == null)
{
if (!_httpContextAccessor.HttpContext.User.Identity.IsAuthenticated)
{
return(false);
}
user = _httpContextAccessor.HttpContext.User;
}
var policy = ProjectRoles.GetPolicy(projectRole);
var resource = new ProjectRoleAuthResource()
{
ProjectName = project, Author = author
};
return((await _authorizationService.AuthorizeAsync(user, resource, policy)).Succeeded);
}
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
ProjectRoleAuthRequirement requirement, ProjectRoleAuthResource resource)
{
if (resource == null)
{
return(Task.CompletedTask);
}
if (context.User.Identity.Name == resource.Author)
{
context.Succeed(requirement);
}
else if (context.User.HasClaim(claim => claim.Type == ProjectRoles.GetClaimType(resource.ProjectName) && claim.Value == requirement.ProjectRole.ToString()))
{
context.Succeed(requirement);
}
return(Task.CompletedTask);
}
public async Task <IActionResult> AddUserToProject([Bind("id,name")] AddUserModel userToProject)
{
// Die Methode steht nur Projektownern oder Admins zur Verfügung, sonst erscheit eine Fehlermeldung
var roles = _context.ProjectRoles.ToList().FindAll(i => i.ProjectId == userToProject.id);
ProjectRoles owner = roles.Find(o => o.ProjectRole == "Owner");
IdentityUser user = await _userManager.FindByIdAsync(owner.UserId);
bool isAdmin = await _userManager.IsInRoleAsync(user, "Admin");
if (user.UserName != this.User.Identity.Name && !isAdmin)
{
return(RedirectToAction("ErrorMessage", new { ID = 7 }));
}
// Die Zuorndung eines Nutzers zu einem Projekt wird in der Tabelle ProjekteUserViewModel gespeichert
if (userToProject.name != null)
{
IdentityUser newUser = await _userManager.FindByNameAsync(userToProject.name);
if (newUser != null)
{
ProjekteUserViewModel newUserInProject = new ProjekteUserViewModel()
{
ProjekteId = userToProject.id,
UserId = newUser.Id
};
_context.Add(newUserInProject);
ChangeUserProjectRole(newUser.Id, userToProject.id, "Nutzer");
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "Projekte", new { userToProject.id }));
}
else
{
return(RedirectToAction("ErrorMessage", new { ID = 6 }));
}
}
return(NotFound("Error beim Hinzufügen eines Projekts"));
}
private static async Task SeedProjectRoles(KMSDBContext db, string dirname, JsonSerializerSettings serializerSettings)
{
var rolesJson = await File.ReadAllTextAsync(Path.Combine(dirname, "project_roles.json"));
var roles = JsonConvert.DeserializeObject <List <RoleSerializer> >(rolesJson, serializerSettings);
foreach (var role in roles)
{
var dbRole = await db.ProjectRoles.SingleOrDefaultAsync(r => r.Name == role.Name && r.System == true);
if (dbRole == null)
{
dbRole = new ProjectRoles {
Name = role.Name, System = true
};
db.ProjectRoles.Add(dbRole);
await db.SaveChangesAsync();
}
foreach (var permission in role.Permissions)
{
var dbPermission = await db.ProjectPermissions.SingleOrDefaultAsync(p => p.ProjectPermissionSlug == permission);
var dbRolePermission = await db.ProjectRolePermissions.SingleOrDefaultAsync(rp => rp.ProjectRoleId == dbRole.ProjectRoleId && rp.ProjectPermissionSlug == permission);
if (dbPermission == null)
{
throw new Exception("Permission for role not found");
}
if (dbRolePermission == null)
{
db.ProjectRolePermissions.Add(new ProjectRolePermissions {
ProjectRoleId = dbRole.ProjectRoleId, ProjectPermissionSlug = permission
});
}
}
await db.SaveChangesAsync();
}
}
public async Task <IActionResult> Create([Bind("Id,Projektname,Projektersteller,Mitglieder,Beschreibung,Deadline,Status")] IvA.Models.ProjekteModel projekte)
{
if (ModelState.IsValid)
{
_context.Add(projekte);
//Status, Erstellungdatum, Mitglieder und Projektersteller werden automatisch gesetzt
projekte.ErstelltAm = DateTime.Now;
projekte.Status = "To Do";
projekte.Mitglieder = "";
projekte.Projektersteller = this.User.Identity.Name;
await _context.SaveChangesAsync();
// Projektersteller als Mitglied setzen
var userClaim = this.User;
var loggedUser = await _userManager.GetUserAsync(userClaim);
ProjekteUserViewModel firstMember = new ProjekteUserViewModel
{
ProjekteId = projekte.ProjekteId,
UserId = loggedUser.Id
};
_context.Add(firstMember);
// Projektersteller zum Owner ernennen
ProjectRoles owner = new ProjectRoles()
{
ProjectId = projekte.ProjekteId,
ProjectRole = "Owner",
UserId = loggedUser.Id
};
_context.Add(owner);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "Projekte", new { id = projekte.ProjekteId }));
}
return(View(projekte));
}
private async Task innerSetProjectRole(string projectName, string userName, eProjectRoles role)
{
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
throw new Exception($"User {userName} does not exist.");
}
var foo = await getProjectRoleClaim(projectName, userName, role);
if (foo != null)
{
return;
}
string claimType = ProjectRoles.GetClaimType(projectName);
var identityResult = await _userManager.AddClaimAsync(user, new Claim(claimType, role.ToString()));
if (!identityResult.Succeeded)
{
throw new Exception($"Error at removeProjectRole. Project: {projectName}, user: {userName}, role: {role} Errors: {string.Join(',', identityResult.Errors.Select(ll => ll.Description))}");
}
}