public static void HandleSubscribe(Message message, TextWriter log)
{
string feedUrl = message.Body.FeedUrl;
string imageUri = message.Body.ImageUri;
string hash = Convert.ToBase64String(message.Hash.Code);
Guid userGuid = message.ObjectId;
using (var context = new CommuterDbContext())
{
Podcast podcast = context.Podcasts
.FirstOrDefault(p => p.FeedUrl == feedUrl);
if (podcast == null)
{
podcast = context.Podcasts.Add(new Podcast
{
FeedUrl = feedUrl,
ImageUri = imageUri
});
log.WriteLine($"Adding new podcast {feedUrl}.");
}
else
{
log.WriteLine($"Adding subscription for existing podcast {feedUrl}.");
}
context.Subscriptions.Add(new Subscription
{
Podcast = podcast,
UserGuid = userGuid,
Hash = hash
});
context.SaveChanges();
}
}
public void Save(Message message)
{
var objectId = message.ObjectId;
var messages = _messagesByObjectId.GetValueOrDefault(
objectId, ImmutableList<Message>.Empty);
_messagesByObjectId = _messagesByObjectId.SetItem(
objectId, messages.Add(message));
}
private async Task EnqueueInternalAsync(Message message)
{
var messageList = await ReadMessagesAsync();
var memento = message.GetMemento();
messageList.Add(memento);
await WriteMessagesAsync(messageList);
}
private async Task ConfirmInternalAsync(Message message)
{
var messageList = await ReadMessagesAsync();
string hash = message.Hash.ToString();
messageList.RemoveAll(o => o.Hash == hash);
await WriteMessagesAsync(messageList);
}
public Subscription CreateSubscription(Message message)
{
string feedUrl = message.Body.FeedUrl;
string imageUri = message.Body.ImageUri;
string title = message.Body.Title;
string subtitle = message.Body.Subtitle;
string author = message.Body.Author;
return new Subscription(
new Uri(feedUrl, UriKind.Absolute),
new Uri(imageUri, UriKind.Absolute),
title,
subtitle,
author,
message.Hash);
}
private async Task SaveInternalAsync(Message message)
{
string fileName = String.Format("obj_{0}.json",
message.ObjectId.ToCanonicalString());
var inputStream = await FileImplementation.OpenForRead(
_folderName, fileName);
var messages = ReadMessages(inputStream);
if (!messages.Any(m => m.Hash == message.Hash.ToString()))
{
messages.Add(message.GetMemento());
var outputStream = await FileImplementation.OpenForWrite(
_folderName, fileName);
WriteMessages(outputStream, messages);
}
}
public static SearchResult FromMessage(Message message)
{
string feedUrl = message.Body.FeedUrl;
string title = message.Body.Title;
string subtitle = message.Body.Subtitle;
string author = message.Body.Author;
string imageUri = message.Body.ImageUri;
var searchResult = new SearchResult(
new Uri(feedUrl, UriKind.Absolute),
title,
subtitle,
author,
new Uri(imageUri, UriKind.Absolute),
message.Hash);
return searchResult;
}
public static void HandleUnsubscribe(Message message, TextWriter log)
{
var hashes = message.GetPredecessors("Subscription")
.Select(p => Convert.ToBase64String(p.Code))
.ToList();
using (var context = new CommuterDbContext())
{
var predecessors = context.Subscriptions
.Where(s => hashes.Contains(s.Hash))
.ToList();
context.Subscriptions.RemoveRange(predecessors);
log.WriteLine($"Removing {predecessors.Count} podcast subscriptions");
context.SaveChanges();
}
}
private static async Task HandleSearch(Message searchMessage, TextWriter log)
{
string searchTerm = searchMessage.Body.SearchTerm;
log.WriteLine($"Searching for {searchTerm}");
var searchResults = await PerformSearch(searchTerm, log);
log.WriteLine($"Found {searchResults.Count} results");
var searchTermId = new { Text = searchTerm }.ToGuid();
var searchResultMessages = searchResults.Select(r => CreateSearchResultMessage(
searchMessage.Hash,
searchTermId,
r)).ToImmutableList();
var aggregateMessage = CreateAggregateMessage(searchTermId, searchResultMessages);
var pump = GetMessagePump();
pump.SendAllMessages(searchResultMessages);
pump.Enqueue(aggregateMessage);
}
public void OnDownloaded(Message message)
{
_fileName.Value = message.Body.FileName;
}
public void HandleMessage(Message message)
{
_dispatcher.Dispatch(this, message);
_playhead.HandleMessage(message);
}
private Queue CreateQueue(Message message)
{
string title = message.Body.Title;
string summary = message.Body.Summary;
DateTime publishedDate = message.Body.PublishedDate;
string mediaUrl = message.Body.MediaUrl;
string imageUri = message.Body.ImageUri;
return new Queue(
new { UserGuid = _userId, mediaUrl = mediaUrl }.ToGuid(),
_userId,
new Uri(mediaUrl, UriKind.Absolute),
title,
summary,
publishedDate,
new Uri(imageUri, UriKind.Absolute));
}
private static void HandleUnsubscribe(Message message, TextWriter log)
{
MessageHandlers.HandleUnsubscribe(message, log);
CheckFeeds(log).Wait();
}
public void Confirm(Message message)
{
}
private void HandleSearch(Message message)
{
string searchTerm = message.Body.SearchTerm;
var searchTermId = new { Text = searchTerm }.ToGuid();
_searchTerm.Value = new SearchTerm(
searchTermId, searchTerm);
}
public void Save(Message message)
{
Perform(() => SaveInternalAsync(message));
}
public void HandleEpisode(Message message)
{
if (!_episodes.Any(e => e.Hash == message.Hash))
_episodes.Add(new Episode
{
Title = message.Body.Title,
Summary = message.Body.Summary,
PublishDate = message.Body.PublishDate,
MediaUrl = new Uri(message.Body.MediaUrl, UriKind.Absolute),
Hash = message.Hash
});
}
public void HandleMessage(Message message)
{
_dispatcher.Dispatch(this, message);
_subscriptions.HandleMessage(message);
_queuedEpisodes.HandleMessage(message);
}
public void Confirm(Message message)
{
Perform(() => ConfirmInternalAsync(message));
}
public void HandleMessage(Message message)
{
_dispatcher.Dispatch(this, message);
}
public void Enqueue(Message message)
{
Perform(() => EnqueueInternalAsync(message));
}
public void Enqueue(Message message)
{
}
public static Aggregate FromMessage(Message message)
{
var hashes = message.GetPredecessors("SearchResult");
return new Aggregate(hashes.ToImmutableHashSet());
}
