public void EditPost(BooruUser User, BooruPost Post)
{
if (User.CanEditPosts)
{
if (_DB.ExecuteScalar <int>(SQLStatements.GetPostCountByID, Post.ID) > 0)
{
if (!User.AdvancePostControl)
{
DataRow postRow = _DB.ExecuteRow(SQLStatements.GetPostByID, Post.ID);
BooruPost oldPost = BooruPost.FromRow(postRow);
Post.EditCount = oldPost.EditCount + 1;
Post.CreationDate = oldPost.CreationDate;
Post.User = oldPost.User;
Post.ViewCount = oldPost.ViewCount;
}
_DB.ExecuteNonQuery(SQLStatements.DeletePostByID, Post.ID);
_DB.ExecuteNonQuery(SQLStatements.DeletePostTagsByPostID, Post.ID);
CheckAndAddPostTags(ref Post);
_DB.ExecuteInsert("posts", Post.ToDictionary(true));
}
else
{
throw new BooruException(BooruException.ErrorCodes.ResourceNotFound);
}
}
else
{
throw new BooruException(BooruException.ErrorCodes.NoPermission);
}
}
public BooruPost GetPost(BooruUser User, ulong PostID, bool IncludeThumbnail)
{
DataRow postRow = _DB.ExecuteRow(SQLStatements.GetPostByID, PostID);
BooruPost post = BooruPost.FromRow(postRow);
if (post != null)
{
DataTable tagTable = _DB.ExecuteTable(SQLStatements.GetTagsByPostID, PostID);
post.Tags = BooruTagList.FromTable(tagTable);
if (User == null)
{
return(post);
}
else if (post.Rating <= User.MaxRating && IsPrivacyAllowed(post, User))
{
return(post);
}
else
{
throw new BooruException(BooruException.ErrorCodes.NoPermission);
}
}
else
{
throw new BooruException(BooruException.ErrorCodes.ResourceNotFound);
}
}
public void EditImage(BooruUser User, ulong PostID, BooruImage Image)
{
if (User.CanEditPosts)
{
DataRow postRow = _DB.ExecuteRow(SQLStatements.GetPostByID, PostID);
BooruPost post = BooruPost.FromRow(postRow);
if (post != null)
{
//Maybe Width + Height checks?
string thumbPath = Path.Combine(ThumbFolder, "thumb" + PostID);
string imagePath = Path.Combine(ImageFolder, "image" + PostID);
using (BooruImage thumbImage = Image.CreateThumbnail(BooruInfo.ThumbnailSize, false))
thumbImage.Save(thumbPath, BooruInfo.ThumbnailQuality);
Image.Save(imagePath);
_ImgOptimizer.Optimize(thumbPath);
_ImgOptimizer.Optimize(imagePath);
post.Width = (uint)Image.Bitmap.Width;
post.Height = (uint)Image.Bitmap.Height;
post.ImageHash = Image.CalculateImageHash();
_DB.ExecuteNonQuery(SQLStatements.DeletePostByID, PostID);
_DB.ExecuteInsert("posts", post.ToDictionary(true));
}
else
{
throw new BooruException(BooruException.ErrorCodes.ResourceNotFound);
}
}
else
{
throw new BooruException(BooruException.ErrorCodes.NoPermission);
}
}
public ulong AddPost(BooruUser User, BooruPost PostWithImage)
{
if (User.CanAddPosts)
{
if (!User.AdvancePostControl)
{
PostWithImage.EditCount = 0;
PostWithImage.CreationDate = DateTime.Now;
PostWithImage.ViewCount = 0;
PostWithImage.User = User.Username;
}
else if (string.IsNullOrWhiteSpace(PostWithImage.User))
{
PostWithImage.User = User.Username;
}
PostWithImage.Width = (uint)PostWithImage.Image.Bitmap.Width;
PostWithImage.Height = (uint)PostWithImage.Image.Bitmap.Height;
PostWithImage.ImageHash = PostWithImage.Image.CalculateImageHash();
PostWithImage.ID = (uint)_DB.ExecuteInsert("posts", PostWithImage.ToDictionary(false));
//Maybe Width + Height checks?
string thumbPath = Path.Combine(ThumbFolder, "thumb" + PostWithImage.ID);
string imagePath = Path.Combine(ImageFolder, "image" + PostWithImage.ID);
using (BooruImage thumbImage = PostWithImage.Image.CreateThumbnail(BooruInfo.ThumbnailSize, false))
thumbImage.Save(thumbPath, BooruInfo.ThumbnailQuality);
PostWithImage.Image.Save(imagePath);
_ImgOptimizer.Optimize(thumbPath);
_ImgOptimizer.Optimize(imagePath);
CheckAndAddPostTags(ref PostWithImage);
return(PostWithImage.ID);
}
else
{
throw new BooruException(BooruException.ErrorCodes.NoPermission);
}
}
public BooruImage GetThumbnail(BooruUser User, ulong PostID)
{
DataRow postRow = _DB.ExecuteRow(SQLStatements.GetPostByID, PostID);
BooruPost post = BooruPost.FromRow(postRow);
if (post != null)
{
string path = Path.Combine(ThumbFolder, "thumb" + PostID);
if (User == null)
{
return(BooruImage.FromFile(path));
}
else if (post.Rating <= User.MaxRating && IsPrivacyAllowed(post, User))
{
return(BooruImage.FromFile(path));
}
else
{
throw new BooruException(BooruException.ErrorCodes.NoPermission);
}
}
else
{
throw new BooruException(BooruException.ErrorCodes.ResourceNotFound);
}
}
private bool nonNegatedCheckPost(BooruPost Post)
{
FieldInfo[] fields = typeof(BooruPost).GetFields();
try
{
foreach (FieldInfo field in fields)
{
if (field.Name.ToLower() == Variable)
{
object convertedValue = Convert.ChangeType(Value, field.FieldType);
object fieldValue = field.GetValue(Post);
switch (Operator)
{
case 0: return(Convert.ToInt64(fieldValue) < Convert.ToInt64(convertedValue));
case 1: return(Convert.ToInt64(fieldValue) <= Convert.ToInt64(convertedValue));
case 3: return(Convert.ToInt64(fieldValue) >= Convert.ToInt64(convertedValue));
case 4: return(Convert.ToInt64(fieldValue) > Convert.ToInt64(convertedValue));
case 2: return(convertedValue.Equals(fieldValue));
case 5: return(!convertedValue.Equals(fieldValue));
}
}
}
}
catch { }
return(false);
}
private bool IsPrivacyAllowed(BooruPost Post, BooruUser User)
{
if (Post.Private && !User.IsAdmin)
{
return(Post.User == User.Username);
}
else
{
return(true);
}
}
private static bool DoSpecialPatternChecks(List <SpecialPattern> Patterns, BooruPost Post)
{
foreach (var check in Patterns)
{
if (!(check.CheckPost(Post)))
{
return(false);
}
}
return(true);
}
public TitlingResult PostToIrc(TitlingRequest req)
{
BooruPost postInfo = GelboTools.GetPostInfo(req.Url);
req.Resource = postInfo;
if (postInfo.Success)
{
string warning = ConstructWarning(postInfo.Tags);
if (!string.IsNullOrEmpty(warning))
{
FormatMessage(req.IrcTitle, postInfo.Rated, warning, postInfo.PostNo);
return(req.CreateResult(true));
}
}
return(req.CreateResult(false));
}
private void CheckAndAddPostTags(ref BooruPost newPost)
{
for (int i = newPost.Tags.Count - 1; !(i < 0); i--)
{
newPost.Tags[i].Tag = newPost.Tags[i].Tag.Trim().ToLower();
if (string.IsNullOrWhiteSpace(newPost.Tags[i].Tag))
{
newPost.Tags.RemoveAt(i);
}
}
foreach (BooruTag tag in newPost.Tags)
{
DataRow existingTagRow = _DB.ExecuteRow(SQLStatements.GetTagByTagString, tag.Tag);
BooruTag existingTag = BooruTag.FromRow(existingTagRow);
if (existingTag == null)
{
bool taggedAliasAdded = false;
DataRow existingAliasRow = _DB.ExecuteRow(SQLStatements.GetAliasByString, tag.Tag);
if (existingAliasRow != null)
{
ulong tagID = Convert.ToUInt64(existingAliasRow["tagid"]);
if (_DB.ExecuteScalar <int>(SQLStatements.GetTagCountByID, tagID) > 0)
{
_DB.ExecuteNonQuery(SQLStatements.InsertPostTag, newPost.ID, tagID);
taggedAliasAdded = true;
}
}
if (!taggedAliasAdded)
{
_DB.ExecuteNonQuery(SQLStatements.InsertTag, tag.Tag, BooruInfo.DefaultTagType);
ulong newTagID = _DB.GetLastInsertedID();
_DB.ExecuteNonQuery(SQLStatements.InsertPostTag, newPost.ID, newTagID);
}
}
else
{
_DB.ExecuteNonQuery(SQLStatements.InsertPostTag, newPost.ID, existingTag.ID);
}
}
}
public BooruImage GetImage(BooruUser User, ulong PostID)
{
DataRow postRow = _DB.ExecuteRow(SQLStatements.GetPostByID, PostID);
BooruPost post = BooruPost.FromRow(postRow);
if (post != null)
{
if (User == null || (post.Rating <= User.MaxRating && IsPrivacyAllowed(post, User)))
{
BooruImage image = BooruImage.FromFile(Path.Combine(ImageFolder, "image" + PostID));
_DB.ExecuteNonQuery(SQLStatements.UpdateIncrementViewCount, PostID);
return(image);
}
else
{
throw new BooruException(BooruException.ErrorCodes.NoPermission);
}
}
else
{
throw new BooruException(BooruException.ErrorCodes.ResourceNotFound);
}
}
private void _ClientHandlerStage3(RequestCode RQ, ReaderWriter RW, ref BooruUser User)
{
switch (RQ)
{
default: throw new NotSupportedException("Unknown request code");
case RequestCode.Get_Post:
{
ulong id = RW.ReadULong();
using (var post = _Booru.GetPost(User, id, false))
post.ToWriter(RW);
} break;
case RequestCode.Get_Thumb:
{
ulong id = RW.ReadULong();
using (var thumb = _Booru.GetThumbnail(User, id))
thumb.ToWriter(RW);
} break;
case RequestCode.Get_Image:
{
ulong id = RW.ReadULong();
using (var image = _Booru.GetImage(User, id))
image.ToWriter(RW);
} break;
case RequestCode.Get_Tag:
{
ulong id = RW.ReadULong();
_Booru.GetTag(User, id).ToWriter(RW);
} break;
case RequestCode.Get_Info:
_Booru.BooruInfo.ToWriter(RW);
break;
case RequestCode.Get_AllTags:
{
List <string> tags = _Booru.GetAllTags();
RW.Write((uint)tags.Count);
foreach (string tag in tags)
{
RW.Write(tag, true);
}
} break;
case RequestCode.Get_PostTags:
{
ulong id = RW.ReadULong();
using (var post = _Booru.GetPost(User, id, false))
post.Tags.ToWriter(RW);
} break;
case RequestCode.Get_User:
User.ToWriter(RW);
break;
case RequestCode.Get_PostCount:
RW.Write(_Booru.GetPostCount());
break;
case RequestCode.Search_String: //User limitations?
{
string pattern = RW.ReadString();
List <ulong> ids = _Booru.Search(User, pattern);
RW.Write((uint)ids.Count);
foreach (ulong id in ids)
{
RW.Write(id);
}
} break;
case RequestCode.Search_Image:
throw new NotImplementedException(); //TODO Implement
case RequestCode.Login:
{
string username = RW.ReadString();
string password = RW.ReadString();
User = _Booru.Login(User, username, password);
} break;
case RequestCode.Logout:
User = _Booru.DefaultUser;
break;
case RequestCode.Search_Tags:
{
string term = RW.ReadString();
byte limit = RW.ReadByte();
_Booru.SearchTags(term, limit).ToWriter(RW);
} break;
case RequestCode.Start_GC:
if (!User.IsAdmin)
{
throw new BooruException(BooruException.ErrorCodes.NoPermission);
}
else
{
GC.Collect();
}
break;
case RequestCode.Add_Post:
using (var post = BooruPost.FromReader(RW))
{
post.Tags = BooruTagList.FromReader(RW);
post.Image = BooruImage.FromReader(RW);
ulong id = _Booru.AddPost(User, post);
RW.Write(id);
if (_MN != null)
{
using (var thumb = _Booru.GetThumbnail(null, id))
_MN.NotificatePostAdded(id, post, thumb);
}
} break;
case RequestCode.Edit_Post:
{
using (var post = BooruPost.FromReader(RW))
{
post.Tags = BooruTagList.FromReader(RW);
_Booru.EditPost(User, post);
}
} break;
case RequestCode.Edit_Image:
{
ulong id = RW.ReadULong();
using (var image = BooruImage.FromReader(RW))
_Booru.EditImage(User, id, image);
} break;
case RequestCode.Delete_Post:
{
ulong id = RW.ReadULong();
_Booru.DeletePost(User, id);
} break;
}
}
public bool CheckPost(BooruPost Post)
{
return(nonNegatedCheckPost(Post) ^ Negate);
}
