def create_default_ranks(apps, schema_editor):
    Rank = apps.get_model('misago_users', 'Rank')

    team = Rank.objects.create(
        name=_("Forum team"),
        slug=slugify(_("Forum team")),
        title=_("Team"),
        css_class='team',
        is_tab=True,
        is_on_index=True,
        order=0)

    member = Rank.objects.create(
        name=_("Members"),
        slug=slugify(_("Members")),
        is_default=True,
        order=1)

    Role = apps.get_model('misago_acl', 'Role')

    team.roles.add(Role.objects.get(name=_("Moderator")))
    team.roles.add(Role.objects.get(name=_("Private threads moderator")))
    team.roles.add(Role.objects.get(name=_("Deleting users")))

    member.roles.add(Role.objects.get(name=_("Private threads")))

def post_thread(
        category,
        title='Test thread',
        poster='Tester',
        is_global=False,
        is_pinned=False,
        is_unapproved=False,
        is_hidden=False,
        is_closed=False,
        started_on=None
):
    started_on = started_on or timezone.now()

    kwargs = {
        'category': category,
        'title': title,
        'slug': slugify(title),
        'started_on': started_on,
        'last_post_on': started_on,
        'is_unapproved': is_unapproved,
        'is_hidden': is_hidden,
        'is_closed': is_closed,
    }

    if is_global:
        kwargs['weight'] = 2
    elif is_pinned:
        kwargs['weight'] = 1

    try:
        kwargs.update({
            'starter': poster,
            'starter_name': poster.username,
            'starter_slug': poster.slug,
            'last_poster': poster,
            'last_poster_name': poster.username,
            'last_poster_slug': poster.slug,
        })
    except AttributeError:
        kwargs.update({
            'starter_name': poster,
            'starter_slug': slugify(poster),
            'last_poster_name': poster,
            'last_poster_slug': slugify(poster),
        })

    thread = Thread.objects.create(**kwargs)
    reply_thread(
        thread,
        poster=poster,
        posted_on=started_on,
        is_hidden=is_hidden,
        is_unapproved=is_unapproved,
    )

    return thread

def create_default_categories_tree(apps, schema_editor):
    Category = apps.get_model('misago_categories', 'Category')

    Category.objects.create(
        special_role='private_threads',
        name='Private',
        slug='private',
        lft=1,
        rght=2,
        tree_id=0,
        level=0,
    )

    root = Category.objects.create(
        special_role='root_category',
        name='Root',
        slug='root',
        lft=3,
        rght=6,
        tree_id=1,
        level=0,
    )

    category_name = _("First category")

    category = Category.objects.create(
        parent=root,
        lft=4,
        rght=5,
        tree_id=1,
        level=1,
        name=category_name,
        slug=slugify(category_name),
        css_class='accent'
    )

    def __call__(self, value):
        slug = slugify(value)

        if not slug.replace('-', ''):
            raise ValidationError(self.error_short)

        if len(slug) > 255:
            raise ValidationError(self.error_long)

 def set_last_post(self, post):
     self.last_post_on = post.posted_on
     self.last_post = post
     self.last_poster = post.poster
     self.last_poster_name = post.poster_name
     if post.poster:
         self.last_poster_slug = post.poster.slug
     else:
         self.last_poster_slug = slugify(post.poster_name)

def create_default_forums_tree(apps, schema_editor):
    Forum = apps.get_model("misago_forums", "Forum")

    Forum.objects.create(
        special_role="private_threads", role="forum", name="Private", slug="private", lft=1, rght=2, tree_id=0, level=0
    )

    root = Forum.objects.create(
        special_role="root_category", role="category", name="Root", slug="root", lft=3, rght=10, tree_id=1, level=0
    )

    category_name = _("First category")
    forum_name = _("First forum")
    redirect_name = _("Misago support forums")
    redirect_link = _("http://misago-project.org")

    category = Forum.objects.create(
        parent=root,
        lft=4,
        rght=9,
        tree_id=1,
        level=1,
        role="category",
        name=category_name,
        slug=slugify(category_name),
        css_class="accent",
    )

    Forum.objects.create(
        parent=category, lft=5, rght=6, tree_id=1, level=2, role="forum", name=forum_name, slug=slugify(forum_name)
    )

    Forum.objects.create(
        parent=category,
        lft=7,
        rght=8,
        tree_id=1,
        level=2,
        role="redirect",
        name=redirect_name,
        slug=slugify(redirect_name),
        redirect_url=redirect_link,
    )

    def set_username(self, new_username, changed_by=None):
        if new_username != self.username:
            old_username = self.username
            self.username = new_username
            self.slug = slugify(new_username)

            if self.pk:
                changed_by = changed_by or self
                self.record_name_change(changed_by, new_username, old_username)
                username_changed.send(sender=self)

def post_thread(forum, title='Test thread', poster='Tester', is_pinned=False,
                is_moderated=False, is_hidden=False, is_closed=False,
                started_on=None):
    started_on = started_on or timezone.now()

    kwargs = {
        'forum': forum,
        'title': title,
        'slug': slugify(title),
        'started_on': started_on,
        'last_post_on': started_on,
        'is_pinned': is_pinned,
        'is_moderated': is_moderated,
        'is_hidden': is_hidden,
        'is_closed': is_closed,
    }

    try:
        kwargs.update({
            'starter': poster,
            'starter_name': poster.username,
            'starter_slug': poster.slug,
            'last_poster': poster,
            'last_poster_name': poster.username,
            'last_poster_slug': poster.slug,
            })
    except AttributeError:
        kwargs.update({
            'starter_name': poster,
            'starter_slug': slugify(poster),
            'last_poster_name': poster,
            'last_poster_slug': slugify(poster),
        })

    thread = Thread.objects.create(**kwargs)
    reply_thread(thread,
        poster=poster,
        posted_on=thread.last_post_on,
        is_moderated=is_moderated)

    return thread

    def set_first_post(self, post):
        self.started_on = post.posted_on
        self.first_post = post
        self.starter = post.poster
        self.starter_name = post.poster_name
        if post.poster:
            self.starter_slug = post.poster.slug
        else:
            self.starter_slug = slugify(post.poster_name)

        self.is_moderated = post.is_moderated
        self.is_hidden = post.is_hidden

    def set_username(self, new_username, changed_by=None):
        if new_username != self.username:
            old_username = self.username
            self.username = new_username
            self.slug = slugify(new_username)

            if self.pk:
                changed_by = changed_by or self
                self.record_name_change(
                    changed_by, new_username, old_username)

                from misago.users.signals import username_changed
                username_changed.send(sender=self)

def post_thread(forum, title='Test thread', weight=0, poster='Tester',
                is_moderated=False, is_hidden=False, is_closed=False,
                started_on=None):
    started_on = started_on or timezone.now()

    kwargs = {
        'forum': forum,
        'weight': weight,
        'title': title,
        'slug': slugify(title),
        'started_on': started_on,
        'last_post_on': started_on,
        'is_moderated': is_moderated,
        'is_hidden': is_hidden,
        'is_closed': is_closed,
    }

    try:
        kwargs.update({
            'starter': poster,
            'starter_name': poster.username,
            'starter_slug': poster.slug,
            'last_poster': poster,
            'last_poster_name': poster.username,
            'last_poster_slug': poster.slug,
            })
    except AttributeError:
        kwargs.update({
            'starter_name': poster,
            'starter_slug': slugify(poster),
            'last_poster_name': poster,
            'last_poster_slug': slugify(poster),
        })

    thread = Thread.objects.create(**kwargs)
    forum.synchronize()
    forum.save()
    return thread

    def test_valid_slugify_output(self):
        """Misago's slugify correctly slugifies string"""
        test_cases = (
            (u'Bob', u'bob'),
            (u'Eric The Fish', u'eric-the-fish'),
            (u'John   Snow', u'john-snow'),
            (u'J0n', u'j0n'),
            (u'An###ne', u'anne'),
            (u'S**t', u'st'),
            (u'Łók', u'lok'),
        )

        for original, slug in test_cases:
            self.assertEqual(slugify(original), slug)

def like_post(post, user=None, username=None):
    if not post.last_likes:
        post.last_likes = []

    if user:
        like = post.postlike_set.create(
            category=post.category,
            thread=post.thread,
            user=user,
            user_name=user.username,
            user_slug=user.slug,
            user_ip='127.0.0.1'
        )

        post.last_likes = [
            {
                'id': user.id,
                'username': user.username
            }
        ] + post.last_likes
    else:
        like = post.postlike_set.create(
            category=post.category,
            thread=post.thread,
            user_name=username,
            user_slug=slugify(username),
            user_ip='127.0.0.1'
        )

        post.last_likes = [
            {
                'id': None,
                'username': username
            }
        ] + post.last_likes

    post.likes += 1
    post.save()

    return like

 def set_title(self, title):
     self.title = title
     self.slug = slugify(title)

 def set_name(self, name):
     self.name = name
     self.slug = slugify(name)

 def get_by_username_or_email(self, login):
     queryset = models.Q(slug=slugify(login))
     queryset = queryset | models.Q(email_hash=hash_email(login))
     return self.get(queryset)

 def get_by_username(self, username):
     return self.get(slug=slugify(username))