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