def load_contents(cli, _type, size, fake):
"""Create v2 contents"""
nb_contents = size * 10
percent_contents_in_validation = 0.2
percent_contents_with_validator = 0.1
percent_contents_public = 0.6
percent_mini = 0.5
percent_medium = 0.3
percent_big = 0.2
nb_avg_containers_in_content = size
nb_avg_extracts_in_content = size
is_articles = _type == 'ARTICLE'
is_tutorials = _type == 'TUTORIAL'
is_opinion = _type == 'OPINION'
textual_type = u'article'
if is_tutorials:
textual_type = u'tutoriel'
elif is_opinion:
textual_type = u'billet'
# small introduction
cli.stdout.write(u'À créer: {:d} {}s'.format(nb_contents, textual_type),
ending='')
if is_tutorials:
cli.stdout.write(u' ({:g} petits, {:g} moyens et {:g} grands)'.format(
nb_contents * percent_mini, nb_contents * percent_medium,
nb_contents * percent_big))
else:
cli.stdout.write('')
cli.stdout.write(u' - {:g} en brouillon'.format(
nb_contents *
(1 - percent_contents_public - percent_contents_in_validation -
percent_contents_with_validator)))
if is_opinion:
cli.stdout.write(u' - {:g} publiés et aprouvés'.format(
nb_contents *
(percent_contents_in_validation + percent_contents_with_validator),
nb_contents * percent_contents_with_validator))
else:
cli.stdout.write(u' - {:g} en validation (dont {:g} réservés)'.format(
nb_contents *
(percent_contents_in_validation + percent_contents_with_validator),
nb_contents * percent_contents_with_validator))
cli.stdout.write(u' - {:g} publiés'.format(nb_contents *
percent_contents_public))
tps1 = time.time()
# create tables with 0=draft, 1=in validation, 2=reserved, 3=published
what_to_do = []
for i in range(nb_contents):
what = 0 # in draft
if i < percent_contents_public * nb_contents:
what = 3
elif i < (percent_contents_public +
percent_contents_with_validator) * nb_contents:
what = 2
elif i >= (1 - percent_contents_in_validation) * nb_contents:
what = 1
what_to_do.append(what)
# create a table with 0=mini, 1=medium, 2=big
content_sizes = []
for i in range(nb_contents):
sz = 0
if i < percent_big * nb_contents:
sz = 2
elif i >= (1 - percent_medium) * nb_contents:
sz = 1
content_sizes.append(sz)
# shuffle the whole thing
random.shuffle(what_to_do)
random.shuffle(content_sizes)
# checks that everything is ok
users = list(Profile.objects.all())
nb_users = len(users)
sub_categories = list(SubCategory.objects.all())
nb_sub_categories = len(sub_categories)
if nb_users == 0:
cli.stdout.write(
u"Il n'y a aucun membre actuellement. "
u'Vous devez rajouter les membre dans vos fixtures (member)')
return
if nb_sub_categories == 0:
cli.stdout.write(
u"Il n'y a aucune catégories actuellement."
u'Vous devez rajouter les catégories dans vos fixtures (category_content)'
)
return
perms = list(
Permission.objects.filter(codename__startswith='change_').all())
staffs = list(User.objects.filter(groups__permissions__in=perms).all())
nb_staffs = len(staffs)
if nb_staffs == 0:
cli.stdout.write(
u"Il n'y a aucun staff actuellement."
u'Vous devez rajouter les staffs dans vos fixtures (staff)')
return
licenses = list(Licence.objects.all())
nb_licenses = len(licenses)
if nb_licenses == 0:
cli.stdout.write(
u"Il n'y a aucune licence actuellement."
u'Vous devez rajouter les licences dans vos fixtures (category_content)'
)
return
# create and so all:
for i in range(nb_contents):
sys.stdout.write('Création {} : {}/{} \r'.format(
textual_type, i + 1, nb_contents))
current_size = content_sizes[i]
to_do = what_to_do[i]
# creation:
content = PublishableContentFactory(type=_type,
title=fake.text(max_nb_chars=60),
description=fake.sentence(
nb_words=15,
variable_nb_words=True))
versioned = content.load_version()
if current_size == 0 or is_articles or is_opinion:
for j in range(random.randint(1, nb_avg_extracts_in_content * 2)):
ExtractFactory(container=versioned,
title=fake.text(max_nb_chars=60),
light=False)
else:
for j in range(random.randint(1,
nb_avg_containers_in_content * 2)):
container = ContainerFactory(parent=versioned,
title=fake.text(max_nb_chars=60))
if current_size == 1: # medium size tutorial
for k in range(
random.randint(1, nb_avg_extracts_in_content * 2)):
ExtractFactory(container=container,
title=fake.text(max_nb_chars=60),
light=False)
else: # big-size tutorial
for k in range(
random.randint(1,
nb_avg_containers_in_content * 2)):
subcontainer = ContainerFactory(
parent=container, title=fake.text(max_nb_chars=60))
for l in range(
random.randint(1, nb_avg_extracts_in_content *
2)):
ExtractFactory(container=subcontainer,
title=fake.text(max_nb_chars=60),
light=False)
# add some informations:
author = users[random.randint(0, nb_users - 1)].user
content.authors.add(author)
UserGalleryFactory(gallery=content.gallery, mode='W', user=author)
content.licence = licenses[random.randint(0, nb_licenses - 1)]
content.sha_draft = versioned.sha_draft
content.subcategory.add(sub_categories[random.randint(
0, nb_sub_categories - 1)])
content.save()
# then, validation if needed:
if to_do > 0:
if is_opinion:
if to_do >= 1:
content.sha_public = content.sha_draft
if to_do == 1:
content.sha_picked = content.sha_draft
published = publish_content(content, versioned)
content.public_version = published
content.save()
else:
valid = CValidation(content=content,
version=content.sha_draft,
date_proposition=datetime.now(),
status='PENDING')
valid.comment_validator = fake.text(max_nb_chars=200)
content.sha_validation = content.sha_draft
if to_do > 1: # reserve validation
valid.date_reserve = datetime.now()
valid.validator = staffs[random.randint(0, nb_staffs - 1)]
valid.status = 'PENDING_V'
if to_do > 2: # publish content
valid.comment_validator = fake.text(max_nb_chars=80)
valid.status = 'ACCEPT'
valid.date_validation = datetime.now()
content.sha_public = content.sha_draft
published = publish_content(content, versioned)
content.public_version = published
valid.save()
content.save()
sys.stdout.flush()
tps2 = time.time()
cli.stdout.write(u'\nFait en {:.3f} sec'.format(tps2 - tps1))
