from datetime import datetime
from typing import Dict, List, Optional
from szurubooru import db, model, rest, search
from szurubooru.func import auth, pools, serialization, snapshots, versions
_search_executor = search.Executor(search.configs.PoolSearchConfig())
def _serialize(ctx: rest.Context, pool: model.Pool) -> rest.Response:
return pools.serialize_pool(
pool, options=serialization.get_serialization_options(ctx))
def _get_pool(params: Dict[str, str]) -> model.Pool:
return pools.get_pool_by_id(params["pool_id"])
@rest.routes.get("/pools/?")
def get_pools(ctx: rest.Context,
_params: Dict[str, str] = {}) -> rest.Response:
auth.verify_privilege(ctx.user, "pools:list")
return _search_executor.execute_and_serialize(
ctx, lambda pool: _serialize(ctx, pool))
@rest.routes.post("/pool/?")
def create_pool(ctx: rest.Context,
_params: Dict[str, str] = {}) -> rest.Response:
auth.verify_privilege(ctx.user, "pools:create")
def executor():
return search.Executor(search.configs.PostSearchConfig())
from typing import Optional, Dict, List
from datetime import datetime
from szurubooru import db, model, errors, rest, search
from szurubooru.func import (auth, tags, posts, snapshots, favorites, scores,
serialization, versions)
_search_executor_config = search.configs.PostSearchConfig()
_search_executor = search.Executor(_search_executor_config)
def _get_post_id(params: Dict[str, str]) -> int:
try:
return int(params['post_id'])
except TypeError:
raise posts.InvalidPostIdError('잘못된 짤 ID: %r.' % params['post_id'])
def _get_post(params: Dict[str, str]) -> model.Post:
return posts.get_post_by_id(_get_post_id(params))
def _serialize_post(ctx: rest.Context,
post: Optional[model.Post]) -> rest.Response:
return posts.serialize_post(
post, ctx.user, options=serialization.get_serialization_options(ctx))
@rest.routes.get('/posts/?')
def get_posts(ctx: rest.Context,
_params: Dict[str, str] = {}) -> rest.Response:
auth.verify_privilege(ctx.user, 'posts:list')
def executor():
return search.Executor(search.configs.CommentSearchConfig())
from datetime import datetime
from typing import Dict, List, Optional
from szurubooru import db, model, rest, search
from szurubooru.func import auth, serialization, snapshots, tags, versions
_search_executor = search.Executor(search.configs.TagSearchConfig())
def _serialize(ctx: rest.Context, tag: model.Tag) -> rest.Response:
return tags.serialize_tag(
tag, options=serialization.get_serialization_options(ctx))
def _get_tag(params: Dict[str, str]) -> model.Tag:
return tags.get_tag_by_name(params["tag_name"])
def _create_if_needed(tag_names: List[str], user: model.User) -> None:
if not tag_names:
return
_existing_tags, new_tags = tags.get_or_create_tags_by_names(tag_names)
if len(new_tags):
auth.verify_privilege(user, "tags:create")
db.session.flush()
for tag in new_tags:
snapshots.create(tag, user)
@rest.routes.get("/tags/?")
def get_tags(ctx: rest.Context, _params: Dict[str, str] = {}) -> rest.Response:
def executor():
return search.Executor(search.configs.UserSearchConfig())
from typing import Any, Dict
from szurubooru import model, rest, search
from szurubooru.func import auth, serialization, users, versions
_search_executor = search.Executor(search.configs.UserSearchConfig())
def _serialize(ctx: rest.Context, user: model.User,
**kwargs: Any) -> rest.Response:
return users.serialize_user(
user,
ctx.user,
options=serialization.get_serialization_options(ctx),
**kwargs)
@rest.routes.get("/users/?")
def get_users(ctx: rest.Context,
_params: Dict[str, str] = {}) -> rest.Response:
auth.verify_privilege(ctx.user, "users:list")
return _search_executor.execute_and_serialize(
ctx, lambda user: _serialize(ctx, user))
@rest.routes.post("/users/?")
def create_user(ctx: rest.Context,
_params: Dict[str, str] = {}) -> rest.Response:
if ctx.user.user_id is None:
auth.verify_privilege(ctx.user, "users:create:self")
else:
from typing import Dict
from datetime import datetime
from szurubooru import search, rest, model
from szurubooru.func import (auth, comments, posts, scores, versions,
serialization)
_search_executor = search.Executor(search.configs.CommentSearchConfig())
def _get_comment(params: Dict[str, str]) -> model.Comment:
try:
comment_id = int(params['comment_id'])
except TypeError:
raise comments.InvalidCommentIdError('잘못된 댓글 ID: %r.' %
params['comment_id'])
return comments.get_comment_by_id(comment_id)
def _serialize(ctx: rest.Context, comment: model.Comment) -> rest.Response:
return comments.serialize_comment(
comment,
ctx.user,
options=serialization.get_serialization_options(ctx))
@rest.routes.get('/comments/?')
def get_comments(ctx: rest.Context,
_params: Dict[str, str] = {}) -> rest.Response:
auth.verify_privilege(ctx.user, 'comments:list')
return _search_executor.execute_and_serialize(
ctx, lambda comment: _serialize(ctx, comment))
