Пример #1
0
    def test_validate_account(self):
        site = Site.objects.get_current().domain
        user = BlogUser.objects.create_superuser(email="*****@*****.**",
                                                 username="******", password="******")

        self.client.login(username='******', password='******')
        response = self.client.get('/admin/')
        self.assertEqual(response.status_code, 200)

        category = Category()
        category.name = "categoryaaa"
        category.created_time = datetime.datetime.now()
        category.last_mod_time = datetime.datetime.now()
        category.save()

        article = Article()
        article.title = "nicetitleaaa"
        article.body = "nicecontentaaa"
        article.author = user
        article.category = category
        article.type = 'a'
        article.status = 'p'
        article.save()

        response = self.client.get(article.get_admin_url())
        self.assertEqual(response.status_code, 200)
Пример #2
0
    def test_edit_category(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Log in
        self.client.login(username='******', password="******")

        # Edit the category
        response = self.client.post(
            '/admin/blog/category/1/', {
                'name': 'perl',
                'description': 'The Perl programming language'
            },
            follow=True)
        self.assertEquals(response.status_code, 200)

        # Check modificado com sucesso
        self.assertTrue('modificado com sucesso' in response.content)

        # Check category amended
        all_categories = Category.objects.all()
        self.assertEquals(len(all_categories), 1)
        only_category = all_categories[0]
        self.assertEquals(only_category.name, 'perl')
        self.assertEquals(only_category.description,
                          'The Perl programming language')
Пример #3
0
 def test_creating_a_new_comment_and_saving_it_to_the_database(self):
     # start by create one Category and one post
     category = Category()
     category.name = "First"
     category.slug = "first"
     category.save()
     
     # create new post
     post = Post()
     post.category = category
     post.title = "First post"
     post.content = "Content"
     post.visable = True
     post.save()
     
     # create one comment
     comment = Comment()
     comment.name = "John"
     comment.content = "This is cool"
     comment.post = post
     
     # check save
     comment.save()
     
     # now check we can find it in the database
     all_comment_in_database = Comment.objects.all()
     self.assertEquals(len(all_comment_in_database), 1)
     only_comment_in_database = all_comment_in_database[0]
     self.assertEquals(only_comment_in_database, comment)
     
     # and check that it's saved its two attributes: name and content
     self.assertEquals(only_comment_in_database.name, comment.name)
     self.assertEquals(only_comment_in_database.content, comment.content)
Пример #4
0
    def __create_category(self, lang, title, desc):
        cat = Category(lang=lang, title=title, desc=desc)

        cat.save()
        print("Created category : {} | {} | {} | ".format(lang, title, desc))

        return cat
Пример #5
0
    def test_validate_comment(self):
        site = Site.objects.get_current().domain
        user = BlogUser.objects.create_superuser(email="*****@*****.**",
                                                 username="******",
                                                 password="******")

        self.client.login(username='******', password='******')

        c = Category()
        c.name = "categoryccc"
        c.created_time = datetime.datetime.now()
        c.last_mod_time = datetime.datetime.now()
        c.save()

        article = Article()
        article.title = "nicetitleccc"
        article.body = "nicecontentccc"
        article.author = user
        article.category = c
        article.type = 'a'
        article.status = 'p'
        article.save()
        s = TextMessage([])
        s.content = "nicetitleccc"
        rsp = search(s, None)
        self.assertTrue(rsp != '没有找到相关文章。')
        rsp = category(None, None)
        self.assertIsNotNone(rsp)
        rsp = recents(None, None)
        self.assertTrue(rsp != '暂时还没有文章')

        cmd = commands()
        cmd.title = "test"
        cmd.command = "ls"
        cmd.describe = "test"
        cmd.save()

        cmdhandler = CommandHandler()
        rsp = cmdhandler.run('test')
        self.assertIsNotNone(rsp)
        s.source = 'u'
        s.content = 'test'
        msghandler = MessageHandler(s, {})

        #msghandler.userinfo.isPasswordSet = True
        #msghandler.userinfo.isAdmin = True
        msghandler.handler()
        s.content = 'y'
        msghandler.handler()
        s.content = 'idcard:12321233'
        msghandler.handler()
        s.content = 'weather:上海'
        msghandler.handler()
        s.content = 'admin'
        msghandler.handler()
        s.content = '123'
        msghandler.handler()

        s.content = 'exit'
        msghandler.handler()
Пример #6
0
 def test_creating_a_new_post_and_saving_it_to_the_database(self):
     # start by create one Category
     category = Category()
     category.name = "First"
     category.slug = "first"
     category.save()
     
     # create new post
     post = Post()
     post.category = category
     post.title = "First post"
     post.content = "Content"
     post.visable = True
     
     # check we can save it
     post.save()
     
     # check slug
     self.assertEquals(post.slug, "first-post")
     
     # now check we can find it in the database
     all_post_in_database = Post.objects.all()
     self.assertEquals(len(all_post_in_database), 1)
     only_post_in_database = all_post_in_database[0]
     self.assertEquals(only_post_in_database, post)
     
     # check that it's saved all attributes: category, title, content, visable and generate slug
     self.assertEquals(only_post_in_database.category, category)
     self.assertEquals(only_post_in_database.title, post.title)
     self.assertEquals(only_post_in_database.content, post.content)
     self.assertEquals(only_post_in_database.visable, post.visable)
     self.assertEquals(only_post_in_database.slug, post.slug)
Пример #7
0
    def test_validate_article(self):
        from accounts.models import BlogUser
        site = Site.objects.get_current().domain
        user = BlogUser()
        user.email = "*****@*****.**"
        user.username = "******"
        user.password = "******"
        user.set_password("liangliangyy")
        user.save()
        response = self.client.get(user.get_absolute_url())
        self.assertEqual(response.status_code, 200)

        category = Category()
        category.name = "category"
        category.created_time = datetime.datetime.now()
        category.last_mod_time = datetime.datetime.now()
        category.save()

        response = self.client.get(category.get_absolute_url())
        self.assertEqual(response.status_code, 200)

        article = Article()
        article.title = "nicetitle"
        article.body = "nicecontent"
        article.author = user
        article.category = category
        article.type = 'a'
        article.status = 'p'
        article.save()
        response = self.client.get(article.get_absolute_url())
        self.assertEqual(response.status_code, 200)
Пример #8
0
def blog_index(request):
    run_check()
    posts = Post.objects.all().order_by('-created_on')
    form = PostForm()
    if request.method == 'POST':
        form = PostForm(request.POST)
        if form.is_valid():
            a = form.cleaned_data['cat']
            count = Category.objects.filter(name=a).count()
            post = Post(
                writer=request.user,
                body=form.cleaned_data['body'],
                title=form.cleaned_data['title'],
            )

            if count == 0:
                ct = Category(name=form.cleaned_data['cat'])
                ct.save()
            else:
                ct = Category.objects.get(name=a)
            post.save()
            post.categories.add(ct)
    context = {
        "posts": posts,
        'form': form,
        'user': request.user,
    }

    return render(request, "blog_index.html", context)
Пример #9
0
    def test_create_post_without_tag(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Log in
        self.client.login(username='******', password="******")

        # Check response code
        response = self.client.get('/admin/blog/post/add/')
        self.assertEquals(response.status_code, 200)

        # Create the new post
        response = self.client.post('/admin/blog/post/add/', {
            'title': 'My first post',
            'text': 'This is my first post',
            'pub_date_0': '2013-12-28',
            'pub_date_1': '22:00:04',
            'slug': 'my-first-post',
            # 'site': '1',
            'category': '1'
        },
                                    follow=True
        )
        self.assertEquals(response.status_code, 200)

        # Check added successfully
        self.assertTrue('added successfully' in response.content)

        # Check new post now in database
        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 1)
Пример #10
0
class PostTests(TestCase):
    def setUp(self):
        self.author = Consumer.objects.create_user(
            email="*****@*****.**", password="******"
        )
        self.category = Category(title="Test Category", slug="test-category")
        self.post = Post(
            title="This is a test",
            slug="this-is-a-test",
            author=self.author,
            category=self.category,
            content="this is a test content",
            status=0,
        )
        self.author.save()
        self.category.save()
        self.post.save()

    def test_post_creation(self):
        self.assertEqual(len(Category.objects.all()), 1)
        self.assertEqual(len(Post.objects.all()), 1)

        self.assertEqual(self.post.status, 0)

    def test_post_changing_status(self):
        Post.objects.change_status(self.post.pk, 1)
        post = Post.objects.get(pk=1)
        self.assertEqual(post.status, 1)
Пример #11
0
    def test_edit_category(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Log in
        self.client.login(username='******', password="******")

        # Edit the category
        response = self.client.post('/admin/blogengine/category/1/', {
            'name': 'perl',
            'description': 'The Perl programming language'
            }, follow=True)
        self.assertEquals(response.status_code, 200)

        # Check changed successfully
        self.assertTrue('changed successfully' in response.content)

        # Check category amended
        all_categories = Category.objects.all()
        self.assertEquals(len(all_categories), 1)
        only_category = all_categories[0]
        self.assertEquals(only_category.name, 'perl')
        self.assertEquals(only_category.description, 'The Perl programming language')
Пример #12
0
 def handle(self, *args, **options):
     with open('upload-temp') as f:
         sep = '\n' + ('-' * 70) + '\n'
         fields = f.read().split(sep)
         if options['edit']:
             try:
                 p = Post.objects.get(slug=fields[1])
                 p.edited = datetime.now()
             except Post.DoesNotExist:
                 raise CommandError('no post with slug "%s" exists'
                                    % fields[1]) 
         else:
             p = Post()
             p.created = datetime.now()
             p.edited = None
         p.title = fields[0]
         p.slug = fields[1]
         p.preview = fields[3]
         p.content = fields[4]
         p.save()
         p.categories.clear()
         for cat in fields[2].split(', '):
             try:
                 c = Category.objects.get(name=cat)
             except Category.DoesNotExist:
                 c = Category(name=cat, slug=slugify(cat))
                 c.save()
             p.categories.add(c)
         p.save()
Пример #13
0
def async_add_category(request):
    if not request.POST:
        raise Http404
    
    data = {}
    
    name = request.POST.get('name', False)
    slug = request.POST.get('slug', False)
    if name == False or slug == False:
        data.update({"status": False, "message": "Invalid data."})
    elif len(name) == 0 or len(slug) == 0:
        data.update({"status": False, "message": "Neither field can be blank."})
    else:
        try:
            cat = Category(name=slug,label=name) # Stupid naming of the model.  Don't feel like fixing all references..
            cat.save()
            data.update({"status": True, "message": "Category successfully added.", 
                         "slug": cat.name, "name": cat.label})
        except:
            data.update({"status": False, "message": "An unknown error occured. Please reload the page."})
    
    return HttpResponse(simplejson.dumps(data), mimetype="application/javascript")

### END AJAX VIEWS ###
    
Пример #14
0
    def test_validate_account(self):
        site = get_current_site().domain
        user = BlogUser.objects.create_superuser(
            email="*****@*****.**",
            username="******",
            password="******")
        testuser = BlogUser.objects.get(username='******')

        loginresult = self.client.login(username='******',
                                        password='******')
        self.assertEqual(loginresult, True)
        response = self.client.get('/admin/')
        self.assertEqual(response.status_code, 200)

        category = Category()
        category.name = "categoryaaa"
        category.created_time = datetime.datetime.now()
        category.last_mod_time = datetime.datetime.now()
        category.save()

        article = Article()
        article.title = "nicetitleaaa"
        article.body = "nicecontentaaa"
        article.author = user
        article.category = category
        article.type = 'a'
        article.status = 'p'
        article.save()

        response = self.client.get(article.get_admin_url())
        self.assertEqual(response.status_code, 200)
Пример #15
0
    def post(self):
        from .models import FontIcon, FontIconLibrary
        iconclass = None
        i = request.form.get('icon', None)
        if i is not None:

            lib, icon = i.split('-')[0], i.split('-')[1:]
            iconclass = FontIcon.query.filter(
                FontIcon.name == ''.join(map(str, icon)),
                FontIconLibrary.name == lib).first()

        self._context['form_args'] = {'heading': self._form_heading}
        self._form = self._form(request.form)
        if self._form.validate():
            from blog.models import Category
            c = Category.query.filter(
                Category.name == self._form.name.data).first()
            if c is None:
                c = Category()
                if iconclass is not None:
                    c.icon_id = iconclass.id
                c.name = self._form.name.data
                c.description = self._form.description.data
                c.save()
                self.flash('You added category: {}'.format(c.name))
                if request.args.get('last_url'):
                    return self.redirect(request.args.get('last_url'),
                                         raw=True)
            else:
                self.flash(
                    'There is already a category by that name, try again')
        return self.redirect('core.index')
Пример #16
0
    def test_create_post_without_tag(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Log in
        self.client.login(username='******', password="******")

        # Check response code
        response = self.client.get('/admin/blog/post/add/')
        self.assertEquals(response.status_code, 200)

        # Create the new post
        response = self.client.post('/admin/blog/post/add/', {
            'title': 'My first post',
            'text': 'This is my first post',
            'pub_date_0': '2013-12-28',
            'pub_date_1': '22:00:04',
            'slug': 'my-first-post',
            'site': '1',
            'category': '1'
        },
                                    follow=True)
        self.assertEquals(response.status_code, 200)

        # Check added successfully
        self.assertTrue('adicionado com sucesso' in response.content)

        # Check new post now in database
        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 1)
Пример #17
0
    def test_validate_account(self):
        site = Site.objects.get_current().domain
        user = BlogUser.objects.create_superuser(email="*****@*****.**",
                                                 username="******", password="******")

        self.client.login(username='******', password='******')
        response = self.client.get('/admin/')
        self.assertEqual(response.status_code, 200)

        category = Category()
        category.name = "categoryaaa"
        category.created_time = datetime.datetime.now()
        category.last_mod_time = datetime.datetime.now()
        category.save()

        article = Article()
        article.title = "nicetitleaaa"
        article.body = "nicecontentaaa"
        article.author = user
        article.category = category
        article.type = 'a'
        article.status = 'p'
        article.save()

        response = self.client.get(article.get_admin_url())
        self.assertEqual(response.status_code, 200)
Пример #18
0
 def handle(self, *args, **options):
     with open('upload-temp') as f:
         sep = '\n' + ('-' * 70) + '\n'
         fields = f.read().split(sep)
         if options['edit']:
             try:
                 p = Post.objects.get(slug=fields[1])
                 p.edited = datetime.now()
             except Post.DoesNotExist:
                 raise CommandError('no post with slug "%s" exists' %
                                    fields[1])
         else:
             p = Post()
             p.created = datetime.now()
             p.edited = None
         p.title = fields[0]
         p.slug = fields[1]
         p.preview = fields[3]
         p.content = fields[4]
         p.save()
         p.categories.clear()
         for cat in fields[2].split(', '):
             try:
                 c = Category.objects.get(name=cat)
             except Category.DoesNotExist:
                 c = Category(name=cat, slug=slugify(cat))
                 c.save()
             p.categories.add(c)
         p.save()
Пример #19
0
def addCategory(request):
    if request.method=='POST':
        name = request.POST['name']
        slug = request.POST['slug']
        desc = request.POST['desc']
        type = request.POST['type']
        if type and type == 'add':
            try:
                cats=Category.objects.filter(name=name)
                if cats.count() >= 1:
                    messages.add_message(request,messages.INFO,'categry [%s] already exits!'%(name))
                else:
                    cat = Category(name=name,slug=slug,desc=desc)
                    cat.save()
                    messages.add_message(request,messages.INFO,'categry [%s] save ok!'%(name))
            except:
                pass
                
        elif type and type == 'edit':
            id = request.POST.get('id','')
            cat = Category.objects.get(id=id)
            cat.name=name
            cat.slug=slug
            cat.desc=desc
            cat.save()
        return HttpResponseRedirect('/admin/categories')
Пример #20
0
def addCategory(request):
    name = request.POST['name']
    slug = request.POST['slug']
    desc = request.POST['desc']
    type = request.POST['type']
    pid = request.POST['category_parent']
    if pid == '0':
        pid = None
    if type and type == 'add':
        try:
            cats=Category.objects.filter(name=name)
            if cats.count() >= 1:
                messages.add_message(request,messages.INFO,'categry [%s] already exits!'%(name))
            else:
                cat = Category(name=name,slug=slug,desc=desc,parent_id=pid)
                cat.save()
                messages.add_message(request,messages.INFO,'categry [%s] save ok!'%(name))
        except Exception as e:
            print 'exception:',e
    elif type and type == 'edit':
        id = request.POST.get('id','')
        cat = Category.objects.get(id=id)
        cat.name=name
        cat.slug=slug
        cat.desc=desc
        cat.parent_id = pid
        cat.save()
    return HttpResponseRedirect('/admin/categories')
Пример #21
0
    def post(self):
        from .models import FontIcon,FontIconLibrary
        iconclass = None
        i = request.form.get('icon',None) 
        if i is not None:

            lib,icon = i.split('-')[0],i.split('-')[1:]
            iconclass = FontIcon.query.filter(FontIcon.name==''.join(map(str,icon)),FontIconLibrary.name==lib).first()

        self._context['form_args'] = {'heading':self._form_heading}
        self._form = self._form(request.form)
        if self._form.validate():
            from blog.models import Category
            c = Category.query.filter(Category.name==self._form.name.data).first()
            if c is None:
                c = Category()
                if iconclass is not None:
                    c.icon_id = iconclass.id
                c.name = self._form.name.data
                c.description = self._form.description.data
                c.save()
                self.flash('You added category: {}'.format(c.name))
                if request.args.get('last_url'):
                    return self.redirect(request.args.get('last_url'),raw=True)
            else:
                self.flash('There is already a category by that name, try again')
        return self.redirect('core.index')
Пример #22
0
    def test_validate_register(self):
        self.assertEquals(
            0, len(BlogUser.objects.filter(email='*****@*****.**')))
        response = self.client.post(
            reverse('account:register'), {
                'username': '******',
                'email': '*****@*****.**',
                'password1': 'password123!q@wE#R$T',
                'password2': 'password123!q@wE#R$T',
            })
        self.assertEquals(
            1, len(BlogUser.objects.filter(email='*****@*****.**')))
        user = BlogUser.objects.filter(email='*****@*****.**')[0]
        sign = get_md5(get_md5(settings.SECRET_KEY + str(user.id)))
        path = reverse('accounts:result')
        url = '{path}?type=validation&id={id}&sign={sign}'.format(path=path,
                                                                  id=user.id,
                                                                  sign=sign)
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

        self.client.login(username='******', password='******')
        user = BlogUser.objects.filter(email='*****@*****.**')[0]
        user.is_superuser = True
        user.is_staff = True
        user.save()
        delete_sidebar_cache(user.username)
        category = Category()
        category.name = "categoryaaa"
        category.created_time = datetime.datetime.now()
        category.last_mod_time = datetime.datetime.now()
        category.save()

        article = Article()
        article.category = category
        article.title = "nicetitle333"
        article.body = "nicecontentttt"
        article.author = user

        article.type = 'a'
        article.status = 'p'
        article.save()

        response = self.client.get(article.get_admin_url())
        self.assertEqual(response.status_code, 200)

        response = self.client.get(reverse('account:logout'))
        self.assertIn(response.status_code, [301, 302, 200])

        response = self.client.get(article.get_admin_url())
        self.assertIn(response.status_code, [301, 302, 200])

        response = self.client.post(reverse('account:login'), {
            'username': '******',
            'password': '******'
        })
        self.assertIn(response.status_code, [301, 302, 200])

        response = self.client.get(article.get_admin_url())
        self.assertIn(response.status_code, [301, 302, 200])
Пример #23
0
    def handle(self, *args, **options):
        self.stdout.write('wait a second..')
        fake = Factory.create('zh_CN')
        iamge_base = settings.QINIU_BASE_URL + 'fake_site/'

        for i in range(1, 4):
            c = Category(id=i, name='test category {0}'.format(i))
            c.save()

        tags = []
        for i in range(20):
            tags.append(fake.city())
        tags = set(tags)

        for i in range(50):
            p = Post(
                category=Category.objects.get(pk=randint(1, 3)),
                header_image_url=iamge_base + '{}.jpg'.format(randint(1, 5)),
                title=fake.country() + fake.city_name() + fake.street_name(),
                subtitle=fake.sentence(nb_words=2, variable_nb_words=True),
                content=self.fake_markdown_content(fake))

            p.save()
            p.tags.add(*sample(tags, randint(1, 3)))
            orginal = p.create_date
            p.create_date = orginal.replace(year=randint(2013, 2015),
                                            month=randint(1, 12))
            p.save()

        user = User.objects.create_user('demouser', password='******')
        user.save()

        self.stdout.write(self.style.SUCCESS('done!'))
        self.stdout.write(self.style.SUCCESS('username as password: demouser'))
Пример #24
0
    def test_all_post_feed(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Create the tag
        tag = Tag()
        tag.name = 'python'
        tag.description = 'The Python programming language'
        tag.save()

        # Create the author
        author = User.objects.create_user('testuser', '*****@*****.**', 'password')
        author.save()

        # Create the site
        site = Site()
        site.name = 'example.com'
        site.domain = 'example.com'
        site.save()
 
        # Create a post
        post = Post()
        post.title = 'My first post'
        post.text = 'This is my first blog post'
        post.slug = 'my-first-post'
        post.pub_date = timezone.now()
        post.author = author
        post.site = site
        post.category = category

        # Save it
        post.save()

        # Add the tag
        post.tags.add(tag)
        post.save()

        # Check we can find it
        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 1)
        only_post = all_posts[0]
        self.assertEquals(only_post, post)

        # Fetch the feed
        response = self.client.get('/feeds/posts/')
        self.assertEquals(response.status_code, 200)

        # Parse the feed
        feed = feedparser.parse(response.content)

        # Check length
        self.assertEquals(len(feed.entries), 1)

        # Check post retrieved is the correct one
        feed_post = feed.entries[0]
        self.assertEquals(feed_post.title, post.title)
        self.assertEquals(feed_post.description, post.text)
Пример #25
0
    def test_category_page(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Create the author
        author = User.objects.create_user('testuser', '*****@*****.**',
                                          'password')
        author.save()

        # Create the site
        site = Site()
        site.name = 'example.com'
        site.domain = 'example.com'
        site.save()

        # Create the post
        post = Post()
        post.title = 'My first post'
        post.text = 'This is [my first blog post](http://127.0.0.1:8000/)'
        post.slug = 'my-first-post'
        post.pub_date = timezone.now()
        post.author = author
        post.site = site
        post.category = category
        post.save()

        # Check new post saved
        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 1)
        only_post = all_posts[0]
        self.assertEquals(only_post, post)

        # Get the category URL
        category_url = post.category.get_absolute_url()

        # Fetch the category
        response = self.client.get(category_url)
        self.assertEquals(response.status_code, 200)

        # Check the category name is in the response
        self.assertTrue(post.category.name in response.content)

        # Check the post text is in the response
        self.assertTrue(
            markdown.markdown(post.text).encode() in response.content)

        # Check the post date is in the response
        self.assertTrue(str(post.pub_date.year) in response.content)
        self.assertTrue(
            _date(post.pub_date, "F").encode('utf-8') in response.content)
        self.assertTrue(str(post.pub_date.day) in response.content)

        # Check the link is marked up properly
        self.assertTrue(
            '<a href="http://127.0.0.1:8000/">my first blog post</a>' in
            response.content)
Пример #26
0
    def test_validate_comment(self):
        site = Site.objects.get_current().domain
        user = BlogUser.objects.create_superuser(email="*****@*****.**",
                                                 username="******", password="******")

        self.client.login(username='******', password='******')

        c = Category()
        c.name = "categoryccc"
        c.created_time = datetime.datetime.now()
        c.last_mod_time = datetime.datetime.now()
        c.save()

        article = Article()
        article.title = "nicetitleccc"
        article.body = "nicecontentccc"
        article.author = user
        article.category = c
        article.type = 'a'
        article.status = 'p'
        article.save()
        s = TextMessage([])
        s.content = "nicetitleccc"
        rsp = search(s, None)
        self.assertTrue(rsp != '没有找到相关文章。')
        rsp = category(None, None)
        self.assertIsNotNone(rsp)
        rsp = recents(None, None)
        self.assertTrue(rsp != '暂时还没有文章')

        cmd = commands()
        cmd.title = "test"
        cmd.command = "ls"
        cmd.describe = "test"
        cmd.save()

        cmdhandler = CommandHandler()
        rsp = cmdhandler.run('test')
        self.assertIsNotNone(rsp)
        s.source = 'u'
        s.content = 'test'
        msghandler = MessageHandler(s, {})

        #msghandler.userinfo.isPasswordSet = True
        #msghandler.userinfo.isAdmin = True
        msghandler.handler()
        s.content = 'y'
        msghandler.handler()
        s.content='idcard:12321233'
        msghandler.handler()
        s.content='weather:上海'
        msghandler.handler()
        s.content='admin'
        msghandler.handler()
        s.content='123'
        msghandler.handler()

        s.content = 'exit'
        msghandler.handler()
Пример #27
0
def createCategory(request):
    if request.method == 'GET':
        return render(request, 'createcategory.html')
    else:
        t = request.POST['category']
        c = Category(title=t)
        c.save()
        return redirect('home')
Пример #28
0
 def post(self, request):
     try:
         name = request.POST.get('name')
         description = request.POST.get('description')
         category = Category(name=name, description=description)
         category.save()
     except Exception, e:
         return JsonResponse({'msg': '新增失败\n%s' % unicode(e)}, status=500)
Пример #29
0
    def __create_category(self, lang, title, desc):
        cat = Category(lang=lang, title=title, desc=desc)

        cat.save()
        print(
            "Created category : {} | {} | {} | ".format(lang, title, desc))

        return cat
Пример #30
0
def save_category(category_id):
    category = None
    try:
        category = Category.objects.get(name=category_id)
    except Exception:
        pass
    if not category:
        category = Category(name=category_id)
        category.save()
Пример #31
0
 def test_is_count_one(self):
     category = Category(name="テストカテゴリー")
     category.save()
     tag = Tag(name="テストタグ")
     tag.save()
     post = Post(category=category, title="test_title", body="test_body")
     post.save()
     saved_posts = Post.objects.all()
     self.assertEqual(saved_posts.count(), 1)
Пример #32
0
    def test_edit_posts(self):
        category = Category()
        category.name = 'python'
        category.description = 'The python language'
        category.save()

        # Create the tag
        tag = Tag()
        tag.name = 'python'
        tag.description = 'The Python programming language'
        tag.save()

        author = User.objects.create_user('testuser', '*****@*****.**', 'password')
        author.save()

        # site = Site()
        # site.name = 'nunfuxgvn.com'
        # site.domain = 'nunfuxgvn.com'
        # site.save()


        post = Post()
        post.title = 'First Post'
        post.content = 'My first post -yay'
        post.slug = 'first-post'
        post.pub_date = timezone.now()
        post.author = author
        # post.site = site
        post.save()
        post.tags.add(tag)
        post.save()

        self.client.login(username='******', password='******')

        response = self.client.post('/admin/blog/post/1/', {
            'title': 'Second Post',
            'text': 'This is my second post',
            'pub_date_0': '2014-07-17',
            'pub_date_1': '11:49:24',
            'slug': 'second-post',
            # 'site': '1',
            'category': '1',
            'tags': '1'
        },
                                    follow=True
        )
        self.assertEquals(response.status_code, 200)

        # Check post successfully changed
        self.assertTrue('changed successfully' in response.content)

        # Check post amended 
        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 1)
        only_post = all_posts[0]
        self.assertEquals(only_post.title, 'Second Post')
        self.assertEquals(only_post.content, 'This is my second post')
Пример #33
0
def add_category(request):
	try:
		req = convertRequest(request)

		category_name = req['category_name']
		category = Category(category_name=category_name)
		category.save()
		return HttpResponse(response_json.success())
	except Exception, e:
		return HttpResponse(response_json.fail(traceback.format_exc()))
Пример #34
0
    def test_delete_post(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Create the tag
        tag = Tag()
        tag.name = 'python'
        tag.description = 'The Python programming language'
        tag.save()

        # Create the author
        author = User.objects.create_user('testuser', '*****@*****.**',
                                          'password')
        author.save()

        # Create the site
        site = Site()
        site.name = 'example.com'
        site.domain = 'example.com'
        site.save()

        # Create the post
        post = Post()
        post.title = 'My first post'
        post.text = 'This is my first blog post'
        post.slug = 'my-first-post'
        post.pub_date = timezone.now()
        post.site = site
        post.author = author
        post.save()
        post.tags.add(tag)
        post.save()

        # Check new post saved
        all_posts = Post.objects.all()
        self.assertGreater(len(all_posts), 0)

        # Log in
        self.client.login(username='******', password="******")

        # Delete the post
        response = self.client.post('/admin/blog/post/1/delete/',
                                    {'post': 'yes'},
                                    follow=True)
        self.assertEquals(response.status_code, 200)

        # Check excluído com sucesso
        self.assertTrue('excluído com sucesso' in response.content)

        # Check post amended
        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 0)
Пример #35
0
    def test_delete_post(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Create the tag
        tag = Tag()
        tag.name = 'python'
        tag.description = 'The Python programming language'
        tag.save()

        # Create the author
        author = User.objects.create_user('testuser', '*****@*****.**', 'password')
        author.save()

        # Create the site
        site = Site()
        site.name = 'example.com'
        site.domain = 'example.com'
        site.save()
        
        # Create the post
        post = Post()
        post.title = 'My first post'
        post.text = 'This is my first blog post'
        post.slug = 'my-first-post'
        post.pub_date = timezone.now()
        post.site = site
        post.author = author
        post.category = category
        post.save()
        post.tags.add(tag)
        post.save()

        # Check new post saved
        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 1)

        # Log in
        self.client.login(username='******', password="******")

        # Delete the post
        response = self.client.post('/admin/blogengine/post/1/delete/', {
            'post': 'yes'
        }, follow=True)
        self.assertEquals(response.status_code, 200)

        # Check deleted successfully
        self.assertTrue('deleted successfully' in response.content)

        # Check post deleted
        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 0)
Пример #36
0
    def post(self, request, *args, **kwargs):
        # name = request.Post.get('name')
        # description = request.Post.get('description') 这种用法不正确

        # request.data 返回解析之后的请求体数据
        name = request.data['name']
        description = request.data['description']

        category_obj = Category(name=name, description=description)
        category_obj.save()
        return Response('添加文章类型成功')
Пример #37
0
    def test_category_page(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Create the author
        author = User.objects.create_user('testuser', '*****@*****.**', 'password')
        author.save()

        # Create the site
        site = Site()
        site.name = 'example.com'
        site.domain = 'example.com'
        site.save()

        # Create the post
        post = Post()
        post.title = 'My first post'
        post.text = 'This is [my first blog post](http://127.0.0.1:8000/)'
        post.slug = 'my-first-post'
        post.pub_date = timezone.now()
        post.author = author
        post.site = site
        post.category = category
        post.save()

        # Check new post saved
        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 1)
        only_post = all_posts[0]
        self.assertEquals(only_post, post)

        # Get the category URL
        category_url = post.category.get_absolute_url()

        # Fetch the category
        response = self.client.get(category_url)
        self.assertEquals(response.status_code, 200)

        # Check the category name is in the response
        self.assertTrue(post.category.name in response.content)

        # Check the post text is in the response
        self.assertTrue(markdown.markdown(post.text) in response.content)

        # Check the post date is in the response
        self.assertTrue(str(post.pub_date.year) in response.content)
        self.assertTrue(post.pub_date.strftime('%b') in response.content)
        self.assertTrue(str(post.pub_date.day) in response.content)

        # Check the link is marked up properly
        self.assertTrue('<a href="http://127.0.0.1:8000/">my first blog post</a>' in response.content)
Пример #38
0
def add_new_category(request):
    if request.method == 'POST':
        text = request.POST.get('text')
        slug = request.POST.get('slug')
    category = Category()
    category.text = text
    category.slug = slug
    category.save()

    my_dict = {'taxonomy':'category'}
    return render(request, 'backend/taxonomy.html', context=my_dict)
Пример #39
0
def add_category(request):
    """添加分类"""
    category_name = request.POST.get('category_name')

    if category_name is None or len(category_name) < 1 or len(
            category_name) > 20:
        return HttpResponseBadRequest()

    category = Category(category_name=category_name)
    category.save()

    return HttpResponseRedirect('/backend/categories')
Пример #40
0
    def test_validate_register(self):
        self.assertEquals(
            0, len(BlogUser.objects.filter(email='*****@*****.**')))
        response = self.client.post(
            reverse('account:register'), {
                'username': '******',
                'email': '*****@*****.**',
                'password1': 'password123!q@wE#R$T',
                'password2': 'password123!q@wE#R$T',
            })
        self.assertEquals(
            1, len(BlogUser.objects.filter(email='*****@*****.**')))

        self.client.login(username='******', password='******')
        user = BlogUser.objects.filter(email='*****@*****.**')[0]
        user.is_superuser = True
        user.is_staff = True
        user.save()
        delete_view_cache(user.username)
        category = Category()
        category.name = "categoryaaa"
        category.created_time = datetime.datetime.now()
        category.last_mod_time = datetime.datetime.now()
        category.save()

        article = Article()
        article.category = category
        article.title = "nicetitle333"
        article.body = "nicecontentttt"
        article.author = user

        article.type = 'a'
        article.status = 'p'
        article.save()

        response = self.client.get(article.get_admin_url())
        self.assertEqual(response.status_code, 200)

        response = self.client.get(reverse('account:logout'))
        self.assertIn(response.status_code, [301, 302, 200])

        response = self.client.get(article.get_admin_url())
        self.assertIn(response.status_code, [301, 302, 200])

        response = self.client.post(reverse('account:login'), {
            'username': '******',
            'password': '******'
        })
        self.assertIn(response.status_code, [301, 302, 200])

        response = self.client.get(article.get_admin_url())
        self.assertIn(response.status_code, [301, 302, 200])
Пример #41
0
    def test_validate_comment(self):
        site = get_current_site().domain
        user = BlogUser.objects.create_superuser(
            email="*****@*****.**",
            username="******",
            password="******")

        self.client.login(username='******', password='******')

        c = Category()
        c.name = "categoryccc"
        c.created_time = timezone.now()
        c.last_mod_time = timezone.now()
        c.save()

        article = Article()
        article.title = "nicetitleccc"
        article.body = "nicecontentccc"
        article.author = user
        article.category = c
        article.type = 'a'
        article.status = 'p'
        article.save()
        s = TextMessage([])
        s.content = "nice"
        rsp = search(s, None)
        rsp = category(None, None)
        self.assertIsNotNone(rsp)
        rsp = recents(None, None)
        self.assertTrue(rsp != 'No articles yet')

        cmd = commands()
        cmd.title = "test"
        cmd.command = "ls"
        cmd.describe = "test"
        cmd.save()

        cmdhandler = CommandHandler()
        rsp = cmdhandler.run('test')
        self.assertIsNotNone(rsp)
        s.source = 'u'
        s.content = 'test'
        msghandler = MessageHandler(s, {})

        # msghandler.userinfo.isPasswordSet = True
        # msghandler.userinfo.isAdmin = True
        msghandler.handler()
        s.content = 'y'
        msghandler.handler()
        s.content = 'idcard:12321233'
        msghandler.handler()
        s.content = 'weather:
Пример #42
0
    def test_index(self):
        category = Category()
        category.name = 'python'
        category.description = 'The python language'
        category.save()

        # Create the tag
        tag = Tag()
        tag.name = 'perl'
        tag.description = 'The Perl programming language'
        tag.save()

        author = User.objects.create_user('testuser', '*****@*****.**', 'password')
        author.save()

        # site = Site()
        # site.name = 'nunfuxgvn.com'
        # site.domain = 'nunfuxgvn.com'
        # site.save()

        post = Post()
        post.title = 'First Post'
        post.content = 'My [first post](http://127.0.0.1:8000/) -yay'
        post.slug = 'first-post'
        post.pub_date = timezone.now()
        post.author = author
        # post.site = site
        post.category = category
        post.save()
        post.tags.add(tag)

        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 1)

        # Fetch test_index
        response = self.client.get('/')
        self.assertEquals(response.status_code, 200)

        self.assertTrue(post.title in response.content)

        self.assertTrue(markdown.markdown(post.content) in response.content)

        self.assertTrue(post.category.name in response.content)

        post_tag = all_posts[0].tags.all()[0]
        self.assertTrue(post_tag.name in response.content)

        self.assertTrue(str(post.pub_date.year) in response.content)
        self.assertTrue(post.pub_date.strftime('%b') in response.content)
        self.assertTrue(str(post.pub_date.day) in response.content)

        self.assertTrue('<a href="http://127.0.0.1:8000/">first post</a>' in response.content)
Пример #43
0
def addCategory(fatherid, name):
    father = Category.objects.get(id=fatherid)
    if fatherid != 1:
        pathStr = father.pathStr + "#" + name
    else:
        pathStr = name
    newCategory = Category(
        name=name,
        fatherid=fatherid,
        pathStr=pathStr,
        cnt=0,
    )
    newCategory.save()
Пример #44
0
    def test_saving_retrieving_post(self):
        category = Category(name="テストカテゴリー")
        category.save()
        tag = Tag(name="テストタグ")
        tag.save()
        post = Post(category=category, title="test_title", body="test_body")
        post.save()

        saved_posts = Post.objects.all()
        actual_post = saved_posts[
            0]  #0は、saved_postsというリストから最初の値を取り出すという意味。2番目の値を取り出すなら1

        self.assertEqual(actual_post.title, "test_title")
        self.assertEqual(actual_post.body, "test_body")
Пример #45
0
def blog_list_categories(request):

    form = AddCategory()
    if request.method == 'POST':
        form = AddCategory(request.POST)
        if form.is_valid():
            category = Category(
                name=form.cleaned_data["name"],
            )
            category.save()
    categories = Category.objects.all()
    context = {"categories":categories, "form":form}

    return render(request, "blog_list_categories.html", context=context)
Пример #46
0
def savepost(request):
    c = Category(name='category test')
    c.save()
    t = Tag(name='tag1')
    t.save()
    user = User.objects.get(username='******')
    p = Post(title='title test',
             body='body test',
             created_time=timezone.now(),
             modified_time=timezone.now(),
             category=c,
             author=user)
    p.save()
    return HttpResponse('<P>添加数据成功</P>')
Пример #47
0
    def test_delete_url(self):
        category = Category(name="テストカテゴリー")
        category.save()
        tag = Tag(name="テストタグ")
        tag.save()
        post = Post(category=category, title="test_title", body="test_body")
        post.save()

        url = reverse("blog:delete", kwargs={"pk": post.pk})
        response = self.client.get(url)

        self.assertEqual(response.status_code, 200)
        template = "blog/post_comfirm_delete.html"
        self.assertTemplateUsed(template)
Пример #48
0
 def post(self):
     self._context['form_args'] = {'heading':self._form_heading}
     self._form = self._form(request.form)
     if self._form.validate():
         from blog.models import Category
         c = Category.query.filter(Category.name==self._form.name.data).first()
         if c is None:
             c = Category()
             c.name = self._form.name.data
             c.description = self._form.description.data
             c.save()
             self.flash('You added category: {}'.format(c.name))
         else:
             self.flash('There is already a category by that name, try again')
     return self.render()
Пример #49
0
    def test_validate_register(self):
        self.assertEquals(0, len(BlogUser.objects.filter(email='*****@*****.**')))
        response = self.client.post(reverse('account:register'), {
            'username': '******',
            'email': '*****@*****.**',
            'password1': 'password123',
            'password2': 'password123',
        })
        self.assertEquals(1, len(BlogUser.objects.filter(email='*****@*****.**')))

        self.client.login(username='******', password='******')
        user = BlogUser.objects.filter(email='*****@*****.**')[0]
        user.is_superuser = True
        user.is_staff = True
        user.save()
        category = Category()
        category.name = "categoryaaa"
        category.created_time = datetime.datetime.now()
        category.last_mod_time = datetime.datetime.now()
        category.save()

        article = Article()
        article.category = category
        article.title = "nicetitle333"
        article.body = "nicecontentttt"
        article.author = user

        article.type = 'a'
        article.status = 'p'
        article.save()

        response = self.client.get(article.get_admin_url())
        self.assertEqual(response.status_code, 200)

        response = self.client.get(reverse('account:logout'))
        self.assertIn(response.status_code, [301, 302])

        response = self.client.get(article.get_admin_url())
        self.assertIn(response.status_code, [301, 302])

        response = self.client.post(reverse('account:login'), {
            'username': '******',
            'password': '******'
        })
        self.assertIn(response.status_code, [301, 302])

        response = self.client.get(article.get_admin_url())
        self.assertEqual(response.status_code, 200)
Пример #50
0
def add(request):
    uid = int(-1)
    userInfos = common.Users(request, uid)
    currentUser = userInfos["currentuser"]

    name = utility.GetPostData(request, "name")
    sortnum = utility.GetPostData(request, "sortnum")

    if request.POST.has_key("ok"):
        categoryInfo = Category()
        categoryInfo.name = name
        categoryInfo.sortnum = sortnum
        categoryInfo.user_id = currentUser.id
        categoryInfo.save()

    return HttpResponseRedirect(categoryroot % currentUser.id)
Пример #51
0
def addCategory(request):
	categories=Category.objects.all();
	addCategory=True;
	displayForm=True;	
	if request.method=='POST':
		form=CategoryForm(request.POST)
		if form.is_valid():
			title=form.cleaned_data['title'];
			envoi=True
			#creation of the section object
			category=Category(title=title)
			category.save();
			return home(request)
	else:
		form=CategoryForm()
	return render(request, 'blog/blogForm.html',locals())		
Пример #52
0
def new_post(request):
    """
    Create a new Post
    """
    if request.method == 'POST':
        form = PostForm(request.POST)
        if form.is_valid():
            #Separate the tags we have seen before from those we haven't
            tags = form.cleaned_data['tags'].split(' ')
            known_tags = list(Tag.objects.filter(tag__in=tags))
            unknown_tag_names = set(tags) - set(x.tag for x in known_tags)
            #Create the unknown tags
            unknown_tags = [Tag(tag=x) for x in unknown_tag_names]
            #Tag.objects.bulk_create(unknown_tags)  # Sadly, this doesn't work.
            [t.save() for t in unknown_tags]

            #If category doesn't exist, create it
            try:
                category = Category.objects.get(name=form.cleaned_data['category'])
            except Category.DoesNotExist:
                category = Category(name=form.cleaned_data['category'], description='')
                category.save()

            #Create the Post object
            post = Post(
                user = request.user,
                category = category,
                title = form.cleaned_data['title'],
                body = form.cleaned_data['body'],
                date = datetime.now()
            )
            post.save()
            #You must create a primary key (by saving an object),
            #before you can use a many to many relationship
            post.tags.add(*(known_tags + unknown_tags))
            post.save()
            return HttpResponseRedirect('/')
        else:
            messages.error(request, 'Invalid post')
            return HttpResponseRedirect(reverse('new_post'))
    else:
        form = PostForm()

    return render(request, 'new_post.html', {
        'form': form,
    })
Пример #53
0
    def test_create_category(self):
        category = Category()

        category.name = 'python'
        category.description = 'The python language'
        category.slug = 'python'

        category.save()

        all_categories = Category.objects.all()
        self.assertEquals(len(all_categories), 1)
        only_category = all_categories[0]
        self.assertEquals(only_category, category)

        self.assertEquals(only_category.name, 'python')
        self.assertEquals(only_category.description, 'The python language')
        self.assertEquals(only_category.slug, 'python')
Пример #54
0
def init_data(**kwargs):
    link=Link(text="dengmin's blog",href="http://www.iyouf.info")
    link.save()
    
    default_cate=Category(name=u'未分类',slug='default',desc=u'未分类')
    default_cate.save()
    
    entry=Entry(title='Hello World!',content='<b>Hello World, welcome to use youflog! thank you!</a>',tags='youflog')
    entry.allow_comment=True
    entry.slug='hello-world'
    entry.category=default_cate
    entry.author_id=1
    entry.save(True)
    
    comment=Comment(author='admin',email='*****@*****.**',weburl='http://iyouf.info',content=u'测试第一条评论')
    comment.content_object=entry
    comment.save()
Пример #55
0
    def test_delete_post(self):
        category = Category()
        category.name = 'python'
        category.description = 'The python language'
        category.save()

        # Create the tag
        tag = Tag()
        tag.name = 'python'
        tag.description = 'The Python programming language'
        tag.save()

        author = User.objects.create_user('testuser', '*****@*****.**', 'password')
        author.save()

        # site = Site()
        # site.name = 'nunfuxgvn.com'
        # site.domain = 'nunfuxgvn.com'
        # site.save()

        post = Post()
        post.title = 'First Post'
        post.test = 'My first post'
        post.slug = 'first-post'
        post.pub_date = timezone.now()
        post.author = author
        # post.site = site
        post.save()
        post.tags.add(tag)
        post.save()

        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 1)

        self.client.login(username='******', password='******')

        response = self.client.post('/admin/blog/post/1/delete/', {
            'post': 'yes'
        }, follow=True)
        self.assertEquals(response.status_code, 200)

        self.assertTrue('deleted successfully' in response.content)

        all_posts = Post.objects.all()
        self.assertEquals(len(all_posts), 0)
Пример #56
0
 def test_unique_slug_generate(self):
     # start by create one Category
     category = Category()
     category.name = "First"
     category.slug = "first"
     category.save()
     
     # create new posts
     post1 = Post(category=category, title="First post", content="Content", visable=True)
     post1.save()
     
     post2 = Post(category=category, title="First post", content="Content", visable=True)
     post2.save()
     
     # check posts then it's the same title
     self.assertEquals(post1.title, post2.title)
     # and different slug
     self.assertNotEquals(post1.slug, post2.slug)
Пример #57
0
    def test_creating_a_new_category_and_saving_it_to_the_database(self):
        # start by createing a new Category object
        category = Category()
        category.name = "First"
        category.slug = "first"

        # check we can save it to the database
        category.save()

        # now check we can find it in the database again
        all_category_in_database = Category.objects.all()
        self.assertEquals(len(all_category_in_database), 1)
        only_category_in_database = all_category_in_database[0]
        self.assertEquals(only_category_in_database, category)

        # and check that it's saved its two attributes: name and slug
        self.assertEquals(only_category_in_database.name, category.name)
        self.assertEquals(only_category_in_database.slug, category.slug)
Пример #58
0
    def test_delete_category(self):
        # Create the category
        category = Category()
        category.name = 'python'
        category.description = 'The Python programming language'
        category.save()

        # Log in
        self.client.login(username='******', password="******")

        # Delete the category
        response = self.client.post('/admin/blogengine/category/1/delete/', {
            'post': 'yes'
        }, follow=True)
        self.assertEquals(response.status_code, 200)

        # Check deleted successfully
        self.assertTrue('deleted successfully' in response.content)

        # Check category deleted
        all_categories = Category.objects.all()
        self.assertEquals(len(all_categories), 0)
Пример #59
0
    def test_create_category(self):
        # Create the category
        category = Category()

        # Add attributes
        category.name = 'python'
        category.description = 'The Python programming language'
        category.slug = 'python'

        # Save it
        category.save()

        # Check we can find it
        all_categories = Category.objects.all()
        self.assertEquals(len(all_categories), 1)
        only_category = all_categories[0]
        self.assertEquals(only_category, category)

        # Check attributes
        self.assertEquals(only_category.name, 'python')
        self.assertEquals(only_category.description, 'The Python programming language')
        self.assertEquals(only_category.slug, 'python')