public async Task <IActionResult> CreateBlog(BlogForCreateDto blogForCreateDto)
{
if (blogForCreateDto == null)
{
return(BadRequest("Blog data can not be empty"));
}
blogForCreateDto.UserId = Convert.ToInt32(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var blog = new Blog.Models.Blog
{
Content = blogForCreateDto.Content,
CreatedAt = blogForCreateDto.CreatedAt,
Title = blogForCreateDto.Title,
UserId = blogForCreateDto.UserId
};
try
{
await _blogRepository.Create(blog);
return(StatusCode(201));
}
catch (Exception)
{
throw;
}
}
public static User CreateUser(TeknikEntities db, Config config, string username, string inviteCode)
{
try
{
User newUser = new User();
newUser.Username = username;
newUser.UserSettings = new UserSettings();
newUser.BlogSettings = new BlogSettings();
newUser.UploadSettings = new UploadSettings();
// if they provided an invite code, let's assign them to it
if (!string.IsNullOrEmpty(inviteCode))
{
InviteCode code = db.InviteCodes.Where(c => c.Code == inviteCode).FirstOrDefault();
db.Entry(code).State = EntityState.Modified;
newUser.ClaimedInviteCode = code;
}
// Add User
db.Users.Add(newUser);
// Generate blog for the user
var newBlog = new Blog.Models.Blog();
newBlog.User = newUser;
db.Blogs.Add(newBlog);
// Save the changes
db.SaveChanges();
return(newUser);
}
catch (Exception ex)
{
throw new Exception("Unable to create user.", ex);
}
}
public static void DeleteUser(TeknikEntities db, Config config, User user)
{
try
{
// Update uploads
List <Upload.Models.Upload> uploads = db.Uploads.Where(u => u.User.Username == user.Username).ToList();
if (uploads.Any())
{
foreach (Upload.Models.Upload upload in uploads)
{
upload.UserId = null;
db.Entry(upload).State = EntityState.Modified;
}
db.SaveChanges();
}
// Update pastes
List <Paste.Models.Paste> pastes = db.Pastes.Where(u => u.User.Username == user.Username).ToList();
if (pastes.Any())
{
foreach (Paste.Models.Paste paste in pastes)
{
paste.UserId = null;
db.Entry(paste).State = EntityState.Modified;
}
db.SaveChanges();
}
// Update shortened urls
List <ShortenedUrl> shortUrls = db.ShortenedUrls.Where(u => u.User.Username == user.Username).ToList();
if (shortUrls.Any())
{
foreach (ShortenedUrl shortUrl in shortUrls)
{
shortUrl.UserId = null;
db.Entry(shortUrl).State = EntityState.Modified;
}
db.SaveChanges();
}
// Update vaults
List <Vault.Models.Vault> vaults = db.Vaults.Where(u => u.User.Username == user.Username).ToList();
if (vaults.Any())
{
foreach (Vault.Models.Vault vault in vaults)
{
vault.UserId = null;
db.Entry(vault).State = EntityState.Modified;
}
db.SaveChanges();
}
// Delete Blogs
Blog.Models.Blog blog = db.Blogs.Where(u => u.User.Username == user.Username).FirstOrDefault();
if (blog != null)
{
db.Blogs.Remove(blog);
db.SaveChanges();
}
// Delete post comments
List <BlogPostComment> postComments = db.BlogPostComments.Where(u => u.User.Username == user.Username).ToList();
if (postComments.Any())
{
foreach (BlogPostComment postComment in postComments)
{
db.BlogPostComments.Remove(postComment);
}
db.SaveChanges();
}
// Delete podcast comments
List <Podcast.Models.PodcastComment> podComments = db.PodcastComments.Where(u => u.User.Username == user.Username).ToList();
if (podComments.Any())
{
foreach (Podcast.Models.PodcastComment podComment in podComments)
{
db.PodcastComments.Remove(podComment);
}
db.SaveChanges();
}
// Delete Owned Invite Codes
List <InviteCode> ownedCodes = db.InviteCodes.Where(i => i.Owner.Username == user.Username).ToList();
if (ownedCodes.Any())
{
foreach (InviteCode code in ownedCodes)
{
db.InviteCodes.Remove(code);
}
db.SaveChanges();
}
// Delete Claimed Invite Code
List <InviteCode> claimedCodes = db.InviteCodes.Where(i => i.ClaimedUser.Username == user.Username).ToList();
if (claimedCodes.Any())
{
foreach (InviteCode code in claimedCodes)
{
db.InviteCodes.Remove(code);
}
db.SaveChanges();
}
// Delete Auth Tokens
//List<AuthToken> authTokens = db.AuthTokens.Where(t => t.User.UserId == user.UserId).ToList();
//if (authTokens.Any())
//{
// foreach (AuthToken authToken in authTokens)
// {
// db.AuthTokens.Remove(authToken);
// }
// db.SaveChanges();
//}
// Delete User
db.Users.Remove(user);
db.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(string.Format("Unable to delete user {0}.", user.Username), ex);
}
}
public async Task Blog(string username)
{
Response.ContentType = "application/rss+xml";
// If empty, grab the main blog
List <BlogPost> posts = new List <BlogPost>();
string blogUrl = Url.SubRouteUrl("blog", "Blog.Blog");
string title = string.Empty;
string description = string.Empty;
bool isSystem = string.IsNullOrEmpty(username);
bool userExists = false;
if (isSystem)
{
posts = _dbContext.BlogPosts.Where(p => (p.System && p.Published)).ToList();
blogUrl = Url.SubRouteUrl("blog", "Blog.Blog");
}
else
{
Blog.Models.Blog blog = _dbContext.Blogs.Where(p => p.User.Username == username && p.BlogId != _config.BlogConfig.ServerBlogId).FirstOrDefault();
posts = _dbContext.BlogPosts.Where(p => (p.BlogId == blog.BlogId && !p.System) && p.Published).ToList();
blogUrl = Url.SubRouteUrl("blog", "Blog.Blog", new { username = username });
}
if (posts.Any())
{
if (isSystem)
{
userExists = true;
title = _config.BlogConfig.Title;
description = _config.BlogConfig.Description;
}
else
{
Users.Models.User user = UserHelper.GetUser(_dbContext, username);
if (user != null)
{
userExists = true;
title = user.BlogSettings.Title;
description = user.BlogSettings.Description;
}
else
{
userExists = false;
title = "No Blog Available";
description = "The specified user does not exist";
}
}
List <SyndicationItem> items = new List <SyndicationItem>();
if (userExists)
{
foreach (BlogPost post in posts.OrderByDescending(p => p.BlogPostId))
{
if (post.Published && post.System == isSystem)
{
SyndicationItem item = new SyndicationItem()
{
Id = post.BlogPostId.ToString(),
Title = post.Title,
Description = MarkdownHelper.Markdown(post.Article).Value,
Published = post.DatePublished
};
item.AddLink(new SyndicationLink(new Uri(Url.SubRouteUrl("blog", "Blog.Post", new { username = post.Blog.User.Username, id = post.BlogPostId }))));
item.AddContributor(new SyndicationPerson(post.Blog.User.Username, UserHelper.GetUserEmailAddress(_config, post.Blog.User.Username)));
items.Add(item);
}
}
}
using (var xmlWriter = CreateXmlWriter())
{
var feedWriter = new RssFeedWriter(xmlWriter);
await feedWriter.WriteTitle(title);
await feedWriter.WriteDescription(description);
await feedWriter.Write(new SyndicationLink(new Uri(blogUrl)));
foreach (SyndicationItem item in items)
{
await feedWriter.Write(item);
}
await xmlWriter.FlushAsync();
}
}
else
{
using (var xmlWriter = CreateXmlWriter())
{
var feedWriter = new RssFeedWriter(xmlWriter);
await feedWriter.WriteTitle("No Blog Available");
await feedWriter.WriteDescription("The specified blog does not exist");
await feedWriter.Write(new SyndicationLink(new Uri(blogUrl)));
await xmlWriter.FlushAsync();
}
}
}
