public void Handle(TagChangedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
var state = _db.GetObject <BlogState>(key);
if (state == null)
{
throw new Exception("Blog has to be started first.");
}
var tags = state
.Posts
.SelectMany(_ => _.Tags)
.Where(_ => _.TagUrl == evnt.Url)
.ToList();
foreach (var tag in tags)
{
tag.TagTitle = evnt.Title;
tag.TagUrl = evnt.Url;
}
_db.SetObject(key, state);
}
public void Handle(LinkClosedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
var state = _db.GetObject <BlogState>(key);
if (state == null)
{
throw new Exception("Blog has to be started first.");
}
state.Links.RemoveAll(_ => _.Id == evnt.Url);
_db.SetObject(key, state);
}
public async Task <PostView> ExecuteAsync()
{
var key = KeyUtils.GetStateKey(_blogId);
var state = await _db.GetObjectAsync <BlogState>(key);
var post = state.Posts.FirstOrDefault(_ => _.Url == _postId);
var links = state.Links.Select(_ => new LinkHomeView
{
Id = _.Id,
Title = _.Title,
Order = _.Order
});
var result = new PostView
{
Id = _blogId,
Url = _postId,
Avatar = state.Avatar,
Brand = state.Brand,
Copyright = state.Copyright,
Github = state.Github,
Linkedin = state.Linkedin,
Twitter = state.Twitter,
Title = post.Title,
Comments = post.Comments,
Infobar = post.Infobar,
Links = links.ToList(),
Body = post.Body,
Date = post.PublishAt.ToShortDateString(),
Category = new CategoryHomeView {
Id = post.CategoryUrl, Title = post.CategoryTitle
},
Tags = post.Tags.Select(tag => new TagHomeView {
Id = tag.TagUrl, Title = tag.TagTitle
}).ToList()
};
return(result);
}
public void Handle(TagStartedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
var state = _db.GetObject <BlogState>(key);
if (state == null)
{
throw new Exception("Blog has to be started first.");
}
var tag = new TagState
{
TagUrl = evnt.Url,
TagTitle = evnt.Title
};
state.Tags.Add(tag);
_db.SetObject(key, state);
}
public void Handle(CategoryChangedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
var state = _db.GetObject <BlogState>(key);
if (state == null)
{
throw new Exception("Blog has to be started first.");
}
var posts = state.Posts.Where(_ => _.CategoryUrl == evnt.Url).ToList();
foreach (var post in posts)
{
post.CategoryTitle = evnt.Title;
post.CategoryUrl = evnt.Url;
}
_db.SetObject(key, state);
}
public void Handle(CategoryStartedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
var state = _db.GetObject <BlogState>(key);
if (state == null)
{
throw new Exception("Blog has to be started first.");
}
var category = new CategoryState
{
Url = evnt.Url,
Title = evnt.Title
};
state.Categories.Add(category);
_db.SetObject(key, state);
}
public void Handle(LinkStartedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
var state = _db.GetObject <BlogState>(key);
if (state == null)
{
throw new Exception("Blog has to be started first.");
}
var item = new LinkState
{
Id = evnt.Url,
Title = evnt.Title,
Order = evnt.Order
};
state.Links.Add(item);
_db.SetObject(key, state);
}
public void Handle(PostStartedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
var state = _db.GetObject <BlogState>(key);
if (state == null)
{
throw new Exception("Blog has to be started first.");
}
var bodyHtml = TextUtils.GetHtmlFromMarkdown(evnt.Body);
var bodyShortHtml = TextUtils.GetHtmlFromMarkdown(TextUtils.GetBodyShort(evnt.Body));
var tags = evnt.Tags.Select(_ => new TagState
{
TagUrl = _.Url,
TagTitle = _.Title
}).ToList();
var post = new PostState
{
Url = evnt.Url,
Title = evnt.Title,
Body = bodyHtml,
BodyShort = bodyShortHtml,
PublishAt = evnt.PublishAt,
CategoryTitle = evnt.CategoryTitle,
CategoryUrl = evnt.CategoryUrl,
Infobar = evnt.Infobar,
IsHidden = evnt.Hidden,
Tags = tags
};
state.Posts.Add(post);
_db.SetObject(key, state);
}
public void Handle(PostChangedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
var state = _db.GetObject <BlogState>(key);
if (state == null)
{
throw new Exception("Blog has to be started first.");
}
var post = state.Posts.FirstOrDefault(_ => _.Url == evnt.Url);
if (post == null)
{
throw new Exception("Post should be created first.");
}
var tags = evnt.Tags.Select(_ => new TagState
{
TagUrl = _.Url,
TagTitle = _.Title
}).ToList();
post.Url = evnt.Url;
post.Title = evnt.Title;
post.BodyShort = TextUtils.GetHtmlFromMarkdown(TextUtils.GetBodyShort(evnt.Body));
post.Body = TextUtils.GetHtmlFromMarkdown(evnt.Body);
post.PublishAt = evnt.PublishAt;
post.CategoryTitle = evnt.CategoryTitle;
post.CategoryUrl = evnt.CategoryUrl;
post.Infobar = evnt.Infobar;
post.IsHidden = evnt.Hidden;
post.Tags = tags;
_db.SetObject(key, state);
}
public void Handle(BlogStartedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
var state = _db.GetObject <BlogState>(key);
if (state != null)
{
throw new Exception("There is a blog with the same host name in the store.");
}
state = new BlogState
{
Id = evnt.AggregateId,
Brand = evnt.Brand,
Copyright = evnt.Copyright,
Avatar = evnt.Avatar,
Github = evnt.Github,
Twitter = evnt.Twitter,
Linkedin = evnt.Linkedin
};
_db.SetObject(key, state);
}
public async Task <HomeView> ExecuteAsync()
{
var key = KeyUtils.GetStateKey(_blogId);
var filter = new FilterHomeView {
By = "none"
};
var state = await _db.GetObjectAsync <BlogState>(key);
var query = state.Posts.Where(_ => !_.IsHidden);
if (!string.IsNullOrEmpty(_filterByDate))
{
var date = DateTime.Parse(_filterByDate);
query = query.Where(_ => _.PublishAt == date);
filter = new FilterHomeView {
By = "date", Title = _filterByDate
};
}
if (!string.IsNullOrEmpty(_filterByCategory))
{
query = query.Where(_ => !string.IsNullOrEmpty(_.CategoryUrl) && _.CategoryUrl.StartsWith(_filterByCategory));
var category = state.Categories.FirstOrDefault(_ => _.Url == _filterByCategory);
filter = new FilterHomeView {
By = "category", Title = category.Title
};
}
if (!string.IsNullOrEmpty(_filterByTag))
{
query = query.Where(_ => _.Tags.Any(t => t.TagUrl == _filterByTag));
var tag = state.Tags.FirstOrDefault(_ => _.TagUrl == _filterByTag);
filter = new FilterHomeView {
By = "tag", Title = tag.TagTitle
};
}
var posts = query
.OrderByDescending(_ => _.PublishAt)
.ToList();
var links = state.Links.Select(_ => new LinkHomeView
{
Id = _.Id,
Title = _.Title,
Order = _.Order
});
var result = new HomeView
{
Id = _blogId,
Avatar = state.Avatar,
Brand = state.Brand,
Copyright = state.Copyright,
Github = state.Github,
Linkedin = state.Linkedin,
Twitter = state.Twitter,
Links = links.ToList(),
Filter = filter,
Posts = posts
.Skip(_pageIndex * _pageSize)
.Take(_pageSize)
.Select(_ => new PostHomeView
{
Id = _.Url,
Url = _.Url,
Title = _.Title,
Short = _.BodyShort,
Date = _.PublishAt.ToString("dd-MM-yyyy"),
Category = new CategoryHomeView {
Id = _.CategoryUrl, Title = _.CategoryTitle
},
Tags = _.Tags.Select(tag => new TagHomeView {
Id = tag.TagUrl, Title = tag.TagTitle
}).ToList()
})
.ToList(),
PageIndex = _pageIndex,
PageSize = _pageSize,
PagesCount = (int)Ceiling(posts.Count / (double)_pageSize)
};
return(result);
}
public void Handle(BlogClosedEvent evnt)
{
var key = KeyUtils.GetStateKey(evnt.AggregateId);
_db.KeyDelete(key);
}
