// GET api/posts?tags=tag1,tag2
public HttpResponseMessage GetByTags(string sessionKey, string tags)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var keyExists = context.Users
.Any(user => user.SessionKey == sessionKey);
if (!keyExists)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
if (tags == null)
{
throw new ServerErrorException(
"Tags value must be set",
HttpStatusCode.BadRequest);
}
var tagsCollection = tags.ToLower().Split(',');
return AllPosts(context)
.Where(p => tagsCollection.All(tag => p.Tags.Contains(tag)));
});
return responseMessage;
}
public HttpResponseMessage GetAll(string sessionKey)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var keyExists = context.Users
.Any(user => user.SessionKey == sessionKey);
if (!keyExists)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
var tagModels = context.Tags.Select(tag =>
new TagModel()
{
Id = tag.Id,
Name = tag.Name,
Posts = tag.Posts.Count
}
);
return tagModels
.OrderBy(model => model.Name);
});
return responseMessage;
}
public HttpResponseMessage GetMyComments(string sessionKey)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var user = context.Users
.FirstOrDefault(u => u.SessionKey == sessionKey);
if (user == null)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
return context.Comments
.Where(c => c.User.Id == user.Id)
.Select(c =>
new CommentModel()
{
Text = c.Text,
PostDate = c.PostDate,
CommentedBy = c.User.DisplayName
}).OrderByDescending(m => m.PostDate);
});
return responseMessage;
}
public HttpResponseMessage LoginUser([FromBody] UserLoginModel model)
{
var responseMessage = this.PerformOperation(() =>
{
using (var context = new BlogDbContext())
{
this.ValidateUsername(model.Username);
this.ValidateAuthCode(model.AuthCode);
var user = context.Users.FirstOrDefault(m =>
m.Username == model.Username.ToLower());
if (user == null)
{
throw new ServerErrorException(
"User does not exist",
HttpStatusCode.BadRequest);
}
if (user.AuthCode != model.AuthCode)
{
throw new ServerErrorException(
"Invalid authentication code",
HttpStatusCode.Unauthorized);
}
if (user.SessionKey == null)
{
user.SessionKey = this.GenerateSessionKey(user.Id);
context.SaveChanges();
}
var loggedUserModel = new UserLoggedModel()
{
DisplayName = user.DisplayName,
SessionKey = user.SessionKey
};
var response = this.Request.CreateResponse(
HttpStatusCode.Created,
loggedUserModel);
return response;
}
});
return responseMessage;
}
public HttpResponseMessage GetByTagId(int id, string sessionKey)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var keyExists = context.Users
.Any(user => user.SessionKey == sessionKey);
if (!keyExists)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
var postModels = context.Posts
.Where(post => post.Tags.Any(tag => tag.Id == id))
.Select(post =>
new PostModel()
{
Id = post.Id,
Title = post.Title,
PostedBy = post.User.DisplayName,
PostDate = post.PostDate,
Text = post.Text,
Tags = post.Tags.Select(tag => tag.Name),
Comments = post.Comments.Select(comment =>
new CommentModel()
{
Text = comment.Text,
CommentedBy = "asd",
PostDate = comment.PostDate
}
)
});
return postModels
.OrderByDescending(model => model.PostDate);
});
return responseMessage;
}
public HttpResponseMessage GetAll(string sessionKey)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var keyExists = context.Users
.Any(user => user.SessionKey == sessionKey);
if (!keyExists)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
return AllPosts(context);
});
return responseMessage;
}
public HttpResponseMessage GetMine(string sessionKey)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var user = context.Users
.FirstOrDefault(u => u.SessionKey == sessionKey);
if (user == null)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
return AllPosts(context)
.Where(p => p.PostedBy == user.DisplayName);
});
return responseMessage;
}
public HttpResponseMessage RegisterUser([FromBody] UserRegisterModel model)
{
var responseMessage = this.PerformOperation(() =>
{
using (var context = new BlogDbContext())
{
if (model == null)
{
throw new ServerErrorException(
"Username data must be set",
HttpStatusCode.BadRequest);
}
this.ValidateUsername(model.Username);
this.ValidateDisplayName(model.DisplayName);
this.ValidateAuthCode(model.AuthCode);
var modelUsernameLower = model.Username.ToLower();
var modelDisplayNameLower = model.DisplayName.ToLower();
var user = context.Users.FirstOrDefault(u =>
u.Username == modelUsernameLower ||
u.DisplayName.ToLower() == modelDisplayNameLower);
if (user != null)
{
if (user.Username == modelUsernameLower)
{
throw new ServerErrorException(
"Username already exists",
HttpStatusCode.Conflict);
}
if (user.DisplayName.ToLower() == modelDisplayNameLower)
{
throw new ServerErrorException(
"Display name already exists",
HttpStatusCode.Conflict);
}
}
var newUser = new User()
{
Username = modelUsernameLower,
DisplayName = model.DisplayName,
AuthCode = model.AuthCode
};
context.Users.Add(newUser);
context.SaveChanges();
newUser.SessionKey = GenerateSessionKey(newUser.Id);
context.SaveChanges();
var loggedUserModel = new UserLoggedModel()
{
DisplayName = newUser.DisplayName,
SessionKey = newUser.SessionKey
};
var response = this.Request.CreateResponse(
HttpStatusCode.Created,
loggedUserModel);
return response;
}
});
return responseMessage;
}
// GET api/posts/id
public HttpResponseMessage GetSinglePostById(string sessionKey, int postId)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var user = context.Users
.FirstOrDefault(u => u.SessionKey == sessionKey);
if (user == null)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
var post = context.Posts
.FirstOrDefault(p => p.Id == postId);
if (post == null)
{
throw new ServerErrorException(
"Post does not exist",
HttpStatusCode.BadRequest);
}
var postModel = new PostModel()
{
Id = post.Id,
PostedBy = post.User.DisplayName,
PostDate = post.PostDate,
Title = post.Title,
Text = post.Text,
Tags = post.Tags.Select(tag => tag.Name),
Comments = post.Comments.Select(comment =>
new CommentModel()
{
Text = comment.Text,
CommentedBy = comment.User.DisplayName,
PostDate = comment.PostDate
}
)
};
return Request.CreateResponse(
HttpStatusCode.OK,
postModel);
});
return responseMessage;
}
private static Tag GetOrCreateTag(BlogDbContext context, string name)
{
var nameToLower = name.ToLower();
var tagEntity = context.Tags
.FirstOrDefault(tag => tag.Name == nameToLower);
// If entity already exists
if (tagEntity != null)
{
return tagEntity;
}
var newTagEntity = new Tag()
{
Name = nameToLower
};
context.Tags.Add(newTagEntity);
context.SaveChanges();
return newTagEntity;
}
private static ICollection<Tag> GetAllPostTags(BlogDbContext context, string postTitle, IEnumerable<string> postTags)
{
var titleWorlds = postTitle.Split(
delimiters,
StringSplitOptions.RemoveEmptyEntries);
var tagEntities = new List<Tag>();
// For each create post request title word
foreach (var word in titleWorlds)
{
if (string.IsNullOrWhiteSpace(word))
{
continue;
}
var tagEntity = GetOrCreateTag(context, word);
tagEntities.Add(tagEntity);
}
// Foreach post create post request tags
if (postTags != null)
{
foreach (var tagWord in postTags)
{
if (string.IsNullOrWhiteSpace(tagWord))
{
continue;
}
// Add if not already added
var newTagEntity = GetOrCreateTag(context, tagWord);
if (tagEntities.Contains(newTagEntity) == false)
{
tagEntities.Add(newTagEntity);
}
}
}
return tagEntities;
}
public HttpResponseMessage PutBlogPostComment(string sessionKey, int postId, [FromBody] CommentCreateModel model)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var user = context.Users
.FirstOrDefault(u => u.SessionKey == sessionKey);
if (user == null)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
var post = context.Posts
.FirstOrDefault(p => p.Id == postId);
if (post == null)
{
throw new ServerErrorException(
"Post does not exist",
HttpStatusCode.BadRequest);
}
this.ValidateCommentCreateModel(model);
var commentEntity = new Comment()
{
Text = model.Text,
PostDate = DateTime.Now,
Post = post,
User = user
};
context.Comments.Add(commentEntity);
context.SaveChanges();
return;
});
return responseMessage;
}
// POST api/posts?sessionKey=...
public HttpResponseMessage PostCreateBlogPost(string sessionKey, [FromBody] PostCreateNewModel model)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var user = context.Users
.FirstOrDefault(u => u.SessionKey == sessionKey);
if (user == null)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
this.ValidatePostCreateModel(model);
var tagEntities = GetAllPostTags(context, model.Title, model.Tags);
var postEntity = new Post()
{
Title = model.Title,
Text = model.Text,
PostDate = DateTime.Now,
User = user,
Tags = tagEntities
};
context.Posts.Add(postEntity);
context.SaveChanges();
var postModel = new PostCreatedModel()
{
Id = postEntity.Id,
Title = postEntity.Title
};
return Request.CreateResponse(
HttpStatusCode.Created,
postModel);
});
return responseMessage;
}
public HttpResponseMessage PutEditPost([FromBody] PostModel editedModel, string sessionKey)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var user = context.Users
.FirstOrDefault(u => u.SessionKey == sessionKey);
if (user == null)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
var post = context.Posts
.FirstOrDefault(p => p.Id == editedModel.Id);
if (post == null)
{
throw new ServerErrorException(
"Post does not exist",
HttpStatusCode.BadRequest);
}
post.Text = editedModel.Text;
context.SaveChanges();
var response = this.Request.CreateResponse(
HttpStatusCode.OK,
"Post edited");
return response;
});
return responseMessage;
}
public HttpResponseMessage GetSearch(string sessionKey, string keyword)
{
var responseMessage = this.PerformOperation(() =>
{
this.ValidateSessionKey(sessionKey);
var context = new BlogDbContext();
var keyExists = context.Users
.Any(user => user.SessionKey == sessionKey);
if (!keyExists)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
if (keyword == null)
{
throw new ServerErrorException(
"Keyword value must be set",
HttpStatusCode.BadRequest);
}
return AllPosts(context)
.Where(post =>
post.Title.ToLower().Contains(keyword.ToLower())
);
});
return responseMessage;
}
private static IOrderedQueryable<PostModel> AllPosts(BlogDbContext context)
{
var postModels = context.Posts
.Select(post =>
new PostModel()
{
Id = post.Id,
Title = post.Title,
PostedBy = post.User.DisplayName,
PostDate = post.PostDate,
Text = post.Text,
Tags = post.Tags.Select(tag => tag.Name),
Comments = post.Comments.Select(comment =>
new CommentModel()
{
Text = comment.Text,
CommentedBy = comment.User.DisplayName,
PostDate = comment.PostDate
}
)
}
);
return postModels
.OrderByDescending(pm => pm.PostDate);
}
public HttpResponseMessage LogoutUser(string sessionKey)
{
var responseMessage = this.PerformOperation(() =>
{
using (var context = new BlogDbContext())
{
this.ValidateSessionKey(sessionKey);
var user = context.Users
.FirstOrDefault(u => u.SessionKey == sessionKey);
if (user == null)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
user.SessionKey = null;
context.SaveChanges();
var response = this.Request.CreateResponse(
HttpStatusCode.OK,
"Logged out");
return response;
}
});
return responseMessage;
}
public HttpResponseMessage GetIsAdmin(string sessionKey)
{
var responseMessage = this.PerformOperation(() =>
{
using (var context = new BlogDbContext())
{
this.ValidateSessionKey(sessionKey);
var user = context.Users
.FirstOrDefault(u => u.SessionKey == sessionKey);
if (user == null)
{
throw new ServerErrorException(
"Invalid or expired session",
HttpStatusCode.BadRequest);
}
HttpResponseMessage response;
if (!user.IsAdmin)
{
response = this.Request.CreateResponse(
HttpStatusCode.BadRequest,
"You do not have administrator priviliges to view this page!");
}
else
{
response = this.Request.CreateResponse(HttpStatusCode.OK);
}
return response;
}
});
return responseMessage;
}
