def generate_category(self, categories, amount_posts=5):
name = f'{self.fake.text(20)[:-1]} {str(time.time()).replace(".", "")[-5:]}'
category = Category(
name=name,
enabled=True,
text1=self.fake.paragraph(20),
text2=self.fake.paragraph(20),
h1=self.fake.text(20)[:-1],
title=self.fake.paragraph(1),
slug=translite_slug(name),
)
if categories:
category.parent = random.choice(categories)
category.save()
category.image_menu.save(
'filename.jpg',
open(
os.path.join(settings.BASE_DIR, 'faker/cat_menu',
random.choice(self.cat_menu)), 'rb'))
category.image.save(
'filename.jpg',
open(
os.path.join(settings.BASE_DIR, 'faker/cat_image',
random.choice(self.cat_image)), 'rb'))
category.image_main.save(
'filename.jpg',
open(
os.path.join(settings.BASE_DIR, 'faker/cat_main_image',
random.choice(self.cat_main_image)), 'rb'))
for i in range(amount_posts):
self.generate_post(category)
def add_category(request):
if request.method == 'POST':
category = Category(category_name=request.POST['category_name'],
status=request.POST['status'])
category.save()
return redirect('/category/manage_category')
else:
return render(request, 'category/add_category.html')
def import_categories(self):
self.stdout.write(self.style.MIGRATE_LABEL("Importing Categories"))
progress = ProgressBar(widgets=[Percentage(), Bar()],
maxval=len(self.categories) * 2).start()
for i, category in enumerate(self.categories):
objCategory = Category(id=category.get('id'),
name=category.get('name'),
slug=category.get('slug'))
objCategory.save()
progress.update(i)
for i, category in enumerate(self.categories):
objCategory = Category.objects.get(pk=category.get('id'))
objCategory.parent = Category.objects.get(slug=category.get(
'parent')) if category.get('parent') else None
objCategory.save()
progress.update(i)
progress.finish()
def setUp(self):
self.tag_a = Tag(name='a')
self.tag_b = Tag(name='b')
self.tag_c = Tag(name='c')
self.tag_d = Tag(name='d')
self.tag_e = Tag(name='e')
self.tag_a.save()
self.tag_b.save()
self.tag_c.save()
self.tag_d.save()
self.tag_e.save()
self.category_1 = Category(name='cat 1')
self.category_2 = Category(name='cat 2')
self.category_3 = Category(name='cat 3')
self.category_1.save()
self.category_2.save()
self.category_3.save()
self.post_1 = Post(pk=1, title='Markdown Syntax', slug='markdown-syntax',
content="Here's some markdown syntax.",
published=True)
self.post_2 = Post(pk=2, title='First Post', slug='first-post',
content='This is my first post.',
published=True)
self.post_3 = Post(pk=3, title='Django Unit Testing', slug='django-unit-testing',
content="To test django with unit testing, do this...",
published=True)
self.post_4 = Post(pk=4, title='Depressed', slug='depressed',
content="I'm depressed...",
published=False)
# this determines time_cr
self.post_3.save()
self.post_1.save()
self.post_2.save()
self.post_4.save()
self.post_1.tags.add(self.tag_a)
self.post_1.tags.add(self.tag_b)
self.post_1.tags.add(self.tag_c)
self.post_1.categories.add(self.category_1)
self.post_1.categories.add(self.category_2)
self.post_2.tags.add(self.tag_b)
self.post_2.tags.add(self.tag_d)
self.post_2.tags.add(self.tag_e)
self.post_2.categories.add(self.category_2)
self.post_2.categories.add(self.category_3)
self.post_3.tags.add(self.tag_b)
self.post_3.tags.add(self.tag_d)
self.post_3.tags.add(self.tag_e)
self.post_4.categories.add(self.category_3)
# this determines time_lu
self.post_4.save()
self.post_1.save()
self.post_3.save()
self.post_2.save()
self.client = Client()
class view_post_tests(TestCase):
def setUp(self):
self.tag_a = Tag(name='a')
self.tag_b = Tag(name='b')
self.tag_c = Tag(name='c')
self.tag_d = Tag(name='d')
self.tag_e = Tag(name='e')
self.tag_a.save()
self.tag_b.save()
self.tag_c.save()
self.tag_d.save()
self.tag_e.save()
self.category_1 = Category(name='cat 1')
self.category_2 = Category(name='cat 2')
self.category_3 = Category(name='cat 3')
self.category_1.save()
self.category_2.save()
self.category_3.save()
self.post_1 = Post(pk=1, title='Markdown Syntax', slug='markdown-syntax',
content="Here's some markdown syntax.",
published=True)
self.post_2 = Post(pk=2, title='First Post', slug='first-post',
content='This is my first post.',
published=True)
self.post_3 = Post(pk=3, title='Django Unit Testing', slug='django-unit-testing',
content="To test django with unit testing, do this...",
published=True)
self.post_4 = Post(pk=4, title='Depressed', slug='depressed',
content="I'm depressed...",
published=False)
# this determines time_cr
self.post_3.save()
self.post_1.save()
self.post_2.save()
self.post_4.save()
self.post_1.tags.add(self.tag_a)
self.post_1.tags.add(self.tag_b)
self.post_1.tags.add(self.tag_c)
self.post_1.categories.add(self.category_1)
self.post_1.categories.add(self.category_2)
self.post_2.tags.add(self.tag_b)
self.post_2.tags.add(self.tag_d)
self.post_2.tags.add(self.tag_e)
self.post_2.categories.add(self.category_2)
self.post_2.categories.add(self.category_3)
self.post_3.tags.add(self.tag_b)
self.post_3.tags.add(self.tag_d)
self.post_3.tags.add(self.tag_e)
self.post_4.categories.add(self.category_3)
# this determines time_lu
self.post_4.save()
self.post_1.save()
self.post_3.save()
self.post_2.save()
self.client = Client()
def test_view_single_posts_by_id(self):
# public post
response = self.client.get('/posts/2/')
self.assertIn('This is my first post', response.content)
# private post
response = self.client.get('/posts/4/')
self.assertIn("The post you're looking for does not exist. ", response.content)
# non-existent post
response = self.client.get('/posts/100/')
self.assertIn("The post you're looking for does not exist. ", response.content)
def test_view_single_posts_by_slug(self):
# public post
response = self.client.get('/posts/first-post/')
self.assertIn('This is my first post', response.content)
# private post
response = self.client.get('/posts/depressed/')
self.assertIn("The post you're looking for does not exist. ", response.content)
# non-existent post
response = self.client.get('/posts/not-exist/')
self.assertIn("The post you're looking for does not exist. ", response.content)
def test_view_single_posts_by_date_slug(self):
pass
# # public post
# response = self.client.get('/posts/2014/04/20/first-post/')
# self.assertIn('This is my first post', response.content)
# # private post
# response = self.client.get('/posts/????/')
# self.assertIn("The post you're looking for does not exist. ", response.content)
# # non-existent post: slug does not exist
# response = self.client.get('/posts/????/')
# self.assertIn("The post you're looking for does not exist. ", response.content)
# # non-existent post: date/slug mismatch
# response = self.client.get('/posts/????/')
# self.assertIn("The post you're looking for does not exist. ", response.content)
def test_view_all_posts(self):
'''
private posts should not show
public posts are listed in chronolgical order of creation time
'''
# redirects properly
response = self.client.get('/posts/')
self.assertRedirects(response, '/')
# posts appear in correct order
response = self.client.get('/')
post_1_position = response.content.find("Here's some markdown syntax.")
post_2_position = response.content.find('This is my first post.')
post_3_position = response.content.find("To test django with unit testing")
self.assertGreater(post_1_position, 0)
self.assertGreater(post_2_position, 0)
self.assertGreater(post_3_position, 0)
self.assertLess(post_2_position, post_1_position)
self.assertLess(post_1_position, post_3_position)
# private post doesn't appear
post_4_position = response.content.find("I'm depressed")
self.assertEqual(post_4_position, -1)
def test_get_absolute_url(self):
# time below is already Apr 30 in UTC time (local time is Central Time, UTC-6/5s)
self.post_2.time_cr = datetime(2014, 4, 29, 20, 13, 19, 0, get_default_timezone())
the_absolute_url = self.post_2.get_absolute_url()
# make sure permalink doesn't roll over to Apr 30
self.assertEqual(the_absolute_url, '/posts/2014/04/29/first-post/')
def post_view(request):
cache_key = settings.RANDOM_POSTS_KEY
cache_count = redis_con.scard(cache_key)
if request.method == 'GET':
nickname = request.GET.get("nickname", "").strip()
category_name = request.GET.get("category", "").strip()
# save cache
if cache_count <= 0:
print 'caching...'
db_posts = Post.objects.filter(
deleted=False, created_at__gte=utils.min_created_at()).all()
for p in db_posts:
redis_con.sadd(cache_key, p.pk)
redis_con.expire(cache_key, settings.RANDOM_POSTS_EXPIRE)
post_id = redis_con.srandmember(cache_key)
# there is no any data
if not post_id:
return JsonResponse(dict(success=True, data=None))
post = Post.objects.filter(id=post_id).get()
read_count = post.read_count + 1
post.read_count = F("read_count") + 1
post.save()
return JsonResponse(
dict(success=True,
data={
"nickname": post.nickname,
"content": post.content,
"category": post.category.name,
"read_count": read_count,
"created_at":
post.created_at.strftime('%Y-%m-%d %H:%M:%S'),
}))
elif request.method == 'POST':
nickname = request.POST.get('nickname',
settings.DEFAULT_NICKNAME).strip()
category_name = request.POST.get(
'category', settings.DEFAULT_CATEGORY_NAME).strip()
content = request.POST.get('content', '').strip()
img_url = request.POST.get('img_url', '').strip()
if not nickname or not category_name or not content:
return JsonResponse(dict(success=False, msg=u'信息不完整'))
if len(nickname) > settings.NICKNAME_MAX_LENGTH:
return JsonResponse(
dict(success=False,
msg=u'用户名最长为 %d 个字符' % settings.NICKNAME_MAX_LENGTH))
if len(category_name) > settings.CATEGORY_MAX_LENGTH:
return JsonResponse(
dict(success=False,
msg=u'类别名最长为 %d 个字符' % settings.CATEGORY_MAX_LENGTH))
if len(content) > settings.POST_MAX_LENGTH:
return JsonResponse(
dict(success=False,
msg=u'post 最多 %d 个字符' % settings.POST_MAX_LENGTH))
category_exist = Category.objects.filter(name=category_name).exists()
if category_exist:
category = Category.objects.filter(name=category_name).get()
category.post_count = F('post_count') + 1
else:
category = Category(name=category_name, post_count=1)
category.save()
post = Post(nickname=nickname,
content=content,
img_url=img_url,
category=category)
post.save()
# save to cache
if cache_count > 0:
redis_con.sadd(cache_key, post.pk)
return JsonResponse(dict(success=True))
def handle(self, *args, **options):
self.stdout.write('Importing WordPress posts')
wp_table_prefix = options['wp-table-prefix']
utc = pytz.utc
my_conv = {
FIELD_TYPE.LONG: int,
FIELD_TYPE.INT24: int,
FIELD_TYPE.SHORT: int,
FIELD_TYPE.TINY: int,
FIELD_TYPE.LONGLONG: int,
FIELD_TYPE.DATETIME: str,
}
try:
db = MySQLdb.connect(host=options['host'],
user=options['user'],
passwd=options['passwd'],
db=options['db'],
conv=my_conv,
use_unicode=True,
charset='utf8mb4')
except Exception as e:
self.stderr.write('Unable to connect to database')
self.stderr.write(str(e))
return
cur = db.cursor()
cur.execute('SET NAMES utf8mb4')
cur.execute("SET CHARACTER SET utf8mb4")
cur.execute("SET character_set_connection=utf8mb4")
wpTagMap = dict()
wpCategoryMap = dict()
posts = list()
# GET TAGS
self.stdout.write('Migrating Tags')
cur.execute(f"""SELECT COUNT(*)
FROM {wp_table_prefix}_terms AS terms
INNER JOIN {wp_table_prefix}_term_taxonomy AS taxonomy
ON terms.term_id = taxonomy.term_id
INNER JOIN {wp_table_prefix}_term_relationships AS relationships
ON relationships.`term_taxonomy_id` = taxonomy.`term_taxonomy_id`
INNER JOIN {wp_table_prefix}_posts AS posts
ON relationships.`object_id` = posts.`ID`
WHERE taxonomy.taxonomy = 'post_tag'
AND posts.post_type = 'post'""")
row = cur.fetchone()
self.stdout.write(f"{row[0]} tags to migrate")
cur.execute(f"""SELECT
terms.term_id,
terms.name,
terms.slug,
posts.ID
FROM {wp_table_prefix}_terms AS terms
INNER JOIN {wp_table_prefix}_term_taxonomy AS taxonomy
ON terms.term_id = taxonomy.term_id
INNER JOIN {wp_table_prefix}_term_relationships AS relationships
ON relationships.`term_taxonomy_id` = taxonomy.`term_taxonomy_id`
INNER JOIN {wp_table_prefix}_posts AS posts
ON relationships.`object_id` = posts.`ID`
WHERE taxonomy.taxonomy = 'post_tag'
AND posts.post_type = 'post'""")
rows = cur.fetchall()
savedTags = dict()
for row in rows:
tag = Tag(name=row[1], slug=row[2])
if row[0] in savedTags:
tag = savedTags[row[0]]
else:
tag.save()
savedTags[row[0]] = tag
if row[3] not in wpTagMap:
wpTagMap[row[3]] = list()
wpTagMap[row[3]].append(tag)
self.stdout.write(f"{len(wpTagMap)} tags migrated")
# GET CATEGORIES
self.stdout.write('Migrating Categories')
cur.execute(f"""SELECT COUNT(*)
FROM {wp_table_prefix}_terms AS terms
INNER JOIN {wp_table_prefix}_term_taxonomy AS taxonomy
ON terms.term_id = taxonomy.term_id
INNER JOIN {wp_table_prefix}_term_relationships AS relationships
ON relationships.`term_taxonomy_id` = taxonomy.`term_taxonomy_id`
INNER JOIN {wp_table_prefix}_posts AS posts
ON relationships.`object_id` = posts.`ID`
WHERE taxonomy.taxonomy = 'category'
AND posts.post_type = 'post'""")
row = cur.fetchone()
self.stdout.write(f"{row[0]} categories to migrate")
cur.execute(f"""SELECT
terms.term_id,
terms.name,
terms.slug,
posts.ID
FROM {wp_table_prefix}_terms AS terms
INNER JOIN {wp_table_prefix}_term_taxonomy AS taxonomy
ON terms.term_id = taxonomy.term_id
INNER JOIN {wp_table_prefix}_term_relationships AS relationships
ON relationships.`term_taxonomy_id` = taxonomy.`term_taxonomy_id`
INNER JOIN {wp_table_prefix}_posts AS posts
ON relationships.`object_id` = posts.`ID`
WHERE taxonomy.taxonomy = 'category'
AND posts.post_type = 'post'""")
rows = cur.fetchall()
savedCategories = dict()
for row in rows:
category = Category(name=row[1], slug=row[2])
if row[0] in savedCategories:
category = savedCategories[row[0]]
else:
category.save()
savedCategories[row[0]] = category
wpCategoryMap[row[3]] = category
self.stdout.write(f"{len(wpCategoryMap)} categories migrated")
# POSTS
self.stdout.write('Migrating Posts')
cur.execute(
f"SELECT COUNT(*) FROM {wp_table_prefix}_posts WHERE post_type = 'post'"
)
row = cur.fetchone()
self.stdout.write(f"{row[0]} posts to migrate")
# we need a default Author
author = Profile.objects.all()[:1].get()
self.stdout.write(f'Default author is {author.name}')
cur.execute(
f"SELECT ID, post_date_gmt, post_content, post_title, post_excerpt, post_status, post_name, post_modified_gmt FROM {wp_table_prefix}_posts WHERE post_type = 'post'"
)
rows = cur.fetchall()
for row in rows:
if not row[6]:
self.stdout.write(f'{row[3]} has no slug. Skipping.')
continue
published = row[1]
if published == '0000-00-00 00:00:00':
published = None
else:
published = utc.localize(datetime.datetime.strptime(
published, "%Y-%m-%d %H:%M:%S"),
is_dst=None)
updated = row[7]
if updated == '0000-00-00 00:00:00':
updated = None
else:
updated = utc.localize(datetime.datetime.strptime(
updated, "%Y-%m-%d %H:%M:%S"),
is_dst=None)
post = Post(published=published,
content=row[2],
title=row[3],
summary=row[4],
is_published=row[5] == 'publish',
slug=row[6],
updated=updated,
author=author)
try:
post.save()
except Exception as e:
self.stderr.write(str(e))
self.stderr.write(post.name)
raise e
posts.append({'post': post, 'wpId': row[0]})
self.stdout.write(f"{len(posts)} posts migrated")
# Attaching Tags and Categories
self.stdout.write("Attaching tags and categories")
for post in posts:
if post['wpId'] in wpCategoryMap:
post['post'].category = wpCategoryMap[post['wpId']]
else:
self.stdout.write(f"No category for {post['post'].title}")
if post['wpId'] in wpTagMap:
post['post'].tags.set(wpTagMap[post['wpId']])
else:
self.stdout.write(f"No tags for {post['post'].title}")
post['post'].save()
self.stdout.write("Tags and categories attached")
cur.close()
db.close()
self.stdout.write('WordPress posts imported')
return
def create_test_category(self):
"""Create a test category."""
self.category = Category(name='TestCategory', )
self.category.save()
class PostsViewsTestCase(TestCase):
"""Test case for Posts views."""
def create_admin_user(self):
"""Create a test admin user."""
self.admin_user = User.objects.create(
username='******',
email='admin@localhost',
)
def create_test_category(self):
"""Create a test category."""
self.category = Category(name='TestCategory', )
self.category.save()
def create_test_post(self):
"""Create a test post for use with other tests."""
self.post = Post(
title='This is my title',
author=self.admin_user,
content='Some content',
published=timezone.now(),
is_published=True,
slugged_title='this-is-my-title',
)
self.post.save()
self.post.categories.add(self.category)
self.post.save()
def setUp(self):
""" setup """
self.create_admin_user()
self.create_test_category()
PageElement.objects.create(name='Tag Line', text='some text')
PageElement.objects.create(name='Footer Text', text='some text')
self.create_test_post()
def test_post_get(self):
"""Test GET /post/{}"""
client = Client()
response = client.get('/post/{}/'.format(self.post.slugged_title))
self.assertEqual(response.status_code, 200)
self.assertTrue(self.post.title in response.content)
def test_post_filtered(self):
"""Test GET /post/filter/?category_name={}"""
client = Client()
for category in self.post.categories.all():
url = '/post/filter/?category_name={}'.format(category.name)
response = client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTrue(self.post.title in response.content)
def test_post_is_published(self):
"""Test that is_published is being used as it should."""
# self.create_test_post()
post = Post.objects.get(title='This is my title')
client = Client()
response = client.get('/', follow=True)
self.assertTrue('This is my title' in response.content)
post.is_published = False
post.save()
response = client.get('/', follow=True)
self.assertFalse('This is my title' in response.content)
def create_category():
faker = Faker()
for _ in range(10):
name = faker.word()
category = Category(name=name)
category.save()
