public async Task HandleAsync(PhotosFromRemarkRemoved @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.Photos.Clear();
foreach (var photo in remarkDto.Value.Photos)
{
remark.Value.Photos.Add(photo);
}
remark.Value.UpdatedAt = DateTime.UtcNow;
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 <Maybe <Remark> > GetAsync(Guid id)
{
var remark = await _provider.GetAsync(
async() => await _remarkRepository.GetByIdAsync(id),
async() => await _serviceClient.GetAsync <Remark>(id));
if (remark.HasNoValue)
{
return(null);
}
if (remark.Value.Tags?.Any() == true)
{
remark.Value.SelectedTag = remark.Value.Tags.First().Name;
}
if (remark.Value.Group == null)
{
return(remark);
}
var group = await _groupRepository.GetAsync(remark.Value.Group.Id);
remark.Value.Group.Criteria = group.Value.Criteria;
remark.Value.Group.Members = group.Value.Members.ToDictionary(x => x.UserId, x => x.Role);
return(remark);
}
public async Task HandleAsync(RemarkCommentVoteDeleted @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;
}
var vote = comment.Votes.SingleOrDefault(x => x.UserId == @event.UserId);
if (vote.Positive)
{
comment.Rating--;
}
else
{
comment.Rating++;
}
comment.Votes.Remove(vote);
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.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(FavoriteRemarkDeleted @event)
{
await _handler
.Run(async() =>
{
var user = await _userRepository.GetByIdAsync(@event.UserId);
if (user.HasNoValue)
{
throw new ServiceException(OperationCodes.UserNotFound,
$"Favorite remark cannot be deleted because user: {@event.UserId} does not exist");
}
user.Value.FavoriteRemarks.Remove(@event.RemarkId);
await _userRepository.EditAsync(user.Value);
await _userCache.AddAsync(user.Value);
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
remark.Value.UserFavorites.Remove(@event.UserId);
await _remarkRepository.UpdateAsync(remark.Value);
await _remarkCache.AddAsync(remark.Value);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
}
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(RemarkVoteDeleted @event)
{
await _handler
.Run(async() =>
{
var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
var vote = remark.Value.Votes
.SingleOrDefault(x => x.UserId == @event.UserId);
if (vote.Positive)
{
remark.Value.Rating--;
remark.Value.PositiveVotesCount--;
}
else
{
remark.Value.Rating++;
remark.Value.NegativeVotesCount--;
}
remark.Value.UpdatedAt = DateTime.UtcNow;
remark.Value.Votes.Remove(vote);
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value);
})
.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(RemarkRenewed @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 = false;
await _remarkRepository.UpdateAsync(remark.Value);
await _cache.AddAsync(remark.Value, addGeo: true);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
}
public async Task HandleAsync(RemarkAssignedToGroup @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.State = remarkDto.Value.State;
remark.Value.States = remarkDto.Value.States;
remark.Value.Assignee = remarkDto.Value.Assignee;
remark.Value.UpdatedAt = remarkDto.Value.UpdatedAt;
await _remarkRepository.UpdateAsync(remark.Value);
await _groupRemarkRepository.DeleteAllForRemarkAsync(@event.RemarkId);
await _cache.AddAsync(remark.Value);
})
.OnError((ex, logger) =>
{
logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event");
})
.ExecuteAsync();
public async Task HandleAsync(CommentEditedInRemark @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.Text = @event.Text;
comment.History.Add(new CommentHistory
{
Text = comment.Text,
CreatedAt = @event.CreatedAt
});
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 <Maybe <IEnumerable <string> > > GetPhotosForGroupsAsync(Guid remarkId, params Guid[] groupIds)
{
if (groupIds == null || !groupIds.Any())
{
return(null);
}
var remark = await _remarkRepository.GetByIdAsync(remarkId);
if (remark.HasNoValue)
{
return(null);
}
return(remark.Value.Photos
.Where(x => groupIds.Contains(x.GroupId))
.Select(x => x.Name)
.ToList());
}
public async Task HandleAsync(RemarkDeleted @event)
=> await _handler
.Run(async() =>
{
var remark = await _repository.GetByIdAsync(@event.RemarkId);
if (remark.HasNoValue)
{
return;
}
await _repository.DeleteAsync(remark.Value);
await _groupRemarkRepository.DeleteAllForRemarkAsync(@event.RemarkId);
await _remarkCache.DeleteAsync(@event.RemarkId, deleteGeo: true, deleteLatest: true);
await _userCache.DeleteRemarkAsync(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 PublishRemarkCreatedAsync(Guid remarkId, string culture, params UserSocialMedia[] socialMedia)
{
var remark = await _remarkRepository.GetByIdAsync(remarkId);
if (remark.HasNoValue)
{
return;
}
foreach (var service in socialMedia)
{
Logger.Debug($"Remark with id: '{remarkId}' will be published on: '{service.Name}'.");
switch (service.Name)
{
case "facebook":
var message = await _localizedResourceService.TranslateAsync("facebook:new_remark",
culture, $"{_generalSettings.RemarkDetailsUrl}{remarkId}");
if (message.HasNoValue)
{
Logger.Debug($"Remark with id: '{remarkId}' will not be published " +
$"on: '{service.Name}' as the translated message was not found.");
break;
}
await _bus.PublishAsync(new PostOnFacebookWall
{
Request = Request.New <PostOnFacebookWall>(),
UserId = remark.Value.Author.UserId,
AccessToken = service.AccessToken,
Message = message.Value
});
Logger.Debug($"Remark with id: '{remarkId}' was published on: '{service.Name}'.");
break;
}
}
}
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(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();
}
public static async Task <Remark> GetOrFailAsync(this IRemarkRepository repository, Guid remarkId)
=> await repository
.GetByIdAsync(remarkId)
.UnwrapAsync(noValueException: new ServiceException(OperationCodes.RemarkNotFound,
$"Remark with id: '{remarkId}' does not exist!"));
public async Task <Maybe <Remark> > GetAsync(Guid id) => await _remarkRepository.GetByIdAsync(id);
