public SetOrganisationCampfireSettingsResponse Invoke(SetOrganisationCampfireSettingsRequest request) { var organisation = Session.MasterRaven .Include <Organisation>(o => o.RavenInstanceId) .Load <Organisation>(request.OrganisationId); if (organisation == null) { return(new SetOrganisationCampfireSettingsResponse(request.OrganisationId, true)); } organisation.RavenInstance = MasterLoad <RavenInstance>(organisation.RavenInstanceId); _authorisationManager.Authorise(organisation, request.CurrentUser); organisation.CampfireDetails = new CampfireDetails { Company = request.CampfireCompany, Token = request.CampfireToken, }; Session.AddCommitAction(new FlushOrganisationCacheCommitAction(_configuration, organisation)); return(new SetOrganisationCampfireSettingsResponse(organisation.Id)); }
public AddCommentResponse Invoke(AddCommentRequest request) { Trace("Starting..."); var issue = Load <Issue>(Issue.GetId(request.IssueId)); if (issue == null) { return(new AddCommentResponse { Status = AddCommentStatus.IssueNotFound }); } _authorisationManager.Authorise(issue, request.CurrentUser); if (request.Comment.IsNotNullOrEmpty()) { Store(new IssueHistory { DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId), IssueId = issue.Id, UserId = request.CurrentUser.Id, Type = HistoryItemType.Comment, Comment = request.Comment, ApplicationId = issue.ApplicationId, SystemMessage = false }); } return(new AddCommentResponse { Status = AddCommentStatus.Ok }); }
public DeleteReplayReplacementResponse Invoke(DeleteReplayReplacementRequest request) { var organisation = Session.MasterRaven .Include <Organisation>(o => o.RavenInstanceId) .Load <Organisation>(request.OrganisationId); if (organisation == null) { return(new DeleteReplayReplacementResponse(request.OrganisationId, null, true)); } organisation.RavenInstance = MasterLoad <RavenInstance>(organisation.RavenInstanceId); _authorisationManager.Authorise(organisation, request.CurrentUser); //if (organisation.ReplayReplacements == null) //{ // return new DeleteReplayReplacementResponse(organisation.Id, request.CurrentUser.Email, true); //} //var replacement = organisation.ReplayReplacements.FirstOrDefault(r => r.Id == request.Id); //if (replacement == null) //{ // return new DeleteReplayReplacementResponse(organisation.Id, request.CurrentUser.Email, true); //} //organisation.ReplayReplacements.Remove(replacement); return(new DeleteReplayReplacementResponse(organisation.Id, request.CurrentUser.Email)); }
public AddReplayReplacementResponse Invoke(AddReplayReplacementRequest request) { var organisation = Session.MasterRaven .Include <Organisation>(o => o.RavenInstanceId) .Load <Organisation>(request.OrganisationId); if (organisation == null) { return(new AddReplayReplacementResponse(request.OrganisationId, null, true)); } organisation.RavenInstance = MasterLoad <RavenInstance>(organisation.RavenInstanceId); _authorisationManager.Authorise(organisation, request.CurrentUser); //if (organisation.ReplayReplacements == null) // organisation.ReplayReplacements = new List<ReplayReplacement>(); //organisation.ReplayReplacements.Add(new ReplayReplacement //{ // Field = request.Field, // Find = request.Find, // Replace = request.Replace, // Id = Guid.NewGuid() //}); return(new AddReplayReplacementResponse(organisation.Id, request.CurrentUser.Email)); }
public EditGroupResponse Invoke(EditGroupRequest request) { Trace("Starting..."); var groupId = Group.GetId(request.GroupId); var existingGroup = Load <Group>(groupId); if (existingGroup == null) { return(new EditGroupResponse(true) { Status = EditGroupStatus.GroupNotFound }); } _authorisationManager.Authorise(existingGroup, request.CurrentUser); //update the groups users var currentUsers = _getUsersQuery.Invoke(new GetUsersRequest { OrganisationId = request.CurrentUser.OrganisationId, Paging = new PageRequestWithSort(1, _configuration.MaxPageSize) }).Users; foreach (var user in currentUsers.Items) { if (request.Users.Any(u => u == user.Id) && user.GroupIds.All(gId => gId != existingGroup.Id)) { var loadedUser = Load <User>(User.GetId(user.Id)); loadedUser.GroupIds.Add(existingGroup.Id); } else if (request.Users.All(u => u != user.Id) && user.GroupIds.Any(gId => gId == existingGroup.Id)) { var loadedUser = Load <User>(User.GetId(user.Id)); loadedUser.GroupIds.Remove(existingGroup.Id); } } if (request.Name.IsNotNullOrEmpty()) { existingGroup.Name = request.Name; } Session.SynchroniseIndexes <Indexing.Users, Indexing.Groups>(); return(new EditGroupResponse(false, request.GroupId, request.CurrentUser.OrganisationId) { Status = EditGroupStatus.Ok }); }
public EditApplicationResponse Invoke(EditApplicationRequest request) { Trace("Starting..."); var applicationId = Application.GetId(request.ApplicationId); var existingApplication = Session.Raven.Query <Application, Indexing.Applications>().Count(o => o.Name == request.Name && o.Id != applicationId); if (existingApplication > 0) { return(new EditApplicationResponse(true) { Status = EditApplicationStatus.ApplicationNameExists }); } var application = Load <Application>(applicationId); if (application == null) { return(new EditApplicationResponse(true) { Status = EditApplicationStatus.ApplicationNotFound }); } //make sure user is authorised to edit this entity _authorisationManager.Authorise(application, request.CurrentUser); application.Name = request.Name; application.IsActive = request.IsActive; application.DefaultUserId = User.GetId(request.UserId); application.MatchRuleFactoryId = request.MatchRuleFactoryId; application.NotificationGroups = request.NotificationGroups; application.Version = request.Version; application.HipChatRoomId = request.HipChatRoomId; application.CampfireRoomId = request.CampfireRoomId; application.DefaultNotificationFrequency = request.NotificationFrequency; Session.SynchroniseIndexes <Indexing.Applications>(); Session.AddCommitAction(new FlushApplicationCacheCommitAction(_configuration, request.CurrentUser.ActiveOrganisation, application.FriendlyId)); return(new EditApplicationResponse(false, request.ApplicationId, request.CurrentUser.OrganisationId) { Status = EditApplicationStatus.Ok }); }
public GetGroupResponse Invoke(GetGroupRequest request) { Trace("Starting..."); var groupId = Group.GetId(request.GroupId); var group = Load <Group>(groupId); if (group != null) { _authorisationManager.Authorise(group, request.CurrentUser); } return(new GetGroupResponse { Group = group }); }
public GetApplicationResponse Invoke(GetApplicationRequest request) { Trace("Starting..."); string applicationId = Application.GetId(request.ApplicationId); var application = Load <Application>(applicationId); if (application != null) { _authorisationManager.Authorise(application, request.CurrentUser); } return(new GetApplicationResponse { Application = application }); }
public DeleteIssueResponse Invoke(DeleteIssueRequest request) { Trace("Starting..."); TraceObject(request); var issueId = Issue.GetId(request.IssueId); var issue = Load <Issue>(issueId); if (issue == null) { return(new DeleteIssueResponse { Status = DeleteIssueStatus.IssueNotFound }); } _authorisationManager.Authorise(issue, request.CurrentUser); //delete the issues errors Session.AddCommitAction(new DeleteAllErrorsCommitAction(issue.Id)); Session.AddCommitAction(new DeleteAllDailyCountsCommitAction(issue.Id)); var hourlyCount = Session.Raven.Load <IssueHourlyCount>("IssueHourlyCount/{0}".FormatWith(issue.FriendlyId)); //delete the hourly count doc if (hourlyCount != null) { Delete(hourlyCount); } //and delete the issue Delete(issue); if (!request.IsBatchDelete) { //tell the reception service an issue has been deleted Session.AddCommitAction(new RaiseIssueDeletedEvent("{0}|{1}".FormatWith(issue.FriendlyId, IdHelper.GetFriendlyId(issue.ApplicationId)))); } return(new DeleteIssueResponse { Status = DeleteIssueStatus.Ok }); }
public GetIssueResponse Invoke(GetIssueRequest request) { Trace("Starting..."); var issueId = Issue.GetId(request.IssueId); var issue = Load <Issue>(issueId); if (issue == null) { Trace("Failed to locate issue with Id:={0}", request.IssueId); return(new GetIssueResponse()); } _authorisationManager.Authorise(issue, request.CurrentUser); return(new GetIssueResponse { Issue = issue }); }
public override Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { try { if (!_authorisationManager.Authorise(context)) { context.SetError("invalid_grant", "The user name or password is incorrect."); } else { var identity = new ClaimsIdentity(context.Options.AuthenticationType); identity.AddClaim(new Claim("sub", context.UserName)); identity.AddClaim(new Claim("role", "user")); context.Validated(identity); } } catch (Exception) { context.SetError("invalid_grant", "The user name or password is incorrect."); } return(Task.CompletedTask); }
public DeleteGroupResponse Invoke(DeleteGroupRequest request) { Trace("Starting..."); var groupId = Group.GetId(request.GroupId); var existingGroup = Session.Raven.Query <Group, Indexing.Groups>().FirstOrDefault(o => o.Id == groupId); if (existingGroup == null) { return(new DeleteGroupResponse(true) { Status = DeleteGroupStatus.GroupNotFound }); } _authorisationManager.Authorise(existingGroup, request.CurrentUser); var usersInGroup = Session.Raven.Query <User, Indexing.Users>().FirstOrDefault(e => e.GroupIds.Any(id => id == existingGroup.Id)); if (usersInGroup != null) { return(new DeleteGroupResponse(true) { Status = DeleteGroupStatus.UsersInGroup }); } Delete(existingGroup); Session.SynchroniseIndexes <Indexing.Groups>(); return(new DeleteGroupResponse(groupId: request.GroupId, organisationId: request.CurrentUser.OrganisationId) { Status = DeleteGroupStatus.Ok }); }
public DeleteApplicationResponse Invoke(DeleteApplicationRequest request) { Trace("Starting..."); var applicationId = Application.GetId(request.ApplicationId); var application = Session.Raven.Load <Application>(applicationId); if (application == null) { return(new DeleteApplicationResponse(true) { Status = DeleteApplicationStatus.ApplicationNotFound }); } _authorisationManager.Authorise(application, request.CurrentUser); DeleteByIndex(CoreConstants.IndexNames.Errors, applicationId); DeleteByIndex(CoreConstants.IndexNames.Issues, applicationId); DeleteByIndex(CoreConstants.IndexNames.IssueDailyCount, applicationId); DeleteByIndex(CoreConstants.IndexNames.IssueHistory, applicationId); DeleteByIndex(CoreConstants.IndexNames.IssueHourlyCounts, applicationId); if (!request.JustDeleteErrors) { Delete(application); } Session.SynchroniseIndexes <Indexing.Errors, Indexing.Issues, Indexing.Applications>(); Session.AddCommitAction(new FlushApplicationCacheCommitAction(_configuration, request.CurrentUser.ActiveOrganisation, application.FriendlyId)); return(new DeleteApplicationResponse(false, request.ApplicationId, application.OrganisationId) { Status = DeleteApplicationStatus.Ok }); }
public UpdateOrganisationResponse Invoke(UpdateOrganisationRequest request) { var organisation = Session.MasterRaven .Include <Organisation>(o => o.RavenInstanceId) .Load <Organisation>(request.OrganisationId); if (organisation == null) { return(new UpdateOrganisationResponse(request.OrganisationId, null, true)); } organisation.RavenInstance = MasterLoad <RavenInstance>(organisation.RavenInstanceId); //TODO - admin auth _authorisationManager.Authorise(organisation, request.CurrentUser); organisation.TimezoneId = request.TimezoneId; organisation.Name = request.Name; organisation.PrimaryUserId = User.GetId(request.PrimaryUserId); Session.AddCommitAction(new FlushOrganisationCacheCommitAction(_configuration, organisation)); return(new UpdateOrganisationResponse(organisation.Id, request.CurrentUser.Email)); }
public EditUserResponse Invoke(EditUserRequest request) { Trace("Starting..."); var userId = User.GetId(request.UserId); var existingUser = Load <User>(userId); var cacheInvalidationItems = new List <CacheInvalidationItem>(); if (existingUser == null) { return(new EditUserResponse { Status = EditUserStatus.UserNotFound }); } var userMapping = Session.MasterRaven.Query <UserOrganisationMapping>().First(u => u.EmailAddress == existingUser.Email); if (userMapping == null) { return(new EditUserResponse { Status = EditUserStatus.UserNotFound }); } _authorisationManager.Authorise(existingUser, request.CurrentUser); var existingEmail = Session.Raven.Query <User, Indexing.Users>().FirstOrDefault(u => u.Email == request.Email && u.Id != userId); if (existingEmail != null) { return(new EditUserResponse { Status = EditUserStatus.EmailExists }); } if (existingUser.Email != request.Email) { userMapping.EmailAddress = request.Email; Session.SynchroniseIndexes <UserOrganisationMappings>(true); } var ravenInstances = _getRavenInstancesQuery.Invoke(new GetRavenInstancesRequest()).RavenInstances; //find the users accounts in their organisations and sync the user foreach (var organisationId in userMapping.Organisations) { var organisation = MasterLoad <Organisation>(organisationId); if (organisation == null) { userMapping.Organisations.Remove(organisationId); } else { organisation.RavenInstance = ravenInstances.First(r => r.Id == organisation.RavenInstanceId); using (Session.SwitchOrg(organisation)) { var user = Session.Raven.Query <User, Indexing.Users>().FirstOrDefault(u => u.Email == request.Email); if (user == null) { userMapping.Organisations.Remove(organisationId); } else { user.Email = request.Email; user.FirstName = request.FirstName; user.LastName = request.LastName; if (organisation.Id == request.CurrentUser.ActiveOrganisation.Id) { if (request.Administrator.HasValue && existingUser.Role != UserRole.SuperUser) { user.Role = request.Administrator.Value ? UserRole.Administrator : UserRole.User; } if (request.GroupIds != null) { user.GroupIds = request.GroupIds.Select(Group.GetId).ToList(); } } cacheInvalidationItems.AddRange(CacheInvalidation.GetUserInvalidationItems(organisation.Id, existingUser.Email)); } } } } Session.SynchroniseIndexes <Indexing.Users, Indexing.Groups>(); return(new EditUserResponse(cacheInvalidationItems) { Status = EditUserStatus.Ok }); }
public AdjustRulesResponse Invoke(AdjustRulesRequest request) { Trace("Starting..."); var currentIssue = Session.Raven.Load <Issue>(Issue.GetId(request.IssueId)); AdjustRulesResponse response; if (!ValidateCommand(currentIssue, request.Rules, out response)) { return(response); } _authorisationManager.Authorise(currentIssue, request.CurrentUser); //craete the new temp issue var tempIssue = CreateTempIssue(currentIssue, request); var currentDbIssue = currentIssue; if (!request.WhatIf) { //storing at this point makes sure we get an Id for the isssue Store(tempIssue); } else { //if we're just doing a whatif we don't want to actually change the issue in the db //note the properties on the new "currentissue" will still presumably be proxies //so need to be careful not to change anything on them... currentIssue = new Issue(); PropertyMapper.Map(currentDbIssue, currentIssue); } //and update the existing issue UpdateCurrentIssue(currentIssue, request); Trace("Starting to determine non matching errors , Current Error Count:={0}, Temp Issue Error Count:={1}...", currentIssue.ErrorCount, tempIssue.ErrorCount); var nonMatchingErrorsResponse = _getErrorsThatDoNotMatchNewRulesQuery.Invoke(new GetErrorsThatDoNotMatchNewRulesRequest { IssueWithModifiedRules = currentIssue, IssueWithOldRules = tempIssue }); Trace("Completed determining non matching errors, temp issue error count:={0}, remaining errors:={1}...", tempIssue.ErrorCount, nonMatchingErrorsResponse.Matches); if (!request.WhatIf) { if (nonMatchingErrorsResponse.NonMatches.Count > 0) { var dateTimeOffset = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId); //if errors on the original issue did not match the new rules, store the temp issue and move the non matching errors to it Session.AddCommitAction(new RaiseIssueCreatedEvent(tempIssue)); //move all these errors to the new issue in a batch _moveErrorsToNewIssueCommand.Invoke(new MoveErrorsToNewIssueRequest { Errors = nonMatchingErrorsResponse.NonMatches, IssueId = tempIssue.Id, CurrentUser = request.CurrentUser }); //re-sync the error counts only if we have moved errors (do it for both issues) Session.AddCommitAction(new SendMessageCommitAction(new SyncIssueErrorCountsMessage { IssueId = currentIssue.Id, OrganisationId = request.CurrentUser.OrganisationId, TriggerEventUtc = DateTime.UtcNow, }, _configuration.GetEventsQueueAddress(request.CurrentUser.ActiveOrganisation.RavenInstance.FriendlyId))); Session.AddCommitAction(new SendMessageCommitAction(new SyncIssueErrorCountsMessage { IssueId = tempIssue.Id, OrganisationId = request.CurrentUser.OrganisationId, TriggerEventUtc = DateTime.UtcNow, }, _configuration.GetEventsQueueAddress(request.CurrentUser.ActiveOrganisation.RavenInstance.FriendlyId))); Store(new IssueHistory { DateAddedUtc = dateTimeOffset, Type = HistoryItemType.RulesAdjustedCreatedNewIssue, SpawnedIssueId = tempIssue.Id, UserId = request.CurrentUser.Id, IssueId = currentIssue.Id, ApplicationId = currentIssue.ApplicationId, SystemMessage = true }); Store(new IssueHistory { DateAddedUtc = dateTimeOffset, Type = HistoryItemType.CreatedByRuleAdjustment, SpawningIssueId = currentIssue.Id, UserId = request.CurrentUser.Id, IssueId = tempIssue.Id, ApplicationId = tempIssue.ApplicationId, SystemMessage = true }); } else { Store(new IssueHistory { DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId), Type = HistoryItemType.RulesAdjustedNoNewIssue, UserId = request.CurrentUser.Id, IssueId = currentIssue.Id, ApplicationId = currentIssue.ApplicationId, SystemMessage = true }); Delete(tempIssue); } Session.AddCommitAction(new RaiseIssueModifiedEvent(currentIssue)); } return(new AdjustRulesResponse { Status = AdjustRulesStatus.Ok, IssueId = currentIssue.FriendlyId, ErrorsMatched = nonMatchingErrorsResponse.Matches.Count, ErrorsNotMatched = nonMatchingErrorsResponse.NonMatches.Count, UnmatchedIssueId = tempIssue.FriendlyId, }); }
public DeleteUserResponse Invoke(DeleteUserRequest request) { Trace("Starting..."); var userId = User.GetId(request.UserId); if (userId == request.CurrentUser.Id) { return(new DeleteUserResponse { Status = DeleteUserStatus.CantDeleteCurrentUser }); } var existingUser = Load <User>(userId); if (existingUser == null) { return(new DeleteUserResponse(true) { Status = DeleteUserStatus.UserNotFound }); } _authorisationManager.Authorise(existingUser, request.CurrentUser); var organisation = Session.MasterRaven.Load <Organisation>(existingUser.OrganisationId); if (organisation.PrimaryUserId == userId) { organisation.PrimaryUserId = request.CurrentUser.Id; } var userOrgMapping = Session.MasterRaven.Query <UserOrganisationMapping>().FirstOrDefault(u => u.EmailAddress == existingUser.Email); if (userOrgMapping != null) { userOrgMapping.Organisations.Remove(organisation.Id); if (userOrgMapping.Organisations.Count == 0) { Session.MasterRaven.Delete(userOrgMapping); } } Session.RavenDatabaseCommands.UpdateByIndex(CoreConstants.IndexNames.Issues, new IndexQuery { Query = "UserId:{0}".FormatWith(userId) }, new[] { new PatchRequest { Name = "UserId", Type = PatchCommandType.Set, Value = User.GetId(request.CurrentUser.Id) } }); Delete(existingUser); Session.SynchroniseIndexes <Indexing.Users, Indexing.Issues>(); return(new DeleteUserResponse(organisationId: request.CurrentUser.OrganisationId, email: existingUser.Email) { Status = DeleteUserStatus.Ok }); }
public DeleteIssueErrorsResponse Invoke(DeleteIssueErrorsRequest request) { Trace("Starting..."); TraceObject(request); var issue = Load <Issue>(Issue.GetId(request.IssueId)); if (issue == null) { return(new DeleteIssueErrorsResponse()); } _authorisationManager.Authorise(issue, request.CurrentUser); //delete the issue's errors Session.AddCommitAction(new DeleteAllErrorsCommitAction(issue.Id)); Session.AddCommitAction(new DeleteAllDailyCountsCommitAction(issue.Id)); var hourlyCount = Session.Raven.Load <IssueHourlyCount>("IssueHourlyCount/{0}".FormatWith(issue.FriendlyId)); if (hourlyCount == null) { hourlyCount = new IssueHourlyCount { IssueId = issue.Id, Id = "IssueHourlyCount/{0}".FormatWith(issue.FriendlyId), ApplicationId = issue.ApplicationId }; hourlyCount.Initialise(); Store(hourlyCount); } else { hourlyCount.Initialise(); } //create or update the historical count of errors for this issue var historicalCount = Load <IssueDailyCount>("IssueDailyCount/{0}-Historical".FormatWith(issue.FriendlyId)); if (historicalCount == null) { historicalCount = new IssueDailyCount { IssueId = issue.Id, ApplicationId = issue.ApplicationId, Count = issue.ErrorCount, Date = DateTime.MinValue.Date, Historical = true, Id = "IssueDailyCount/{0}-Historical".FormatWith(issue.FriendlyId) }; Store(historicalCount); } else { historicalCount.Count += issue.ErrorCount; } Store(new IssueHistory { DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId), UserId = request.CurrentUser.Id, Type = HistoryItemType.ErrorsPurged, IssueId = issue.Id, ApplicationId = issue.ApplicationId, SystemMessage = true }); issue.ErrorCount = 0; issue.LimitStatus = ErrorLimitStatus.Ok; return(new DeleteIssueErrorsResponse()); }
public UpdateIssueDetailsResponse Invoke(UpdateIssueDetailsRequest request) { Trace("Starting..."); var issue = Load <Issue>(Issue.GetId(request.IssueId)); if (issue == null) { return(new UpdateIssueDetailsResponse { Status = UpdateIssueDetailsStatus.IssueNotFound }); } _authorisationManager.Authorise(issue, request.CurrentUser); //if we are assigning this issue to a new user, notify them if (issue.UserId != request.AssignedUserId && request.AssignedUserId != request.CurrentUser.Id) { var user = _getUserQuery.Invoke(new GetUserRequest { UserId = request.AssignedUserId, OrganisationId = issue.OrganisationId }).User; _sendNotificationCommand.Invoke(new SendNotificationRequest { EmailInfo = new IssueAssignedToUserEmailInfo { To = user.Email, IssueId = issue.Id, IssueName = request.Name }, OrganisationId = issue.OrganisationId, Organisation = request.CurrentUser.ActiveOrganisation }); } if (issue.Status != request.Status) { Store(new IssueHistory { DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId), IssueId = issue.Id, NewStatus = request.Status, PreviousStatus = issue.Status, SystemMessage = true, UserId = request.CurrentUser.Id, Type = HistoryItemType.StatusUpdated, ApplicationId = issue.ApplicationId, }); } if (issue.UserId != request.AssignedUserId) { Store(new IssueHistory { DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId), IssueId = issue.Id, SystemMessage = true, UserId = request.CurrentUser.Id, AssignedToUserId = request.AssignedUserId, Type = HistoryItemType.AssignedUserChanged, ApplicationId = issue.ApplicationId }); } issue.Status = request.Status; issue.UserId = request.AssignedUserId; issue.Name = request.Name; issue.NotifyFrequency = request.NotifyFrequency; issue.Reference = request.Reference; issue.LastModifiedUtc = DateTime.UtcNow; if (request.Comment.IsNotNullOrEmpty()) { Store(new IssueHistory { DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId), IssueId = issue.Id, UserId = request.CurrentUser.Id, AssignedToUserId = request.AssignedUserId, Type = HistoryItemType.Comment, Comment = request.Comment, ApplicationId = issue.ApplicationId }); } Session.AddCommitAction(new RaiseIssueModifiedEvent(issue)); return(new UpdateIssueDetailsResponse { Status = UpdateIssueDetailsStatus.Ok }); }
public BatchStatusUpdateResponse Invoke(BatchStatusUpdateRequest request) { Trace("Starting..."); if (request.AssignToUserId != null) { var assignToUser = _getUserQuery.Invoke(new GetUserRequest { OrganisationId = request.CurrentUser.OrganisationId, UserId = request.AssignToUserId }).User; _authorisationManager.Authorise(assignToUser, request.CurrentUser); } var issuesToUpdate = new List <Issue>(); foreach (var issueId in request.IssueIds.Select(issueId => issueId.Split('|')[0])) { var issue = Load <Issue>(Issue.GetId(issueId)); if (issue != null) { _authorisationManager.Authorise(issue, request.CurrentUser); issuesToUpdate.Add(issue); if (request.AssignToUserId != null) { issue.UserId = request.AssignToUserId; Store(new IssueHistory { DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId), UserId = request.CurrentUser.Id, AssignedToUserId = request.AssignToUserId, Type = HistoryItemType.AssignedUserChanged, IssueId = issue.Id, ApplicationId = issue.ApplicationId, SystemMessage = true }); } Store(new IssueHistory { DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId), UserId = request.CurrentUser.Id, PreviousStatus = issue.Status, NewStatus = request.Status, Type = HistoryItemType.StatusUpdated, IssueId = issue.Id, ApplicationId = issue.ApplicationId, SystemMessage = true }); issue.Status = request.Status; } } if (issuesToUpdate.Count > 0) { Session.AddCommitAction(new RaiseIssueModifiedEvent(issuesToUpdate)); } return(new BatchStatusUpdateResponse { Status = BulkStatusUpdateStatus.Ok }); }
public MergeIssuesResponse Invoke(MergeIssuesRequest request) { Trace("Starting..."); TraceObject(request); var mergeFromIssue = Load <Issue>(Issue.GetId(request.MergeFromIssueId)); var mergeToIssue = Load <Issue>(Issue.GetId(request.MergeToIssueId)); MergeIssuesResponse response; if (!ValidateCommand(mergeFromIssue, mergeToIssue, out response)) { return(response); } _authorisationManager.Authorise(mergeFromIssue, request.CurrentUser); _authorisationManager.Authorise(mergeToIssue, request.CurrentUser); new SynchroniseIndexCommitAction <Indexing.Errors>().Execute(Session); //move all errors fron the MergeFromIssue to the MergeToIssue Session.AddCommitAction(new UpdateByIndexCommitAction(CoreConstants.IndexNames.Errors, new IndexQuery { Query = "IssueId:{0}".FormatWith(mergeFromIssue.Id) }, new[] { new PatchRequest { Name = "IssueId", Type = PatchCommandType.Set, Value = mergeToIssue.Id } }, true)); Store(new IssueHistory { DateAddedUtc = DateTime.UtcNow.ToDateTimeOffset(request.CurrentUser.ActiveOrganisation.TimezoneId), SpawningIssueId = mergeFromIssue.Id, SystemMessage = true, Type = HistoryItemType.MergedTo, IssueId = mergeToIssue.Id, ApplicationId = mergeToIssue.ApplicationId }); Delete(mergeFromIssue); //re-sync the error counts Session.AddCommitAction(new SendMessageCommitAction(new SyncIssueErrorCountsMessage { IssueId = request.MergeToIssueId, OrganisationId = request.CurrentUser.OrganisationId, TriggerEventUtc = DateTime.UtcNow, }, _configuration.GetEventsQueueAddress(request.CurrentUser.ActiveOrganisation.RavenInstance.FriendlyId))); return(new MergeIssuesResponse { Status = MergeIssuesStatus.Ok }); }