def save(self, serializer):
if self.mode == PostingEndpoint.START:
self.new_thread(serializer.validated_data)
parsing_result = self.parse_post(serializer.validated_data['post'])
if self.mode == PostingEndpoint.EDIT:
self.edit_post(serializer.validated_data, parsing_result)
else:
self.new_post(serializer.validated_data, parsing_result)
if self.mode == PostingEndpoint.START:
self.post.set_search_document(self.thread.title)
else:
self.post.set_search_document()
self.post.updated_on = self.datetime
self.post.save()
self.post.update_search_vector()
update_post_checksum(self.post)
self.post.update_fields += ['checksum', 'search_vector']
if self.mode == PostingEndpoint.START:
self.thread.set_first_post(self.post)
if self.mode != PostingEndpoint.EDIT:
self.thread.set_last_post(self.post)
self.thread.save()
# annotate post for future middlewares
self.post.parsing_result = parsing_result
def save(self, serializer):
if self.mode == PostingEndpoint.START:
self.new_thread(serializer.validated_data)
parsing_result = serializer.validated_data['parsing_result']
if self.mode == PostingEndpoint.EDIT:
self.edit_post(serializer.validated_data, parsing_result)
else:
self.new_post(serializer.validated_data, parsing_result)
if self.mode == PostingEndpoint.START:
self.post.set_search_document(self.thread.title)
else:
self.post.set_search_document()
self.post.updated_on = self.datetime
self.post.save()
self.post.update_search_vector()
update_post_checksum(self.post)
self.post.update_fields += ['checksum', 'search_vector']
if self.mode == PostingEndpoint.START:
self.thread.set_first_post(self.post)
self.thread.set_last_post(self.post)
self.thread.save()
# annotate post for future middlewares
self.post.parsing_result = parsing_result
def merge(self, other_post):
if self.poster_id != other_post.poster_id:
raise ValueError("post can't be merged with other user's post")
elif (self.poster_id is None and other_post.poster_id is None
and self.poster_name != other_post.poster_name):
raise ValueError("post can't be merged with other user's post")
if self.thread_id != other_post.thread_id:
raise ValueError(
"only posts belonging to same thread can be merged")
if self.is_event or other_post.is_event:
raise ValueError("can't merge events")
if self.pk == other_post.pk:
raise ValueError("post can't be merged with itself")
other_post.original = str('\n\n').join(
(other_post.original, self.original))
other_post.parsed = str('\n').join((other_post.parsed, self.parsed))
update_post_checksum(other_post)
if self.is_protected:
other_post.is_protected = True
if self.is_best_answer:
self.thread.best_answer = other_post
if other_post.is_best_answer:
self.thread.best_answer_is_protected = other_post.is_protected
from misago.threads.signals import merge_post
merge_post.send(sender=self, other_post=other_post)
def clean_posts():
for post in batch_update(Post.objects):
post.original = clean_original(post.original)
parsed_post = common_flavour(FakeRequest(), FakeUser(), post.original)
post.parsed = parsed_post['parsed_text']
update_post_checksum(post)
post.save()
def test_post_content(self):
"""unicode in thread title causes no showstopper"""
self.thread.first_post.original = u'Łódź'
self.thread.first_post.parsed = u'<p>Łódź</p>'
update_post_checksum(self.thread.first_post)
self.thread.first_post.save()
self.override_acl()
response = self.client.get(self.thread.get_absolute_url())
self.assertEqual(response.status_code, 200)
def test_post_content(self):
"""unicode in thread title causes no showstopper"""
self.thread.first_post.original = u'Łódź'
self.thread.first_post.parsed = u'<p>Łódź</p>'
update_post_checksum(self.thread.first_post)
self.thread.first_post.save()
self.override_acl()
response = self.client.get(self.thread.get_absolute_url())
self.assertEqual(response.status_code, 200)
def save(self, form):
if self.mode == START:
self.new_thread(form)
if self.mode == EDIT:
self.edit_post(form)
else:
self.new_post()
self.post.updated_on = self.datetime
self.post.save()
update_post_checksum(self.post)
self.post.update_fields.append('checksum')
def save(self, form):
if self.mode == START:
self.new_thread(form)
if self.mode == EDIT:
self.edit_post(form)
else:
self.new_post()
self.post.updated_on = self.datetime
self.post.save()
update_post_checksum(self.post)
self.post.update_fields.append('checksum')
def save(self):
thread = self.context['thread']
starter = self.context['user']
post = self.context['post']
problem, created = Problem.objects.get_or_create(thread=thread,
starter=starter)
uid = problem.uid
uid_str = settings.OJ_UID_FORMAT.format(uid.hex)
problem.order_type = self.order_type
problem.judge_name = self.judge_name
problem.module_name = self.module_name + '.py'
problem.save()
post.parsed = post.parsed + '\n' + uid_str
update_post_checksum(post)
post.save()
def save(self, serializer):
if self.mode == PostingEndpoint.START:
self.new_thread(serializer.validated_data)
parsing_result = serializer.validated_data['parsing_result']
if self.mode == PostingEndpoint.EDIT:
self.edit_post(serializer.validated_data, parsing_result)
else:
self.new_post(serializer.validated_data, parsing_result)
if self.mode == PostingEndpoint.START:
self.post.set_search_document(self.thread.title)
else:
self.post.set_search_document()
self.post.updated_on = self.datetime
self.post.save()
try:
if self.request.data['tags']:
tags = self.request.data['tags']
except:
tags = ""
if tags:
splited_tags = tags.split("#")
for tag in splited_tags:
if tag:
try:
Tag.objects.create(tag_name=tag.replace(" ", ""),
updated_on=self.datetime,
created_on=self.datetime,
thread_id=self.tag.thread.id)
except:
raise Exception("error saving tags")
self.post.update_search_vector()
update_post_checksum(self.post)
self.post.update_fields += ['checksum', 'search_vector']
if self.mode == PostingEndpoint.START:
self.thread.set_first_post(self.post)
self.thread.set_last_post(self.post)
self.thread.save()
# annotate post for future middlewares
self.post.parsing_result = parsing_result
def update_posts_checksums(self, posts_to_update):
self.stdout.write("Updating %s posts checksums...\n" % posts_to_update)
updated_count = 0
show_progress(self, updated_count, posts_to_update)
start_time = time.time()
queryset = Post.objects.filter(is_event=False)
for post in chunk_queryset(queryset):
update_post_checksum(post)
post.save(update_fields=['checksum'])
updated_count += 1
show_progress(self, updated_count, posts_to_update, start_time)
self.stdout.write("\n\nUpdated %s posts checksums" % updated_count)
def revert_post_endpoint(request, post):
edit = get_edit_by_pk(post, request.GET.get('edit'))
datetime = timezone.now()
post_edits = post.edits
post.edits_record.create(
category=post.category,
thread=post.thread,
edited_on=datetime,
editor=request.user,
editor_name=request.user.username,
editor_slug=request.user.slug,
editor_ip=request.user_ip,
edited_from=post.original,
edited_to=edit.edited_from,
)
parsing_result = common_flavour(request, post.poster, edit.edited_from)
post.original = parsing_result['original_text']
post.parsed = parsing_result['parsed_text']
update_post_checksum(post)
post.updated_on = datetime
post.edits = F('edits') + 1
post.last_editor = request.user
post.last_editor_name = request.user.username
post.last_editor_slug = request.user.slug
post.save()
post.is_read = True
post.is_new = False
post.edits = post_edits + 1
add_acl(request.user, post)
if post.poster:
make_users_status_aware(request.user, [post.poster])
return Response(PostSerializer(post, context={'user': request.user}).data)
def revert_post_endpoint(request, post):
edit = get_edit_by_pk(post, request.GET.get('edit'))
datetime = timezone.now()
post_edits = post.edits
post.edits_record.create(
category=post.category,
thread=post.thread,
edited_on=datetime,
editor=request.user,
editor_name=request.user.username,
editor_slug=request.user.slug,
editor_ip=request.user_ip,
edited_from=post.original,
edited_to=edit.edited_from,
)
parsing_result = common_flavour(request, post.poster, edit.edited_from)
post.original = parsing_result['original_text']
post.parsed = parsing_result['parsed_text']
update_post_checksum(post)
post.updated_on = datetime
post.edits = F('edits') + 1
post.last_editor = request.user
post.last_editor_name = request.user.username
post.last_editor_slug = request.user.slug
post.save()
post.is_read = True
post.is_new = False
post.edits = post_edits + 1
add_acl(request.user, post)
if post.poster:
make_users_status_aware(request.user, [post.poster])
return Response(PostSerializer(post, context={'user': request.user}).data)
def merge(self, other_post):
if self.thread_id != other_post.thread_id:
raise ValueError(
"only posts belonging to same thread can be merged")
if self.is_event or other_post.is_event:
raise ValueError("can't merge events")
if self.pk == other_post.pk:
raise ValueError("post can't be merged with itself")
other_post.original = six.text_type('\n\n').join(
(other_post.original, self.original))
other_post.parsed = six.text_type('\n').join(
(other_post.parsed, self.parsed))
update_post_checksum(other_post)
from misago.threads.signals import merge_post
merge_post.send(sender=self, other_post=other_post)
def merge(self, other_post):
if not self.poster_id or self.poster_id != other_post.poster_id:
raise ValueError("post can't be merged with other user's post")
if self.thread_id != other_post.thread_id:
raise ValueError("only posts belonging to same thread can be merged")
if self.is_event or other_post.is_event:
raise ValueError("can't merge events")
if self.pk == other_post.pk:
raise ValueError("post can't be merged with itself")
other_post.original = six.text_type('\n\n').join((other_post.original, self.original))
other_post.parsed = six.text_type('\n').join((other_post.parsed, self.parsed))
update_post_checksum(other_post)
from misago.threads.signals import merge_post
merge_post.send(sender=self, other_post=other_post)
def merge(self, other_post):
if self.thread_id != other_post.thread_id:
message = "only posts belonging to same thread can be merged"
raise ValueError(message)
message = "posts made by different authors can't be merged"
if self.poster_id and other_post.poster_id:
if self.poster_id != other_post.poster_id:
raise ValueError(message)
else:
raise ValueError(message)
if self.pk == other_post.pk:
raise ValueError("post can't be merged with itself")
other_post.original = '%s\n\n%s' % (other_post.original, self.original)
other_post.parsed = '%s\n%s' % (other_post.parsed, self.parsed)
update_post_checksum(other_post)
from misago.threads.signals import merge_post
merge_post.send(sender=self, other_thread=other_post)
def setUp(self):
User = get_user_model()
self.user = User.objects.create_user("Bob", "*****@*****.**", "Pass.123")
datetime = timezone.now()
self.forum = Forum.objects.filter(role="forum")[:1][0]
self.thread = Thread(
forum=self.forum,
weight=0,
started_on=datetime,
starter_name="Tester",
starter_slug="tester",
last_post_on=datetime,
last_poster_name="Tester",
last_poster_slug="tester",
)
self.thread.set_title("Test thread")
self.thread.save()
self.post = Post.objects.create(
forum=self.forum,
thread=self.thread,
poster=self.user,
poster_name=self.user.username,
poster_ip="127.0.0.1",
original="Hello! I am test message!",
parsed="<p>Hello! I am test message!</p>",
checksum="nope",
posted_on=datetime,
updated_on=datetime,
)
update_post_checksum(self.post)
self.post.save(update_fields=["checksum"])
self.thread.first_post = self.post
self.thread.last_post = self.post
self.thread.save()
def setUp(self):
User = get_user_model()
self.user = User.objects.create_user("Bob", "*****@*****.**", "Pass.123")
datetime = timezone.now()
self.category = Category.objects.all_categories()[:1][0]
self.thread = Thread(
category=self.category,
started_on=datetime,
starter_name='Tester',
starter_slug='tester',
last_post_on=datetime,
last_poster_name='Tester',
last_poster_slug='tester'
)
self.thread.set_title("Test thread")
self.thread.save()
self.post = Post.objects.create(
category=self.category,
thread=self.thread,
poster=self.user,
poster_name=self.user.username,
poster_ip='127.0.0.1',
original="Hello! I am test message!",
parsed="<p>Hello! I am test message!</p>",
checksum="nope",
posted_on=datetime,
updated_on=datetime
)
update_post_checksum(self.post)
self.post.save(update_fields=['checksum'])
self.thread.first_post = self.post
self.thread.last_post = self.post
self.thread.save()
def handle(self, *args, **options):
items_to_create = options['threads']
categories = list(Category.objects.all_categories())
fake = Factory.create()
message = 'Creating %s fake threads...\n'
self.stdout.write(message % items_to_create)
created_threads = 0
start_time = time.time()
show_progress(self, created_threads, items_to_create)
while created_threads < items_to_create:
with atomic():
datetime = timezone.now()
category = random.choice(categories)
user = UserModel.objects.order_by('?')[:1][0]
thread_is_unapproved = random.randint(0, 100) > 90
thread_is_hidden = random.randint(0, 100) > 90
thread_is_closed = random.randint(0, 100) > 90
thread = Thread(
category=category,
started_on=datetime,
starter_name='-',
starter_slug='-',
last_post_on=datetime,
last_poster_name='-',
last_poster_slug='-',
replies=0,
is_unapproved=thread_is_unapproved,
is_hidden=thread_is_hidden,
is_closed=thread_is_closed,
)
thread.set_title(corpus_short.random_choice())
thread.save()
original, parsed = self.fake_post_content()
post = Post.objects.create(
category=category,
thread=thread,
poster=user,
poster_name=user.username,
original=original,
parsed=parsed,
posted_on=datetime,
updated_on=datetime,
)
update_post_checksum(post)
post.save(update_fields=['checksum'])
thread.set_first_post(post)
thread.set_last_post(post)
thread.save()
user.threads += 1
user.posts += 1
user.save()
thread_type = random.randint(0, 100)
if thread_type > 98:
thread_replies = random.randint(200, 2500)
elif thread_type > 50:
thread_replies = random.randint(5, 30)
else:
thread_replies = random.randint(0, 10)
for _ in range(thread_replies):
datetime = timezone.now()
user = UserModel.objects.order_by('?')[:1][0]
original, parsed = self.fake_post_content()
is_unapproved = random.randint(0, 100) > 97
post = Post.objects.create(
category=category,
thread=thread,
poster=user,
poster_name=user.username,
original=original,
parsed=parsed,
is_unapproved=is_unapproved,
posted_on=datetime,
updated_on=datetime,
)
if not is_unapproved:
is_hidden = random.randint(0, 100) > 97
else:
is_hidden = False
if is_hidden:
post.is_hidden = True
if random.randint(0, 100) < 80:
user = UserModel.objects.order_by('?')[:1][0]
post.hidden_by = user
post.hidden_by_name = user.username
post.hidden_by_slug = user.username
else:
post.hidden_by_name = fake.first_name()
post.hidden_by_slug = post.hidden_by_name.lower()
update_post_checksum(post)
post.save()
user.posts += 1
user.save()
thread.synchronize()
thread.save()
created_threads += 1
show_progress(self, created_threads, items_to_create, start_time)
pinned_threads = random.randint(0, int(created_threads * 0.025)) or 1
self.stdout.write('\nPinning %s threads...' % pinned_threads)
for _ in range(0, pinned_threads):
thread = Thread.objects.order_by('?')[:1][0]
if random.randint(0, 100) > 75:
thread.weight = 2
else:
thread.weight = 1
thread.save()
for category in categories:
category.synchronize()
category.save()
total_time = time.time() - start_time
total_humanized = time.strftime('%H:%M:%S', time.gmtime(total_time))
message = '\nSuccessfully created %s fake threads in %s'
self.stdout.write(message % (created_threads, total_humanized))
def handle(self, *args, **options):
try:
fake_threads_to_create = int(args[0])
except IndexError:
fake_threads_to_create = 5
except ValueError:
self.stderr.write("\nOptional argument should be integer.")
sys.exit(1)
forums = [f for f in Forum.objects.all_forums().filter(role='forum')]
fake = Factory.create()
User = get_user_model()
total_users = User.objects.count()
self.stdout.write('Creating fake threads...\n')
message = '\nSuccessfully created %s fake threads'
created_threads = 0
start_time = time.time()
show_progress(self, created_threads, fake_threads_to_create)
for i in xrange(fake_threads_to_create):
with atomic():
datetime = timezone.now()
forum = random.choice(forums)
user = User.objects.order_by('?')[:1][0]
thread_is_moderated = random.randint(0, 100) > 90
thread_is_hidden = random.randint(0, 100) > 90
thread_is_closed = random.randint(0, 100) > 90
thread = Thread(forum=forum,
started_on=datetime,
starter_name='-',
starter_slug='-',
last_post_on=datetime,
last_poster_name='-',
last_poster_slug='-',
replies=0,
is_moderated=thread_is_moderated,
is_hidden=thread_is_hidden,
is_closed=thread_is_closed)
thread.set_title(fake.sentence())
thread.save()
fake_message = "\n\n".join(fake.paragraphs())
post = Post.objects.create(
forum=forum,
thread=thread,
poster=user,
poster_name=user.username,
poster_ip=fake.ipv4(),
original=fake_message,
parsed=linebreaks_filter(fake_message),
posted_on=datetime,
updated_on=datetime)
update_post_checksum(post)
post.save(update_fields=['checksum'])
thread.set_first_post(post)
thread.set_last_post(post)
thread.save()
user.threads += 1
user.posts += 1
user.save()
thread_type = random.randint(0, 100)
if thread_type > 95:
thread_replies = random.randint(200, 500)
elif thread_type > 50:
thread_replies = random.randint(5, 30)
else:
thread_replies = random.randint(0, 10)
for x in xrange(thread_replies):
datetime = timezone.now()
user = User.objects.order_by('?')[:1][0]
fake_message = "\n\n".join(fake.paragraphs())
is_moderated = random.randint(0, 100) > 97
if not is_moderated:
is_hidden = random.randint(0, 100) > 97
else:
is_hidden = False
post = Post.objects.create(
forum=forum,
thread=thread,
poster=user,
poster_name=user.username,
poster_ip=fake.ipv4(),
original=fake_message,
parsed=linebreaks_filter(fake_message),
is_hidden=is_hidden,
is_moderated=is_moderated,
posted_on=datetime,
updated_on=datetime)
update_post_checksum(post)
post.save(update_fields=['checksum'])
user.posts += 1
user.save()
thread.synchronize()
thread.save()
created_threads += 1
show_progress(self, created_threads, fake_threads_to_create,
start_time)
pinned_threads = random.randint(0, int(created_threads * 0.025)) or 1
self.stdout.write('\nPinning %s threads...' % pinned_threads)
for i in xrange(0, pinned_threads):
thread = Thread.objects.order_by('?')[:1][0]
thread.is_pinned = True
thread.save()
for forum in forums:
forum.synchronize()
forum.save()
self.stdout.write(message % created_threads)
def handle(self, *args, **options):
items_to_create = options['threads']
categories = list(Category.objects.all_categories())
fake = Factory.create()
User = get_user_model()
total_users = User.objects.count()
self.stdout.write('Creating fake threads...\n')
message = '\nSuccessfully created %s fake threads in %s'
created_threads = 0
start_time = time.time()
show_progress(self, created_threads, items_to_create)
while created_threads < items_to_create:
with atomic():
datetime = timezone.now()
category = random.choice(categories)
user = User.objects.order_by('?')[:1][0]
thread_is_unapproved = random.randint(0, 100) > 90
thread_is_hidden = random.randint(0, 100) > 90
thread_is_closed = random.randint(0, 100) > 90
thread = Thread(
category=category,
started_on=datetime,
starter_name='-',
starter_slug='-',
last_post_on=datetime,
last_poster_name='-',
last_poster_slug='-',
replies=0,
is_unapproved=thread_is_unapproved,
is_hidden=thread_is_hidden,
is_closed=thread_is_closed
)
thread.set_title(fake.sentence())
thread.save()
fake_message = "\n\n".join(fake.paragraphs())
post = Post.objects.create(
category=category,
thread=thread,
poster=user,
poster_name=user.username,
poster_ip=fake.ipv4(),
original=fake_message,
parsed=linebreaks_filter(fake_message),
posted_on=datetime,
updated_on=datetime
)
update_post_checksum(post)
post.save(update_fields=['checksum'])
thread.set_first_post(post)
thread.set_last_post(post)
thread.save()
user.threads += 1
user.posts += 1
user.save()
thread_type = random.randint(0, 100)
if thread_type > 95:
thread_replies = random.randint(200, 2500)
elif thread_type > 50:
thread_replies = random.randint(5, 30)
else:
thread_replies = random.randint(0, 10)
for x in range(thread_replies):
datetime = timezone.now()
user = User.objects.order_by('?')[:1][0]
fake_message = "\n\n".join(fake.paragraphs())
is_unapproved = random.randint(0, 100) > 97
post = Post.objects.create(
category=category,
thread=thread,
poster=user,
poster_name=user.username,
poster_ip=fake.ipv4(),
original=fake_message,
parsed=linebreaks_filter(fake_message),
is_unapproved=is_unapproved,
posted_on=datetime,
updated_on=datetime
)
if not is_unapproved:
is_hidden = random.randint(0, 100) > 97
else:
is_hidden = False
if is_hidden:
post.is_hidden = True
if random.randint(0, 100) < 80:
user = User.objects.order_by('?')[:1][0]
post.hidden_by = user
post.hidden_by_name = user.username
post.hidden_by_slug = user.username
else:
post.hidden_by_name = fake.first_name()
post.hidden_by_slug = post.hidden_by_name.lower()
update_post_checksum(post)
post.save()
user.posts += 1
user.save()
thread.synchronize()
thread.save()
created_threads += 1
show_progress(
self, created_threads, items_to_create, start_time)
pinned_threads = random.randint(0, int(created_threads * 0.025)) or 1
self.stdout.write('\nPinning %s threads...' % pinned_threads)
for i in range(0, pinned_threads):
thread = Thread.objects.order_by('?')[:1][0]
if random.randint(0, 100) > 75:
thread.weight = 2
else:
thread.weight = 1
thread.save()
for category in categories:
category.synchronize()
category.save()
total_time = time.time() - start_time
total_humanized = time.strftime('%H:%M:%S', time.gmtime(total_time))
self.stdout.write(message % (created_threads, total_humanized))
def _wraps(self, thread_id, sol_id, *args, **kwargs):
try:
thread = Thread.objects.get(id=thread_id)
poster = get_user_model().objects.get(username='******')
now = timezone.now()
reply = _('<h3>Status: Judging</h3>')
post = Post.objects.filter(category=thread.category,
thread=thread,
poster=poster)
if post.count() == 0:
post = Post(category=thread.category,
thread=thread,
poster=poster,
poster_name=settings.OJ_ROBOT_NAME,
poster_ip='0.0.0.0',
updated_on=now,
original=reply,
parsed=reply,
posted_on=now)
else:
post = post[0]
post.updated_on = now
post.original = reply
post.parsed = reply
post.save()
update_post_checksum(post)
post.save()
except Exception as e:
logging.error('Posting error:{}'.format(e))
start_time = time.time()
try:
logging.info('Judging started:{}'.format(sol_id))
solution = Solution.objects.get(id=sol_id)
result = func(solution, *args, **kwargs)
except Exception as e:
logging.error('Judgin failed:{}'.format(e))
solution.status = SOL_ERROR
result = -1
else:
logging.info('Judging succeed:{}'.format(sol_id))
solution.status = SOL_FINISHED
finally:
solution.save()
logging.info('Judging finished:{}'.format(sol_id))
# Reply thread about judgement details
duration = time.time() - start_time
status = _('Error') if result < 0 else _('Succeed')
reply = settings.OJ_REPLY_FORMAT % {
'status': status,
'duration': duration,
'result': result,
'updated_on': timezone.localtime(now).strftime(
_('%Y-%m-%d %H:%M:%S')),
}
now = timezone.now()
post.updated_on = now
post.original = reply
post.parsed = reply
post.save()
update_post_checksum(post)
post.save()
return result
def handle(self, *args, **options):
items_to_create = options['threads']
categories = list(Category.objects.all_categories())
fake = Factory.create()
User = get_user_model()
total_users = User.objects.count()
self.stdout.write('Creating fake threads...\n')
message = '\nSuccessfully created %s fake threads in %s'
created_threads = 0
start_time = time.time()
show_progress(self, created_threads, items_to_create)
while created_threads < items_to_create:
with atomic():
datetime = timezone.now()
category = random.choice(categories)
user = User.objects.order_by('?')[:1][0]
thread_is_unapproved = random.randint(0, 100) > 90
thread_is_hidden = random.randint(0, 100) > 90
thread_is_closed = random.randint(0, 100) > 90
thread = Thread(
category=category,
started_on=datetime,
starter_name='-',
starter_slug='-',
last_post_on=datetime,
last_poster_name='-',
last_poster_slug='-',
replies=0,
is_unapproved=thread_is_unapproved,
is_hidden=thread_is_hidden,
is_closed=thread_is_closed
)
thread.set_title(fake.sentence())
thread.save()
fake_message = "\n\n".join(fake.paragraphs())
post = Post.objects.create(
category=category,
thread=thread,
poster=user,
poster_name=user.username,
poster_ip=fake.ipv4(),
original=fake_message,
parsed=linebreaks_filter(fake_message),
posted_on=datetime,
updated_on=datetime
)
update_post_checksum(post)
post.save(update_fields=['checksum'])
thread.set_first_post(post)
thread.set_last_post(post)
thread.save()
user.threads += 1
user.posts += 1
user.save()
thread_type = random.randint(0, 100)
if thread_type > 95:
thread_replies = random.randint(200, 2500)
elif thread_type > 50:
thread_replies = random.randint(5, 30)
else:
thread_replies = random.randint(0, 10)
for x in range(thread_replies):
datetime = timezone.now()
user = User.objects.order_by('?')[:1][0]
fake_message = "\n\n".join(fake.paragraphs())
is_unapproved = random.randint(0, 100) > 97
if not is_unapproved:
is_hidden = random.randint(0, 100) > 97
else:
is_hidden = False
post = Post.objects.create(
category=category,
thread=thread,
poster=user,
poster_name=user.username,
poster_ip=fake.ipv4(),
original=fake_message,
parsed=linebreaks_filter(fake_message),
is_hidden=is_hidden,
is_unapproved=is_unapproved,
posted_on=datetime,
updated_on=datetime
)
update_post_checksum(post)
post.save(update_fields=['checksum'])
user.posts += 1
user.save()
thread.synchronize()
thread.save()
created_threads += 1
show_progress(
self, created_threads, items_to_create, start_time)
pinned_threads = random.randint(0, int(created_threads * 0.025)) or 1
self.stdout.write('\nPinning %s threads...' % pinned_threads)
for i in range(0, pinned_threads):
thread = Thread.objects.order_by('?')[:1][0]
if random.randint(0, 100) > 75:
thread.weight = 2
else:
thread.weight = 1
thread.save()
for category in categories:
category.synchronize()
category.save()
total_time = time.time() - start_time
total_humanized = time.strftime('%H:%M:%S', time.gmtime(total_time))
self.stdout.write(message % (created_threads, total_humanized))
def handle(self, *args, **options):
try:
fake_threads_to_create = int(args[0])
except IndexError:
fake_threads_to_create = 5
except ValueError:
self.stderr.write("\nOptional argument should be integer.")
sys.exit(1)
forums = [f for f in Forum.objects.all_forums().filter(role='forum')]
fake = Factory.create()
User = get_user_model()
total_users = User.objects.count()
self.stdout.write('Creating fake threads...\n')
message = '\nSuccessfully created %s fake threads'
created_threads = 0
start_time = time.time()
show_progress(self, created_threads, fake_threads_to_create)
for i in xrange(fake_threads_to_create):
with atomic():
datetime = timezone.now()
forum = random.choice(forums)
user = User.objects.order_by('?')[:1][0]
thread_is_moderated = random.randint(0, 100) > 90
thread_is_hidden = random.randint(0, 100) > 90
thread_is_closed = random.randint(0, 100) > 90
thread = Thread(
forum=forum,
started_on=datetime,
starter_name='-',
starter_slug='-',
last_post_on=datetime,
last_poster_name='-',
last_poster_slug='-',
replies=random.randint(0, 2000),
is_moderated=thread_is_moderated,
is_hidden=thread_is_hidden,
is_closed=thread_is_closed)
thread.set_title(fake.sentence())
thread.save()
fake_message = "\n\n".join(fake.paragraphs())
post = Post.objects.create(
forum=forum,
thread=thread,
poster=user,
poster_name=user.username,
poster_ip=fake.ipv4(),
original=fake_message,
parsed=linebreaks_filter(fake_message),
posted_on=datetime,
updated_on=datetime)
update_post_checksum(post)
post.save(update_fields=['checksum'])
thread.set_first_post(post)
thread.set_last_post(post)
thread.save()
forum.threads += 1
forum.posts += 1
forum.set_last_thread(thread)
forum.save()
user.threads += 1
user.posts += 1
user.save()
created_threads += 1
show_progress(
self, created_threads, fake_threads_to_create, start_time)
pinned_threads = random.randint(0, int(created_threads * 0.025)) or 1
self.stdout.write('\nPinning %s threads...' % pinned_threads)
for i in xrange(0, pinned_threads):
thread = Thread.objects.order_by('?')[:1][0]
thread.is_pinned = True
thread.save()
self.stdout.write(message % created_threads)
