public async Task DeleteUsersAsync_UsersToDeleteDoNotExists_QueryReturnEmptyCollection()
{
// arrange
var cxn = new SqlConnectionWrapperMock();
var repository = new SqlUserRepository(cxn.Object, cxn.Object);
int[] userIds = { };
var operationScope = new OperationScope
{
Ids = userIds,
SelectAll = false
};
var userIdTable = SqlConnectionWrapper.ToDataTable(operationScope.Ids);
var returntResult = new List <int>();
cxn.SetupQueryAsync("DeleteUsers",
new Dictionary <string, object>
{
{ "UserIds", userIdTable },
{ "Search", "" },
{ "SessionUserId", 0 },
{ "SelectAll", operationScope.SelectAll }
},
returntResult);
// act
var result = await repository.DeleteUsersAsync(operationScope, string.Empty, 0, null);
// assert
cxn.Verify();
Assert.AreEqual(result.Count, returntResult.Count);
}
public async Task DeleteRoleAssignment_SuccessfulDeletionOfRoleAssignment_ReturnCountOfDeletedRoleAssignmentResult()
{
// Arrange
var totalDeletedItems = 1;
var scope = new OperationScope()
{
SelectAll = false, Ids = new List <int>()
{
2, 3
}
};
_privilegeRepositoryMock
.Setup(r => r.GetInstanceAdminPrivilegesAsync(UserId))
.ReturnsAsync(InstanceAdminPrivileges.AccessAllProjectsAdmin);
_privilegeRepositoryMock
.Setup(r => r.GetProjectAdminPermissionsAsync(UserId, ProjectId))
.ReturnsAsync(ProjectAdminPrivileges.ManageGroupsAndRoles);
_instanceRepositoryMock.Setup(repo => repo.DeleteRoleAssignmentsAsync(It.IsAny <int>(), It.Is <OperationScope>(a => a.Ids != null), It.IsAny <string>())).ReturnsAsync(totalDeletedItems);
// Act
var result = await _controller.DeleteRoleAssignment(ProjectId, scope, string.Empty) as OkNegotiatedContentResult <DeleteResult>;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(totalDeletedItems, result.Content.TotalDeleted);
}
public async Task <int> DeleteUserFromGroupsAsync(int userId, OperationScope body)
{
var parameters = new DynamicParameters();
parameters.Add("@UserId", userId);
parameters.Add("@SelectAll", body.SelectAll);
if (body.Ids != null)
{
parameters.Add("@GroupMembership", SqlConnectionWrapper.ToDataTable(body.Ids));
}
parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
var result = await _connectionWrapper.ExecuteScalarAsync <int>("DeleteUserFromGroups", parameters, commandType : CommandType.StoredProcedure);
var errorCode = parameters.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.GeneralSqlError:
throw new BadRequestException(ErrorMessages.GeneralErrorOfDeletingUserFromGroups);
case (int)SqlErrorCodes.UserLoginNotExist:
throw new ResourceNotFoundException(ErrorMessages.UserNotExist, ErrorCodes.ResourceNotFound);
}
}
return(result);
}
public async Task DeleteGroups_ValidRequest_ReturnDeletedGroupsCount()
{
// arrange
_privilegesRepository
.Setup(t => t.GetInstanceAdminPrivilegesAsync(SessionUserId))
.ReturnsAsync(InstanceAdminPrivileges.ManageGroups);
var scope = new OperationScope()
{
SelectAll = false, Ids = new List <int>()
{
2, 3
}
};
var returnResult = new List <int>
{
1,
2,
3
};
_sqlGroupRepositoryMock.Setup(repo => repo.DeleteGroupsAsync(It.Is <OperationScope>(a => a.Ids != null), It.IsAny <string>(), It.IsAny <IDbTransaction>())).ReturnsAsync(returnResult);
// act
var result = await _controller.DeleteGroups(scope, string.Empty) as OkNegotiatedContentResult <DeleteResult>;
// assert
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Content.TotalDeleted);
}
public async Task <int> AddUserToGroupsAsync(int userId, OperationScope body, string search)
{
if (!string.IsNullOrWhiteSpace(search))
{
search = UsersHelper.ReplaceWildcardCharacters(search);
}
var parameters = new DynamicParameters();
parameters.Add("@UserId", userId);
parameters.Add("@GroupMembership", SqlConnectionWrapper.ToDataTable(body.Ids, "Int32Collection", "Int32Value"));
parameters.Add("@SelectAll", body.SelectAll);
parameters.Add("@Search", search);
parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
var result = await _connectionWrapper.ExecuteScalarAsync <int>("AddUserToGroups", parameters, commandType : CommandType.StoredProcedure);
var errorCode = parameters.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.UserLoginNotExist:
throw new ResourceNotFoundException(ErrorMessages.UserNotExist, ErrorCodes.ResourceNotFound);
}
}
return(result);
}
public async Task <int> DeleteRoleAssignmentsAsync(int projectId, OperationScope scope, string search)
{
if (!string.IsNullOrWhiteSpace(search))
{
search = UsersHelper.ReplaceWildcardCharacters(search);
}
var parameters = new DynamicParameters();
parameters.Add("@ProjectId", projectId);
parameters.Add("@RoleAssignmentIds", SqlConnectionWrapper.ToDataTable(scope.Ids));
parameters.Add("@Search", search);
parameters.Add("@SelectAll", scope.SelectAll);
parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
var result = await _connectionWrapper.ExecuteScalarAsync <int>("DeleteProjectRoleAssigments", parameters,
commandType : CommandType.StoredProcedure);
var errorCode = parameters.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.ProjectWithCurrentIdNotExist:
throw new ResourceNotFoundException(ErrorMessages.ProjectNotExist, ErrorCodes.ResourceNotFound);
}
}
return(result);
}
// Compat with mbuild client type interface
public TargetList FilterScope(IGraphState graph, string here, OperationScope scope)
{
if (inner == null)
{
return(TargetList.Null);
}
short hereid = graph.GetProviderId(here);
if (hereid < 0)
{
throw ExHelp.App("Nonexistant provider basis `{0}'", here);
}
switch (scope)
{
case OperationScope.Everywhere:
return(this);
case OperationScope.HereAndBelow:
return(FilterInside(graph, hereid));
case OperationScope.HereOnly:
return(FilterExact(hereid));
default:
throw ExHelp.App("Unknown OperationScope {0} (here = {1})", scope, here);
}
}
public async Task <List <int> > DeleteGroupsAsync(OperationScope body, string search, IDbTransaction transaction)
{
if (!string.IsNullOrWhiteSpace(search))
{
search = UsersHelper.ReplaceWildcardCharacters(search);
}
var parameters = new DynamicParameters();
parameters.Add("@GroupsIds", SqlConnectionWrapper.ToDataTable(body.Ids));
parameters.Add("@Search", search);
parameters.Add("@SelectAll", body.SelectAll);
List <int> result;
if (transaction == null)
{
result = (await _connectionWrapper.QueryAsync <int>("DeleteGroups", parameters, commandType: CommandType.StoredProcedure)).ToList();
}
else
{
result = (await transaction.Connection.QueryAsync <int>("DeleteGroups", parameters, transaction, commandType: CommandType.StoredProcedure)).ToList();
}
return(result);
}
public WhatToDoNext DoConfigMode()
{
func = new OperationFunc(ConfigOperation);
select_tag = "config";
scope = OperationScope.Everywhere;
return(Check(SetMajorMode("configure") || SetOperation("configure")));
}
/// <summary>
/// Creates a new operation and makes it the current one.
/// </summary>
/// <returns>
/// The <see cref="IOperationScope" /> instance representing the operation created.
/// </returns>
public IOperationScope CreateOperation()
{
if (this.currentOperation != null)
{
throw new InvalidOperationException(Resources.OperationInProgress);
}
this.currentOperation = new OperationScope(this);
return(this.currentOperation);
}
public RavenJObject Transform(string transformScript, RavenJObject input)
{
if (jint == null)
throw new InvalidOperationException("Jint must be initialized.");
jint.ResetStatementsCount();
using (var scope = new OperationScope())
{
var jsObject = scope.ToJsObject(jint, input);
var jsObjectTransformed = jint.Invoke("Transform", jsObject);
return jsObjectTransformed != JsValue.Null ? scope.ConvertReturnValue(jsObjectTransformed) : null;
}
}
public RavenJObject Transform(string transformScript, RavenJObject input)
{
if (jint == null)
{
throw new InvalidOperationException("Jint must be initialized.");
}
jint.ResetStatementsCount();
using (var scope = new OperationScope())
{
var jsObject = scope.ToJsObject(jint, input);
var jsObjectTransformed = jint.Invoke("Transform", jsObject);
return(jsObjectTransformed != JsValue.Null ? scope.ConvertReturnValue(jsObjectTransformed) : null);
}
}
public async Task <int> DeleteWorkflowsAsync(OperationScope body, string search, int revision, IDbTransaction transaction = null)
{
if (search != null)
{
search = UsersHelper.ReplaceWildcardCharacters(search);
}
var result = 0;
var parameters = new DynamicParameters();
parameters.Add("@PublishRevision", revision);
parameters.Add("@WorkflowIds", SqlConnectionWrapper.ToDataTable(body.Ids));
parameters.Add("@Search", search);
parameters.Add("@SelectAll", body.SelectAll);
parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
if (transaction != null)
{
result =
await
_connectionWrapper.ExecuteScalarAsync <int>("DeleteWorkflows", parameters, transaction,
commandType : CommandType.StoredProcedure);
}
else
{
result =
await
_connectionWrapper.ExecuteScalarAsync <int>("DeleteWorkflows", parameters,
commandType : CommandType.StoredProcedure);
}
var errorCode = parameters.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.GeneralSqlError:
throw new BadRequestException(ErrorMessages.GeneralErrorOfDeletingWorkflows);
}
}
return(result);
}
public async Task <IHttpActionResult> DeleteUserFromGroups(int userId, [FromBody] OperationScope body)
{
if (body == null)
{
throw new BadRequestException(ErrorMessages.InvalidDeleteUserFromGroupsParameters, ErrorCodes.BadRequest);
}
if (body.IsEmpty())
{
return(Ok(DeleteResult.Empty));
}
await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.ManageUsers);
var result = await _userRepository.DeleteUserFromGroupsAsync(userId, body);
return(Ok(new DeleteResult {
TotalDeleted = result
}));
}
public async Task DeleteRoleAssignment_UserdDoesNotHaveRequiredPermissions_ForbiddenResult()
{
// arrange
var scope = new OperationScope()
{
SelectAll = false, Ids = new List <int>()
{
2, 3
}
};
_privilegeRepositoryMock
.Setup(t => t.GetInstanceAdminPrivilegesAsync(UserId))
.ReturnsAsync(InstanceAdminPrivileges.None);
// act
await _controller.DeleteRoleAssignment(ProjectId, scope);
// assert
// Exception
}
public async Task DeleteGroups_UserdDoesNotHaveRequiredPermissions_ForbiddenResult()
{
// arrange
var scope = new OperationScope()
{
Ids = new List <int>()
{
1, 2
}
};
_privilegesRepository
.Setup(t => t.GetInstanceAdminPrivilegesAsync(SessionUserId))
.ReturnsAsync(InstanceAdminPrivileges.None);
// act
var result = await _controller.DeleteGroups(scope);
// assert
// Exception
}
public async Task <IHttpActionResult> DeleteGroups([FromBody] OperationScope scope, string search = null)
{
SearchFieldValidator.Validate(search);
if (scope == null)
{
return(BadRequest(ErrorMessages.InvalidDeleteGroupsParameters));
}
if (scope.IsEmpty())
{
return(Ok(DeleteResult.Empty));
}
await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.ManageGroups);
var deletedGroupIds = new List <int>();
Func <IDbTransaction, long, Task> action = async(transaction, transactionId) =>
{
var groupIds = await _groupRepository.DeleteGroupsAsync(scope, search, transaction);
deletedGroupIds.AddRange(groupIds);
var topRevisionId = await _itemInfoRepository.GetTopRevisionId(transaction);
var message = new UsersGroupsChangedMessage(new int[0], deletedGroupIds)
{
TransactionId = transactionId,
RevisionId = topRevisionId,
ChangeType = UsersGroupsChangedType.Delete
};
await _sendMessageExecutor.Execute(_applicationSettingsRepository, _serviceLogRepository, message, transaction);
};
await RunInTransactionAsync(action);
return(Ok(new DeleteResult {
TotalDeleted = deletedGroupIds.Count
}));
}
public async Task <IHttpActionResult> DeleteWorkflows([FromBody] OperationScope scope, string search = null)
{
SearchFieldValidator.Validate(search);
if (scope == null)
{
return(BadRequest(ErrorMessages.InvalidDeleteWorkflowsParameters));
}
if (scope.IsEmpty())
{
return(Ok(DeleteResult.Empty));
}
await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.AccessAllProjectData);
var result = await _workflowService.DeleteWorkflows(scope, search, Session.UserId);
return(Ok(new DeleteResult {
TotalDeleted = result
}));
}
public async Task <IHttpActionResult> AddUserToGroups(int userId, [FromBody] OperationScope scope, string search = null)
{
SearchFieldValidator.Validate(search);
if (scope == null)
{
throw new BadRequestException(ErrorMessages.InvalidAddUserToGroupsParameters, ErrorCodes.BadRequest);
}
if (scope.IsEmpty())
{
return(Ok(CreateResult.Empty));
}
await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.ManageUsers);
var result = await _userRepository.AddUserToGroupsAsync(userId, scope, search);
return(Ok(new CreateResult {
TotalCreated = result
}));
}
public async Task <List <int> > DeleteUsersAsync(OperationScope scope, string search, int sessionUserId, IDbTransaction transaction)
{
if (!string.IsNullOrWhiteSpace(search))
{
search = UsersHelper.ReplaceWildcardCharacters(search);
}
var parameters = new DynamicParameters();
parameters.Add("@UserIds", SqlConnectionWrapper.ToDataTable(scope.Ids));
parameters.Add("@Search", search);
parameters.Add("@SelectAll", scope.SelectAll);
parameters.Add("@SessionUserId", sessionUserId);
parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
List <int> result;
if (transaction == null)
{
result = (await _connectionWrapper.QueryAsync <int>("DeleteUsers", parameters, commandType: CommandType.StoredProcedure)).ToList();
}
else
{
result = (await transaction.Connection.QueryAsync <int>("DeleteUsers", parameters, transaction, commandType: CommandType.StoredProcedure)).ToList();
}
var errorCode = parameters.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.GeneralSqlError:
throw new BadRequestException(ErrorMessages.GeneralErrorOfDeletingUsers);
}
}
return(result);
}
public async Task <IHttpActionResult> DeleteRoleAssignment(int projectId, [FromBody] OperationScope scope, string search = null)
{
SearchFieldValidator.Validate(search);
if (scope == null)
{
throw new BadRequestException(ErrorMessages.InvalidDeleteRoleAssignmentsParameters, ErrorCodes.BadRequest);
}
if (scope.IsEmpty())
{
return(Ok(DeleteResult.Empty));
}
await _privilegesManager.DemandAny(Session.UserId, projectId,
InstanceAdminPrivileges.AccessAllProjectsAdmin, ProjectAdminPrivileges.ManageGroupsAndRoles);
var result = await _instanceRepository.DeleteRoleAssignmentsAsync(projectId, scope, search);
return(Ok(new DeleteResult {
TotalDeleted = result
}));
}
public WhatToDoNext DoBelow(string where)
{
scope = OperationScope.HereAndBelow;
below_prefix = where;
return(Check(SetScope("below")));
}
public WhatToDoNext DoGlobal()
{
scope = OperationScope.Everywhere;
return(Check(SetScope("global")));
}
public WhatToDoNext DoLocal()
{
scope = OperationScope.HereOnly;
return(Check(SetScope("local")));
}
public async Task <int> UnassignProjectsAndArtifactTypesFromWorkflowAsync(int workflowId, OperationScope scope, string search = null)
{
if (search != null)
{
search = UsersHelper.ReplaceWildcardCharacters(search);
}
var parameters = new DynamicParameters();
parameters.Add("@WorkflowId", workflowId);
parameters.Add("@AllProjects", scope.SelectAll);
parameters.Add("@ProjectIds", SqlConnectionWrapper.ToDataTable(scope.Ids));
parameters.Add("@Search", search);
parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
var result = await _connectionWrapper.ExecuteScalarAsync <int>("UnassignProjectsAndArtifactTypesFromWorkflow", parameters,
commandType : CommandType.StoredProcedure);
var errorCode = parameters.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.WorkflowWithCurrentIdNotExist:
throw new ResourceNotFoundException(ErrorMessages.WorkflowNotExist, ErrorCodes.ResourceNotFound);
case (int)SqlErrorCodes.WorkflowWithCurrentIdIsActive:
throw new ConflictException(ErrorMessages.WorkflowIsActive, ErrorCodes.WorkflowIsActive);
case (int)SqlErrorCodes.GeneralSqlError:
throw new Exception(ErrorMessages.GeneralErrorOfDeletingWorkflows);
}
}
return(result);
}
public async Task <IHttpActionResult> UnassignProjectsAndArtifactTypesFromWorkflowAsync(int workflowId, [FromBody] OperationScope scope, string search = null)
{
await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.AccessAllProjectData);
SearchFieldValidator.Validate(search);
if (scope == null)
{
throw new BadRequestException(ErrorMessages.UnassignMemberScopeEmpty, ErrorCodes.BadRequest);
}
if (scope.IsEmpty())
{
return(Ok(DeleteResult.Empty));
}
var result = await _workflowRepository.UnassignProjectsAndArtifactTypesFromWorkflowAsync(workflowId, scope, search);
return(Ok(new DeleteResult {
TotalDeleted = result
}));
}
public WhatToDoNext DoConfigMode () {
func = new OperationFunc (ConfigOperation);
select_tag = "config";
scope = OperationScope.Everywhere;
return Check (SetMajorMode ("configure") || SetOperation ("configure"));
}
public WhatToDoNext DoLocal () {
scope = OperationScope.HereOnly;
return Check (SetScope ("local"));
}
public WhatToDoNext DoGlobal () {
scope = OperationScope.Everywhere;
return Check (SetScope ("global"));
}
public WhatToDoNext DoBelow (string where) {
scope = OperationScope.HereAndBelow;
below_prefix = where;
return Check (SetScope ("below"));
}
public async Task <SyncResult> AssignArtifactTypesToProjectInWorkflow(int workflowId, int projectId, OperationScope scope)
{
var parameters = new DynamicParameters();
parameters.Add("@WorkflowId", workflowId);
parameters.Add("@ProjectId", projectId);
parameters.Add("@ArtifactTypeIds", SqlConnectionWrapper.ToDataTable(scope.Ids, "Int32Collection", "Int32Value"));
parameters.Add("@SelectAll", scope.SelectAll);
parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
var result = await _connectionWrapper.QueryAsync <SyncResult>("AssignArtifactTypesToProjectInWorkflow", parameters, commandType : CommandType.StoredProcedure);
var errorCode = parameters.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.GeneralSqlError:
throw new Exception(ErrorMessages.GeneralErrorOfAssignProjectsAndArtifactTypesToWorkflow);
case (int)SqlErrorCodes.WorkflowWithCurrentIdNotExist:
throw new ResourceNotFoundException(ErrorMessages.WorkflowNotExist, ErrorCodes.ResourceNotFound);
case (int)SqlErrorCodes.ProjectWithCurrentIdNotExist:
throw new ResourceNotFoundException(ErrorMessages.ProjectNotExist, ErrorCodes.ResourceNotFound);
case (int)SqlErrorCodes.WorkflowWithCurrentIdIsActive:
throw new ConflictException(ErrorMessages.WorkflowIsActive, ErrorCodes.WorkflowIsActive);
case (int)SqlErrorCodes.WorkflowProjectHasNoArtifactTypes:
throw new ConflictException(ErrorMessages.WorkflowProjectHasNoArtifactTypes, ErrorCodes.WorkflowProjectHasNoArtifactTypes);
case (int)SqlErrorCodes.WorkflowProjectHasNoLiveArtifactTypes:
throw new ConflictException(ErrorMessages.WorkflowProjectHasNoLiveArtifactTypes, ErrorCodes.WorkflowProjectHasNoLiveArtifactTypes);
case (int)SqlErrorCodes.WorkflowProjectHasNoLiveArtifactTypesAmongChecked:
throw new ConflictException(ErrorMessages.WorkflowProjectHasNoLiveArtifactTypesAmongChecked, ErrorCodes.WorkflowProjectHasNoLiveArtifactTypesAmongChecked);
}
}
return(result.FirstOrDefault());
}
public OperationExecutive(IContext context, ISafeRepository safeRepository)
{
this.context = context;
this.safeRepository = safeRepository;
this.currentOperation = null;
}
public async Task <IHttpActionResult> AssignArtifactTypesToProjectInWorkflow(int workflowId, int projectId, [FromBody] OperationScope scope)
{
await _privilegesManager.Demand(Session.UserId, InstanceAdminPrivileges.AccessAllProjectData);
if (scope == null) // just check this, for empty list of ids we should get custom message from SP
{
throw new BadRequestException(ErrorMessages.ArtifactTypeIdsNotValid, ErrorCodes.BadRequest);
}
var result = await _workflowRepository.AssignArtifactTypesToProjectInWorkflow(workflowId, projectId, scope);
return(Ok(result));
}
