public async Task HandleAsync(RemarkCommentVoteSubmitted @event)
{
await _handler
.Run(async() =>
{
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
var comment = remark.Value.Comments.SingleOrDefault(x => x.Id == @event.CommentId);
if (comment == null)
{
return;
}
Vote(comment, @event.UserId, @event.Positive);
comment.Votes.Add(new Vote
{
UserId = @event.UserId,
Positive = @event.Positive,
CreatedAt = @event.CreatedAt
});
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.ExecuteAsync();
}
public async Task HandleAsync(RemarkEdited @event)
=> await _handler
.Run(async() =>
{
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
var remarkDto = await _remarkServiceClient.GetAsync <Remark>(@event.RemarkId);
remark.Value.Group = remarkDto.Value.Group;
remark.Value.Category = remarkDto.Value.Category;
remark.Value.Description = remarkDto.Value.Description;
remark.Value.Location = remarkDto.Value.Location;
remark.Value.Tags = remarkDto.Value.Tags;
remark.Value.UpdatedAt = remarkDto.Value.UpdatedAt;
remark.Value.States = remarkDto.Value.States;
remark.Value.State = remarkDto.Value.State;
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
public async Task HandleAsync(RemarkActionTaken @event)
{
await _handler
.Run(async() =>
{
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
var participant = new Participant
{
User = new RemarkUser
{
UserId = @event.UserId,
Name = @event.Username
},
Description = @event.Description,
CreatedAt = @event.CreatedAt
};
if (remark.Value.Participants == null)
{
remark.Value.Participants = new HashSet <Participant>();
}
remark.Value.UpdatedAt = DateTime.UtcNow;
remark.Value.Participants.Add(participant);
remark.Value.ParticipantsCount++;
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.ExecuteAsync();
}
public async Task HandleAsync(RemarkResolved @event)
{
await _handler
.Run(async() =>
{
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
var remarkDto = await _remarkServiceClient.GetAsync <Remark>(@event.RemarkId);
remark.Value.UpdatedAt = remarkDto.Value.UpdatedAt;
remark.Value.State = remarkDto.Value.State;
remark.Value.States = remarkDto.Value.States;
remark.Value.Photos = remarkDto.Value.Photos;
remark.Value.Resolved = true;
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
}
public async Task HandleAsync(RemarkReported @event)
{
await _handler
.Run(async() =>
{
var report = new Report
{
Id = Guid.NewGuid(),
RemarkId = @event.RemarkId,
ResourceId = @event.ResourceId,
UserId = @event.UserId,
Type = @event.Type,
CreatedAt = DateTime.UtcNow
};
await _reportRepository.AddAsync(report);
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
switch (@event.Type)
{
case "activity": remark.Value.States
.Single(x => x.Id == @event.ResourceId.Value).ReportsCount++; break;
case "comment": remark.Value.Comments
.Single(x => x.Id == @event.ResourceId.Value).ReportsCount++; break;
case "remark": remark.Value.ReportsCount++; break;
}
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
}
public async Task HandleAsync(CommentDeletedFromRemark @event)
{
await _handler
.Run(async() =>
{
var remark = await _repository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
var comment = remark.Value.Comments.SingleOrDefault(x => x.Id == @event.CommentId);
if (comment == null)
{
return;
}
comment.History.Clear();
comment.Text = string.Empty;
comment.Removed = true;
remark.Value.UpdatedAt = DateTime.UtcNow;
await _repository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
}
public async Task HandleAsync(AddPhotosToRemarkRejected @event)
=> await _handler
.Run(async() =>
{
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
remark.Value.Status = null;
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
public async Task HandleAsync(RemarkCreated @event)
{
await _handler
.Run(async() =>
{
var remark = await _remarkServiceClient.GetAsync <Remark>(@event.RemarkId);
remark.Value.Status = null;
await _remarkRepository.AddAsync(remark.Value);
await _remarkCache.AddAsync(remark.Value, addGeo: true, addLatest: true);
await _userCache.AddRemarkAsync(remark.Value.Author.UserId, @event.RemarkId);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
}
public async Task HandleAsync(RemarkVoteSubmitted @event)
{
await _handler
.Run(async() =>
{
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
Vote(remark.Value, @event.UserId, @event.Positive);
remark.Value.Votes.Add(new Vote
{
UserId = @event.UserId,
Positive = @event.Positive,
CreatedAt = @event.CreatedAt
});
remark.Value.UpdatedAt = DateTime.UtcNow;
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.ExecuteAsync();
}
public async Task HandleAsync(CommentAddedToRemark @event)
{
await _handler
.Run(async() =>
{
var remark = await _repository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
remark.Value.UpdatedAt = DateTime.UtcNow;
if (remark.Value.Comments == null)
{
remark.Value.Comments = new List <Comment>();
}
remark.Value.Comments.Add(new Comment
{
Id = @event.CommentId,
Text = @event.Text,
User = new RemarkUser
{
UserId = @event.UserId,
Name = @event.Username
},
CreatedAt = @event.CreatedAt,
Votes = new List <Vote>(),
History = new List <CommentHistory>()
});
await _repository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
}
public async Task HandleAsync(FavoriteRemarkAdded @event)
{
await _handler
.Run(async() =>
{
var user = await _userRepository.GetByIdAsync(@event.UserId);
if (user.HasNoValue)
{
throw new ServiceException(OperationCodes.UserNotFound,
$"Favorite remark cannot be added because user: {@event.UserId} does not exist");
}
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
if (user.Value.FavoriteRemarks == null)
{
user.Value.FavoriteRemarks = new HashSet <Guid>();
}
if (remark.Value.UserFavorites == null)
{
remark.Value.UserFavorites = new HashSet <string>();
}
user.Value.FavoriteRemarks.Add(@event.RemarkId);
remark.Value.UserFavorites.Add(@event.UserId);
await _userRepository.EditAsync(user.Value);
await _remarkRepository.UpdateAsync(remark.Value);
await _remarkCache.AddAsync(remark.Value);
await _userCache.AddAsync(user.Value);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
}
public async Task HandleAsync(RemarkActionCanceled @event)
{
await _handler
.Run(async() =>
{
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
var participant = remark.Value.Participants.SingleOrDefault(x => x.User.UserId == @event.UserId);
if (participant == null)
{
return;
}
remark.Value.UpdatedAt = DateTime.UtcNow;
remark.Value.Participants.Remove(participant);
remark.Value.ParticipantsCount--;
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.ExecuteAsync();
}