Style cleanup in api module

boards/views/api.py

@@ -1,189 +1,189 b''
 from datetime import datetime
 import json
 from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, render
 from django.template import RequestContext
 from django.utils import timezone
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread, Tag
 from boards.views import _datetime_to_epoch, _new_post, \
     _ban_current_user
 
 __author__ = 'neko259'
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 
 
 @transaction.atomic
 def api_get_threaddiff(request, thread_id, last_update_time):
     """Get posts that were changed or added since time"""
 
     thread = get_object_or_404(Post, id=thread_id).thread_new
 
     filter_time = datetime.fromtimestamp(float(last_update_time) / 1000000,
                                          timezone.get_current_timezone())
 
     json_data = {
         'added': [],
         'updated': [],
         'last_update': None,
-        }
+    }
     added_posts = Post.objects.filter(thread_new=thread,
                                       pub_time__gt=filter_time) \
         .order_by('pub_time')
     updated_posts = Post.objects.filter(thread_new=thread,
                                         pub_time__lte=filter_time,
                                         last_edit_time__gt=filter_time)
     for post in added_posts:
         json_data['added'].append(get_post(request, post.id).content.strip())
     for post in updated_posts:
         json_data['updated'].append(get_post(request, post.id).content.strip())
     json_data['last_update'] = _datetime_to_epoch(thread.last_edit_time)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 # TODO This method needs to be implemented properly
 # def api_add_post(request, form):
 #     """
 #     Add a post and return the JSON response for it
 #     """
 #
 #     status = 'ok'
 #     errors = []
 #
 #     if request.method == 'POST':
 #         form = ThreadForm(request.POST, request.FILES,
 #                           error_class=PlainErrorList)
 #         form.session = request.session
 #
 #         if form.is_valid():
 #             # TODO Don't form a response here cause we'll not need it
 #             _new_post(request, form)
 #         if form.need_to_ban:
 #             # Ban user because he is suspected to be a bot
 #             _ban_current_user(request)
 #     else:
 #         status = 'error'
 #         for field in form.fields:
 #             if field.errors:
 #                 errors.append(field.errors)
 #
 #     response = {
 #         'status': status,
 #         'errors': errors,
 #     }
 #
 #     return HttpResponse(content=json.dumps(response))
 
 
 def get_post(request, post_id):
     """
     Get 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)
     thread = post.thread_new
 
     context = RequestContext(request)
     context['post'] = post
     context['can_bump'] = thread.can_bump()
     if PARAMETER_TRUNCATED in request.GET:
         context[PARAMETER_TRUNCATED] = True
 
     return render(request, 'boards/post.html', context)
 
 
 # TODO Test this
 def api_get_threads(request, count):
     """
     Get 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.threads.filter(archived=False)
     else: 
         threads = Thread.objects.filter(archived=False)
 
     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 pub time, tags, replies and images count
         post_json = {
-                'id' : opening_post.id,
-                'title' : opening_post.title,
-                'text' : opening_post.text.rendered,
-                }
+            'id': opening_post.id,
+            'title': opening_post.title,
+            'text': opening_post.text.rendered,
+        }
         if opening_post.image:
             post_json += {
-                    'image' : opening_post.image.url,
-                    'image_preview' : opening_post.image.url_200x150,
-                    }
+                'image': opening_post.image.url,
+                'image_preview': opening_post.image.url_200x150,
+            }
         opening_posts.append(post_json)
 
     return HttpResponse(content=json.dumps(opening_posts))
 
 
 # TODO Test this
 def api_get_tags(request):
     """
     Get all tags or user tags.
     """
 
     # TODO Get favorite tags for the given user ID
 
     tags = Tag.objects.get_not_empty_tags()
     tag_names = []
     for tag in tags:
         tag_names.append(tag.name)
 
     return HttpResponse(content=json.dumps(tag_names))
 
 
 # TODO The result can be cached by the thread last update time
 # TODO Test this
 def api_get_thread_posts(request, opening_post_id):
     """
     Get the JSON array of thread posts
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
     thread = opening_post.thread_new
     posts = thread.get_replies()
 
     json_post_list = []
 
     for post in posts:
         # TODO Add pub time and replies
         post_json = {
-                'id' : post.id,
-                'title' : post.title,
-                'text' : post.text.rendered,
-                }
+            'id': post.id,
+            'title': post.title,
+            'text': post.text.rendered,
+        }
         if post.image:
             post_json += {
-                    'image' : post.image.url,
-                    'image_preview' : post.image.url_200x150,
-                    }
+                'image': post.image.url,
+                'image_preview': post.image.url_200x150,
+            }
         json_post_list.append(post_json)
 
     return HttpResponse(content=json.dumps(json_post_list))