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)); }