public DocumentPermissionModel(ProtectedDocument document)
: this()
{
Path = document.Path;
GroupIds = document.ProtectedDocumentGroups.Select(d => d.UserGroupId).ToList();
CompanyIds = document.ProtectedDocumentCompanies.Select(d => d.CompanyId).ToList();
CompanyTypeIds = document.ProtectedDocumentCompanyTypes.Select(d => d.CompanyTypeId).ToList();
}
public void ThrowsUnauthorizedExceptionGivenUserNotInAuthorRole()
{
var editor = new User {
Role = Roles.Editor
};
var document = new ProtectedDocument(TestConstants.TEST_DOCUMENT_NAME, TestConstants.TEST_DOCUMENT_CONTENT);
Assert.Throws <UnauthorizedAccessException>(() => document.UpdateName(TestConstants.TEST_DOCUMENT_NAME, editor));
}
public async Task <IActionResult> Edit(string title)
{
ProtectedDocument doc = docs.FirstOrDefault(d => d.Title == title);
AuthorizationResult authorized = await authService.AuthorizeAsync(User, doc, "AuthorsAndEditors");
if (authorized.Succeeded)
{
return(View("Index", doc));
}
else
{
return(new ChallengeResult());
}
}
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, DocumentAuthorizationRequirement requirement)
{
ProtectedDocument doc = context.Resource as ProtectedDocument;
string user = context.User.Identity.Name;
StringComparison compare = StringComparison.OrdinalIgnoreCase;
if (doc != null && user != null && (requirement.AllowAuthors && doc.Author.Equals(user, compare)) ||
(requirement.AllowEditors && doc.Editor.Equals(user, compare)))
{
context.Succeed(requirement);
}
else
{
context.Fail();
}
return(Task.CompletedTask);
}
protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, DocumentAuthorizationRequirement requirement)
{
ProtectedDocument doc = context.Resource as ProtectedDocument;
string user = context.User.Identity.Name;
if (doc != null && user != null &&
(
requirement.AllowAuthors && doc.Author.Equals(user) ||
requirement.AllowEditors && doc.Editor.Equals(user)
))
{
context.Succeed(requirement);
}
else
{
context.Fail();
}
await Task.CompletedTask;
}
internal ResponseModel Delete(ProtectedDocument protectedDocument)
{
return(_protectedDocumentRepository.Delete(protectedDocument));
}
internal ResponseModel Insert(ProtectedDocument protectedDocument)
{
return(_protectedDocumentRepository.Insert(protectedDocument));
}
/// <summary>
/// Save document permissions
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel SaveDocumentPermissionManageModel(DocumentPermissionManageModel model)
{
var protectedDocument = GetByEncryptPath(model.EncryptedPath);
if (protectedDocument != null)
{
#region User Groups
if (model.GroupIds == null)
{
model.GroupIds = new List <int>();
}
var currentGroups = protectedDocument.ProtectedDocumentGroups.Select(p => p.UserGroupId).ToList();
// Remove groups
var removedGroupIds = currentGroups.Where(g => !model.GroupIds.Contains(g)).ToList();
_protectedDocumentGroupRepository.Delete(protectedDocument.Id, removedGroupIds);
// Add new groups
var addedGroupIds = model.GroupIds.Where(id => !currentGroups.Contains(id)).ToList();
_protectedDocumentGroupRepository.Insert(protectedDocument.Id, addedGroupIds);
#endregion
#region Company
if (model.CompanyIds == null)
{
model.CompanyIds = new List <int>();
}
var currentCompanies = protectedDocument.ProtectedDocumentCompanies.Select(p => p.CompanyId).ToList();
// Remove companies
var removedCompanyIds = currentCompanies.Where(id => !model.CompanyIds.Contains(id)).ToList();
_protectedDocumentCompanyRepository.Delete(protectedDocument.Id, removedCompanyIds);
// Add new companies
var addedCompanyIds = model.CompanyIds.Where(id => !currentCompanies.Contains(id)).ToList();
_protectedDocumentCompanyRepository.Insert(protectedDocument.Id, addedCompanyIds);
#endregion
#region Company Types
if (model.CompanyTypeIds == null)
{
model.CompanyTypeIds = new List <int>();
}
var currentCompanyTypes =
protectedDocument.ProtectedDocumentCompanyTypes.Select(p => p.CompanyTypeId).ToList();
// Remove company types
var removedCompanyTypeIds = currentCompanyTypes.Where(id => !model.CompanyTypeIds.Contains(id)).ToList();
_protectedDocumentCompanyTypeRepository.Delete(protectedDocument.Id, removedCompanyTypeIds);
// Add new company types
var addedCompanyTypeIds = model.CompanyTypeIds.Where(id => !currentCompanyTypes.Contains(id)).ToList();
_protectedDocumentCompanyTypeRepository.Insert(protectedDocument.Id, addedCompanyTypeIds);
#endregion
return(new ResponseModel
{
Success = true,
Message = T("ProtectedDocument_Message_UpdateSuccessfully")
});
}
protectedDocument = new ProtectedDocument
{
Path = model.EncryptedPath.GetUniqueLinkInput()
};
var response = Insert(protectedDocument);
if (response.Success)
{
#region User Groups
if (model.GroupIds == null)
{
model.GroupIds = new List <int>();
}
_protectedDocumentGroupRepository.Insert(protectedDocument.Id, model.GroupIds);
#endregion
#region Company
if (model.CompanyIds == null)
{
model.CompanyIds = new List <int>();
}
_protectedDocumentCompanyRepository.Insert(protectedDocument.Id, model.CompanyIds);
#endregion
#region Company Types
if (model.CompanyTypeIds == null)
{
model.CompanyTypeIds = new List <int>();
}
_protectedDocumentCompanyTypeRepository.Insert(protectedDocument.Id, model.CompanyTypeIds);
#endregion
return(response.SetMessage(response.Success
? T("ProtectedDocument_Message_UpdateSuccessfully")
: T("ProtectedDocument_Message_UpdateFailure")));
}
return(new ResponseModel
{
Success = false,
Message = T("ProtectedDocument_Message_UpdateFailure")
});
}
