|
|
import json
|
|
|
import logging
|
|
|
|
|
|
from django.core import serializers
|
|
|
from django.db import transaction
|
|
|
from django.http import HttpResponse
|
|
|
from django.shortcuts import get_object_or_404
|
|
|
from django.views.decorators.csrf import csrf_protect
|
|
|
|
|
|
from boards.abstracts.settingsmanager import get_settings_manager
|
|
|
from boards.forms import PostForm, PlainErrorList
|
|
|
from boards.mdx_neboard import Parser
|
|
|
from boards.models import Post, Thread, Tag, Attachment, TagAlias
|
|
|
from boards.models.thread import STATUS_ARCHIVE
|
|
|
from boards.models.user import Notification
|
|
|
from boards.utils import datetime_to_epoch
|
|
|
from boards.views.thread import ThreadView
|
|
|
from boards.models.attachment.viewers import FILE_TYPES_IMAGE
|
|
|
|
|
|
__author__ = 'neko259'
|
|
|
|
|
|
PARAMETER_TRUNCATED = 'truncated'
|
|
|
PARAMETER_TAG = 'tag'
|
|
|
PARAMETER_OFFSET = 'offset'
|
|
|
PARAMETER_DIFF_TYPE = 'type'
|
|
|
PARAMETER_POST = 'post'
|
|
|
PARAMETER_UPDATED = 'updated'
|
|
|
PARAMETER_LAST_UPDATE = 'last_update'
|
|
|
PARAMETER_THREAD = 'thread'
|
|
|
PARAMETER_UIDS = 'uids'
|
|
|
PARAMETER_SUBSCRIBED = 'subscribed'
|
|
|
|
|
|
DIFF_TYPE_HTML = 'html'
|
|
|
DIFF_TYPE_JSON = 'json'
|
|
|
|
|
|
STATUS_OK = 'ok'
|
|
|
STATUS_ERROR = 'error'
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
@transaction.atomic
|
|
|
def api_get_threaddiff(request):
|
|
|
"""
|
|
|
Gets posts that were changed or added since time
|
|
|
"""
|
|
|
|
|
|
thread_id = request.POST.get(PARAMETER_THREAD)
|
|
|
uids_str = request.POST.get(PARAMETER_UIDS)
|
|
|
|
|
|
if not thread_id or not uids_str:
|
|
|
return HttpResponse(content='Invalid request.')
|
|
|
|
|
|
uids = uids_str.strip().split(' ')
|
|
|
|
|
|
opening_post = get_object_or_404(Post, id=thread_id)
|
|
|
thread = opening_post.get_thread()
|
|
|
|
|
|
json_data = {
|
|
|
PARAMETER_UPDATED: [],
|
|
|
PARAMETER_LAST_UPDATE: None, # TODO Maybe this can be removed already?
|
|
|
}
|
|
|
posts = Post.objects.filter(thread=thread).exclude(uid__in=uids)
|
|
|
|
|
|
diff_type = request.GET.get(PARAMETER_DIFF_TYPE, DIFF_TYPE_HTML)
|
|
|
|
|
|
for post in posts:
|
|
|
json_data[PARAMETER_UPDATED].append(post.get_post_data(
|
|
|
format_type=diff_type, request=request))
|
|
|
json_data[PARAMETER_LAST_UPDATE] = str(thread.last_edit_time)
|
|
|
|
|
|
settings_manager = get_settings_manager(request)
|
|
|
json_data[PARAMETER_SUBSCRIBED] = str(settings_manager.thread_is_fav(opening_post))
|
|
|
|
|
|
# If the tag is favorite, update the counter
|
|
|
settings_manager = get_settings_manager(request)
|
|
|
favorite = settings_manager.thread_is_fav(opening_post)
|
|
|
if favorite:
|
|
|
settings_manager.add_or_read_fav_thread(opening_post)
|
|
|
|
|
|
return HttpResponse(content=json.dumps(json_data))
|
|
|
|
|
|
|
|
|
@csrf_protect
|
|
|
def api_add_post(request, opening_post_id):
|
|
|
"""
|
|
|
Adds a post and return the JSON response for it
|
|
|
"""
|
|
|
|
|
|
opening_post = get_object_or_404(Post, id=opening_post_id)
|
|
|
|
|
|
logger.info('Adding post via api...')
|
|
|
|
|
|
status = STATUS_OK
|
|
|
errors = []
|
|
|
|
|
|
if request.method == 'POST':
|
|
|
form = PostForm(request.POST, request.FILES, error_class=PlainErrorList)
|
|
|
form.session = request.session
|
|
|
|
|
|
if form.need_to_ban:
|
|
|
# Ban user because he is suspected to be a bot
|
|
|
# _ban_current_user(request)
|
|
|
status = STATUS_ERROR
|
|
|
if form.is_valid():
|
|
|
post = ThreadView().new_post(request, form, opening_post,
|
|
|
html_response=False)
|
|
|
if not post:
|
|
|
status = STATUS_ERROR
|
|
|
else:
|
|
|
logger.info('Added post #%d via api.' % post.id)
|
|
|
else:
|
|
|
status = STATUS_ERROR
|
|
|
errors = form.as_json_errors()
|
|
|
|
|
|
response = {
|
|
|
'status': status,
|
|
|
'errors': errors,
|
|
|
}
|
|
|
|
|
|
return HttpResponse(content=json.dumps(response))
|
|
|
|
|
|
|
|
|
def get_post(request, post_id):
|
|
|
"""
|
|
|
Gets the html of a post. Used for popups. Post can be truncated if used
|
|
|
in threads list with 'truncated' get parameter.
|
|
|
"""
|
|
|
|
|
|
post = get_object_or_404(Post, id=post_id)
|
|
|
truncated = PARAMETER_TRUNCATED in request.GET
|
|
|
|
|
|
return HttpResponse(content=post.get_view(truncated=truncated, need_op_data=True))
|
|
|
|
|
|
|
|
|
def api_get_threads(request, count):
|
|
|
"""
|
|
|
Gets the JSON thread opening posts list.
|
|
|
Parameters that can be used for filtering:
|
|
|
tag, offset (from which thread to get results)
|
|
|
"""
|
|
|
|
|
|
if PARAMETER_TAG in request.GET:
|
|
|
tag_name = request.GET[PARAMETER_TAG]
|
|
|
if tag_name is not None:
|
|
|
tag = get_object_or_404(Tag, name=tag_name)
|
|
|
threads = tag.get_threads().exclude(status=STATUS_ARCHIVE)
|
|
|
else:
|
|
|
threads = Thread.objects.exclude(status=STATUS_ARCHIVE)
|
|
|
|
|
|
if PARAMETER_OFFSET in request.GET:
|
|
|
offset = request.GET[PARAMETER_OFFSET]
|
|
|
offset = int(offset) if offset is not None else 0
|
|
|
else:
|
|
|
offset = 0
|
|
|
|
|
|
threads = threads.order_by('-bump_time')
|
|
|
threads = threads[offset:offset + int(count)]
|
|
|
|
|
|
opening_posts = []
|
|
|
for thread in threads:
|
|
|
opening_post = thread.get_opening_post()
|
|
|
|
|
|
# TODO Add tags, replies and images count
|
|
|
post_data = opening_post.get_post_data(include_last_update=True)
|
|
|
post_data['status'] = thread.get_status()
|
|
|
|
|
|
opening_posts.append(post_data)
|
|
|
|
|
|
return HttpResponse(content=json.dumps(opening_posts))
|
|
|
|
|
|
|
|
|
# TODO Test this
|
|
|
def api_get_tags(request):
|
|
|
"""
|
|
|
Gets all tags or user tags.
|
|
|
"""
|
|
|
|
|
|
# TODO Get favorite tags for the given user ID
|
|
|
|
|
|
tags = TagAlias.objects.all()
|
|
|
|
|
|
term = request.GET.get('term')
|
|
|
if term is not None:
|
|
|
tags = tags.filter(name__contains=term)
|
|
|
|
|
|
tag_names = [tag.name for tag in tags]
|
|
|
|
|
|
return HttpResponse(content=json.dumps(tag_names))
|
|
|
|
|
|
|
|
|
def api_get_stickers(request):
|
|
|
attachments = Attachment.objects.filter(mimetype__in=FILE_TYPES_IMAGE)\
|
|
|
.exclude(alias='').exclude(alias=None)
|
|
|
|
|
|
term = request.GET.get('term')
|
|
|
if term:
|
|
|
attachments = attachments.filter(alias__contains=term)
|
|
|
|
|
|
image_dict = [{'thumb': attachment.get_thumb_url(),
|
|
|
'alias': attachment.alias}
|
|
|
for attachment in attachments]
|
|
|
|
|
|
return HttpResponse(content=json.dumps(image_dict))
|
|
|
|
|
|
|
|
|
# TODO The result can be cached by the thread last update time
|
|
|
# TODO Test this
|
|
|
def api_get_thread_posts(request, opening_post_id):
|
|
|
"""
|
|
|
Gets the JSON array of thread posts
|
|
|
"""
|
|
|
|
|
|
opening_post = get_object_or_404(Post, id=opening_post_id)
|
|
|
thread = opening_post.get_thread()
|
|
|
posts = thread.get_replies()
|
|
|
|
|
|
json_data = {
|
|
|
'posts': [],
|
|
|
'last_update': None,
|
|
|
}
|
|
|
json_post_list = []
|
|
|
|
|
|
for post in posts:
|
|
|
json_post_list.append(post.get_post_data())
|
|
|
json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
|
|
|
json_data['posts'] = json_post_list
|
|
|
|
|
|
return HttpResponse(content=json.dumps(json_data))
|
|
|
|
|
|
|
|
|
def api_get_notifications(request, username):
|
|
|
last_notification_id_str = request.GET.get('last', None)
|
|
|
last_id = int(last_notification_id_str) if last_notification_id_str is not None else None
|
|
|
|
|
|
posts = Notification.objects.get_notification_posts(usernames=[username],
|
|
|
last=last_id)
|
|
|
|
|
|
json_post_list = []
|
|
|
for post in posts:
|
|
|
json_post_list.append(post.get_post_data())
|
|
|
return HttpResponse(content=json.dumps(json_post_list))
|
|
|
|
|
|
|
|
|
def api_get_post(request, post_id):
|
|
|
"""
|
|
|
Gets the JSON of a post. This can be
|
|
|
used as and API for external clients.
|
|
|
"""
|
|
|
|
|
|
post = get_object_or_404(Post, id=post_id)
|
|
|
|
|
|
json = serializers.serialize("json", [post], fields=(
|
|
|
"pub_time", "_text_rendered", "title", "text", "image",
|
|
|
"image_width", "image_height", "replies", "tags"
|
|
|
))
|
|
|
|
|
|
return HttpResponse(content=json)
|
|
|
|
|
|
|
|
|
def api_get_preview(request):
|
|
|
raw_text = request.POST['raw_text']
|
|
|
|
|
|
parser = Parser()
|
|
|
return HttpResponse(content=parser.parse(parser.preparse(raw_text)))
|
|
|
|
|
|
|
|
|
def api_get_new_posts(request):
|
|
|
"""
|
|
|
Gets favorite threads and unread posts count.
|
|
|
"""
|
|
|
posts = list()
|
|
|
|
|
|
include_posts = 'include_posts' in request.GET
|
|
|
|
|
|
settings_manager = get_settings_manager(request)
|
|
|
fav_threads = settings_manager.get_fav_threads()
|
|
|
fav_thread_ops = Post.objects.filter(id__in=fav_threads.keys())\
|
|
|
.order_by('-pub_time').prefetch_related('thread')
|
|
|
|
|
|
ops = [{'op': op, 'last_id': fav_threads[str(op.id)]} for op in fav_thread_ops]
|
|
|
if include_posts:
|
|
|
new_post_threads = Thread.objects.get_new_posts(ops)
|
|
|
if new_post_threads:
|
|
|
thread_ids = {thread.id: thread for thread in new_post_threads}
|
|
|
else:
|
|
|
thread_ids = dict()
|
|
|
|
|
|
for op in fav_thread_ops:
|
|
|
fav_thread_dict = dict()
|
|
|
|
|
|
op_thread = op.get_thread()
|
|
|
if op_thread.id in thread_ids:
|
|
|
thread = thread_ids[op_thread.id]
|
|
|
new_post_count = thread.new_post_count
|
|
|
fav_thread_dict['newest_post_link'] = thread.get_replies()\
|
|
|
.filter(id__gt=fav_threads[str(op.id)])\
|
|
|
.first().get_absolute_url(thread=thread)
|
|
|
else:
|
|
|
new_post_count = 0
|
|
|
fav_thread_dict['new_post_count'] = new_post_count
|
|
|
|
|
|
fav_thread_dict['id'] = op.id
|
|
|
|
|
|
fav_thread_dict['post_url'] = op.get_link_view()
|
|
|
fav_thread_dict['title'] = op.title
|
|
|
|
|
|
posts.append(fav_thread_dict)
|
|
|
else:
|
|
|
fav_thread_dict = dict()
|
|
|
fav_thread_dict['new_post_count'] = \
|
|
|
Thread.objects.get_new_post_count(ops)
|
|
|
posts.append(fav_thread_dict)
|
|
|
|
|
|
return HttpResponse(content=json.dumps(posts))
|
|
|
|
