class Command(BaseCommand):
sd = SampleDataHelper(seed=12345678901)
@transaction.atomic
def handle(self, *args, **options):
self.users = [User.objects.get(is_superuser=True)]
# create users
if BASE_USERS:
for username, full_name, email in BASE_USERS:
self.users.append(self.create_user(username=username, full_name=full_name, email=email))
else:
for x in range(NUM_USERS):
self.users.append(self.create_user(counter=x))
def create_user(self, counter=None, username=None, full_name=None, email=None):
counter = counter or self.sd.int()
username = username or "user{0}".format(counter)
full_name = full_name or "{} {}".format(self.sd.name('es'), self.sd.surname('es', number=1))
email = email or "user{0}@tweets2cash.demo".format(counter)
user = User.objects.create(username=username,
full_name=full_name,
email=email,
token=self.sd.hex_chars(10,10)))
user.set_password('123123')
user.save()
return user
class Command(BaseCommand):
args = ''
help = 'Example data generator'
sd = SampleDataHelper(seed=12345678901)
#this function populate's the user and activity_period table in databse
def generate_mymodel_data(self, instances):
choices = [
"America/Los_Angeles", "Belgium/Brussels", "Cambodia/Phnom Penh",
"Denmark/Copenhagen", "Fiji/Suva", "India/Kolkata", "India/Ranchi",
"China/Wuhan", "Russia/Moscow"
]
user_instance = User()
for x in range(1, instances):
instance = User.objects.create(
uid=self.sd.hex_chars(min_chars=9, max_chars=9),
real_name=self.sd.fullname(locale=None, as_list=False),
tz=self.sd.choice(choices),
)
for outer_loop in range(1, instances):
for inner_loop in range(3):
activeity_period = Activity_Periods.objects.create(
start_time=self.sd.datetime(begin=-1440, end=1440),
end_time=self.sd.datetime(begin=-1440, end=1440),
user=User.objects.get(id=outer_loop))
#this function is responsible for running the above function and this fun get's executed while running
#the <python mange.py dummydata> dummydata is this module name
def handle(self, *args, **options):
print("Generating MyModel data")
self.generate_mymodel_data(51)
class Register(object):
fields = {}
ignored_fields = []
_instance = None
sd = SampleDataHelper()
def __new__(cls, *args, **kwargs):
if not cls._instance:
cls._instance = super(Register, cls).__new__(cls, *args, **kwargs)
return cls._instance
def register(self, field_class, handler_class):
self.fields[field_class] = handler_class
def ignore(self, field_class):
self.ignored_fields.append(field_class)
def get_handler(self, field_instance):
if field_instance.__class__ in self.ignored_fields:
return None
handler = self.fields.get(field_instance.__class__, None)
if handler:
return handler(self.sd, field_instance)
return None
class Command(BaseCommand):
sd = SampleDataHelper(seed=12345678901)
#@transaction.atomic
def handle(self, *args, **options):
# Prevent events emission when sample data is running
disconnect_events_signals()
self.users = [User.objects.get(is_superuser=True)]
# create users
if BASE_USERS:
for username, full_name, email in BASE_USERS:
self.users.append(
self.create_user(username=username,
full_name=full_name,
email=email))
else:
for x in range(NUM_USERS):
self.users.append(self.create_user(counter=x))
# create project
projects_range = range(NUM_PROJECTS + NUM_EMPTY_PROJECTS +
NUM_BLOCKED_PROJECTS)
empty_projects_range = range(NUM_PROJECTS,
NUM_PROJECTS + NUM_EMPTY_PROJECTS)
blocked_projects_range = range(
NUM_PROJECTS + NUM_EMPTY_PROJECTS,
NUM_PROJECTS + NUM_EMPTY_PROJECTS + NUM_BLOCKED_PROJECTS)
for x in projects_range:
project = self.create_project(
x,
is_private=x in [2, 4],
blocked_code=BLOCKED_BY_STAFF
if x in (blocked_projects_range) else None)
# added memberships
computable_project_roles = set()
for user in self.users:
if user == project.owner:
continue
role = self.sd.db_object_from_queryset(project.roles.all())
Membership.objects.create(email=user.email,
project=project,
role=role,
is_admin=self.sd.boolean(),
user=user)
if role.computable:
computable_project_roles.add(role)
# Delete a random member so all the projects doesn't have the same team
Membership.objects.filter(project=project).exclude(
user=project.owner).order_by("?").first().delete()
# added invitations
for i in range(NUM_INVITATIONS):
role = self.sd.db_object_from_queryset(project.roles.all())
Membership.objects.create(email=self.sd.email(),
project=project,
role=role,
is_admin=self.sd.boolean(),
token=self.sd.hex_chars(10, 10))
if role.computable:
computable_project_roles.add(role)
# If the project isn't empty
if x not in empty_projects_range:
# added custom attributes
names = set([self.sd.words(1, 3) for i in range(1, 6)])
for name in names:
EpicCustomAttribute.objects.create(
name=name,
description=self.sd.words(3, 12),
type=self.sd.choice(TYPES_CHOICES)[0],
project=project,
order=i)
names = set([self.sd.words(1, 3) for i in range(1, 6)])
for name in names:
UserStoryCustomAttribute.objects.create(
name=name,
description=self.sd.words(3, 12),
type=self.sd.choice(TYPES_CHOICES)[0],
project=project,
order=i)
names = set([self.sd.words(1, 3) for i in range(1, 6)])
for name in names:
TaskCustomAttribute.objects.create(
name=name,
description=self.sd.words(3, 12),
type=self.sd.choice(TYPES_CHOICES)[0],
project=project,
order=i)
names = set([self.sd.words(1, 3) for i in range(1, 6)])
for name in names:
IssueCustomAttribute.objects.create(
name=name,
description=self.sd.words(3, 12),
type=self.sd.choice(TYPES_CHOICES)[0],
project=project,
order=i)
start_date = now() - datetime.timedelta(55)
# create milestones
for y in range(self.sd.int(*NUM_MILESTONES)):
end_date = start_date + datetime.timedelta(15)
milestone = self.create_milestone(project, start_date,
end_date)
# create uss asociated to milestones
for z in range(self.sd.int(*NUM_USS)):
us = self.create_us(project, milestone,
computable_project_roles)
# create tasks
rang = NUM_TASKS_FINISHED if start_date <= now(
) and end_date <= now() else NUM_TASKS
for w in range(self.sd.int(*rang)):
if start_date <= now() and end_date <= now():
task = self.create_task(project,
milestone,
us,
start_date,
end_date,
closed=True)
elif start_date <= now() and end_date >= now():
task = self.create_task(
project, milestone, us, start_date, now())
else:
# No task on not initiated milestones
pass
start_date = end_date
# created unassociated uss.
for y in range(self.sd.int(*NUM_USS_BACK)):
us = self.create_us(project, None,
computable_project_roles)
# create bugs.
for y in range(self.sd.int(*NUM_ISSUES)):
bug = self.create_bug(project)
# create a wiki pages and wiki links
wiki_page = self.create_wiki_page(project, "home")
for y in range(self.sd.int(*NUM_WIKI_LINKS)):
wiki_link = self.create_wiki_link(project)
if self.sd.boolean():
self.create_wiki_page(project, wiki_link.href)
# create epics
for y in range(self.sd.int(*NUM_EPICS)):
epic = self.create_epic(project)
project.refresh_from_db()
# Set color for some tags:
for tag in project.tags_colors:
if self.sd.boolean():
tag[1] = self.generate_color(tag[0])
# Set a value to total_story_points to show the deadline in the backlog
project_stats = get_stats_for_project(project)
defined_points = project_stats["defined_points"]
project.total_story_points = int(defined_points *
self.sd.int(5, 12) / 10)
project.save()
self.create_likes(project)
def create_attachment(self, obj, order):
attached_file = self.sd.file_from_directory(*ATTACHMENT_SAMPLE_DATA)
membership = self.sd.db_object_from_queryset(
obj.project.memberships.filter(user__isnull=False))
attachment = Attachment.objects.create(
project=obj.project,
name=path.basename(attached_file.name),
size=attached_file.size,
content_object=obj,
order=order,
owner=membership.user,
is_deprecated=self.sd.boolean(),
description=self.sd.words(3, 12),
attached_file=attached_file)
return attachment
def create_wiki_link(self, project, title=None):
wiki_link = WikiLink.objects.create(project=project,
title=title or self.sd.words(1, 3))
return wiki_link
def create_wiki_page(self, project, slug):
wiki_page = WikiPage.objects.create(
project=project,
slug=slug,
content=self.sd.paragraphs(3, 15),
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user)
for i in range(self.sd.int(*NUM_ATTACHMENTS)):
attachment = self.create_attachment(wiki_page, i + 1)
take_snapshot(wiki_page, user=wiki_page.owner)
# Add history entry
wiki_page.content = self.sd.paragraphs(3, 15)
wiki_page.save()
take_snapshot(wiki_page,
comment=self.sd.paragraph(),
user=wiki_page.owner)
return wiki_page
def get_custom_attributes_value(self, type):
if type == TEXT_TYPE:
return self.sd.words(1, 12)
if type == MULTILINE_TYPE:
return self.sd.paragraphs(2, 4)
if type == DATE_TYPE:
return self.sd.future_date(min_distance=0, max_distance=365)
if type == URL_TYPE:
return self.sd.choice(URL_CHOICES)
return None
def create_bug(self, project):
bug = Issue.objects.create(
project=project,
subject=self.sd.choice(SUBJECT_CHOICES),
description=self.sd.paragraph(),
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
severity=self.sd.db_object_from_queryset(
Severity.objects.filter(project=project)),
status=self.sd.db_object_from_queryset(
IssueStatus.objects.filter(project=project)),
priority=self.sd.db_object_from_queryset(
Priority.objects.filter(project=project)),
type=self.sd.db_object_from_queryset(
IssueType.objects.filter(project=project)),
tags=self.sd.words(1, 10).split(" "))
bug.save()
custom_attributes_values = {
str(ca.id): self.get_custom_attributes_value(ca.type)
for ca in project.issuecustomattributes.all().order_by('id')
if self.sd.boolean()
}
if custom_attributes_values:
bug.custom_attributes_values.attributes_values = custom_attributes_values
bug.custom_attributes_values.save()
for i in range(self.sd.int(*NUM_ATTACHMENTS)):
attachment = self.create_attachment(bug, i + 1)
if bug.status.order != 1:
bug.assigned_to = self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user
bug.save()
take_snapshot(bug, user=bug.owner)
# Add history entry
bug.status = self.sd.db_object_from_queryset(
IssueStatus.objects.filter(project=project))
bug.save()
take_snapshot(bug, comment=self.sd.paragraph(), user=bug.owner)
self.create_votes(bug)
self.create_watchers(bug)
return bug
def create_task(self,
project,
milestone,
us,
min_date,
max_date,
closed=False):
task = Task(subject=self.sd.choice(SUBJECT_CHOICES),
description=self.sd.paragraph(),
project=project,
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
milestone=milestone,
user_story=us,
finished_date=None,
assigned_to=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
tags=self.sd.words(1, 10).split(" "))
if closed:
task.status = project.task_statuses.get(order=4)
else:
task.status = self.sd.db_object_from_queryset(
project.task_statuses.all())
if task.status.is_closed:
task.finished_date = self.sd.datetime_between(min_date, max_date)
task.save()
custom_attributes_values = {
str(ca.id): self.get_custom_attributes_value(ca.type)
for ca in project.taskcustomattributes.all().order_by('id')
if self.sd.boolean()
}
if custom_attributes_values:
task.custom_attributes_values.attributes_values = custom_attributes_values
task.custom_attributes_values.save()
for i in range(self.sd.int(*NUM_ATTACHMENTS)):
attachment = self.create_attachment(task, i + 1)
take_snapshot(task, user=task.owner)
# Add history entry
task.status = self.sd.db_object_from_queryset(
project.task_statuses.all())
task.save()
take_snapshot(task, comment=self.sd.paragraph(), user=task.owner)
self.create_votes(task)
self.create_watchers(task)
return task
def create_us(self, project, milestone=None, computable_project_roles=[]):
us = UserStory.objects.create(
subject=self.sd.choice(SUBJECT_CHOICES),
project=project,
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
description=self.sd.paragraph(),
milestone=milestone,
status=self.sd.db_object_from_queryset(
project.us_statuses.filter(is_closed=False)),
tags=self.sd.words(1, 3).split(" "))
for role_points in us.role_points.filter(
role__in=computable_project_roles):
if milestone:
role_points.points = self.sd.db_object_from_queryset(
us.project.points.exclude(value=None))
else:
role_points.points = self.sd.db_object_from_queryset(
us.project.points.all())
role_points.save()
us.save()
custom_attributes_values = {
str(ca.id): self.get_custom_attributes_value(ca.type)
for ca in project.userstorycustomattributes.all().order_by('id')
if self.sd.boolean()
}
if custom_attributes_values:
us.custom_attributes_values.attributes_values = custom_attributes_values
us.custom_attributes_values.save()
for i in range(self.sd.int(*NUM_ATTACHMENTS)):
attachment = self.create_attachment(us, i + 1)
if self.sd.choice([True, True, False, True, True]):
us.assigned_to = self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user
us.save()
take_snapshot(us, user=us.owner)
# Add history entry
us.status = self.sd.db_object_from_queryset(
project.us_statuses.filter(is_closed=False))
us.save()
take_snapshot(us, comment=self.sd.paragraph(), user=us.owner)
self.create_votes(us)
self.create_watchers(us)
return us
def create_milestone(self, project, start_date, end_date):
milestone = Milestone.objects.create(
project=project,
name='Sprint {0}-{1}-{2}'.format(start_date.year, start_date.month,
start_date.day),
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
created_date=start_date,
modified_date=start_date,
estimated_start=start_date,
estimated_finish=end_date,
order=10)
take_snapshot(milestone, user=milestone.owner)
return milestone
def create_epic(self, project):
epic = Epic.objects.create(
subject=self.sd.choice(SUBJECT_CHOICES),
project=project,
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
description=self.sd.paragraph(),
status=self.sd.db_object_from_queryset(
project.epic_statuses.filter(is_closed=False)),
tags=self.sd.words(1, 3).split(" "))
epic.save()
custom_attributes_values = {
str(ca.id): self.get_custom_attributes_value(ca.type)
for ca in project.epiccustomattributes.all().order_by("id")
if self.sd.boolean()
}
if custom_attributes_values:
epic.custom_attributes_values.attributes_values = custom_attributes_values
epic.custom_attributes_values.save()
for i in range(self.sd.int(*NUM_ATTACHMENTS)):
attachment = self.create_attachment(epic, i + 1)
if self.sd.choice([True, True, False, True, True]):
epic.assigned_to = self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user
epic.save()
take_snapshot(epic, user=epic.owner)
# Add history entry
epic.status = self.sd.db_object_from_queryset(
project.epic_statuses.filter(is_closed=False))
epic.save()
take_snapshot(epic, comment=self.sd.paragraph(), user=epic.owner)
self.create_votes(epic)
self.create_watchers(epic)
if self.sd.choice([True, True, False, True, True]):
filters = {}
if self.sd.choice([True, True, False, True, True]):
filters = {"project": epic.project}
n = self.sd.choice(list(range(self.sd.int(*NUM_USS_EPICS))))
user_stories = UserStory.objects.filter(
**filters).order_by("?")[:n]
for idx, us in enumerate(list(user_stories)):
RelatedUserStory.objects.create(epic=epic,
user_story=us,
order=idx + 1)
# Add history entry
take_snapshot(epic, user=epic.owner)
# Add history entry
epic.status = self.sd.db_object_from_queryset(
project.epic_statuses.filter(is_closed=False))
epic.save()
take_snapshot(epic, comment=self.sd.paragraph(), user=epic.owner)
return epic
def create_project(self, counter, is_private=None, blocked_code=None):
if is_private is None:
is_private = self.sd.boolean()
anon_permissions = not is_private and list(
map(lambda perm: perm[0], ANON_PERMISSIONS)) or []
public_permissions = not is_private and list(
map(lambda perm: perm[0], ANON_PERMISSIONS)) or []
project = Project.objects.create(
slug='project-%s' % (counter),
name='Project Example {0}'.format(counter),
description='Project example {0} description'.format(counter),
owner=self.sd.choice(self.users),
is_private=is_private,
anon_permissions=anon_permissions,
public_permissions=public_permissions,
total_story_points=self.sd.int(600, 3000),
total_milestones=self.sd.int(5, 10),
tags=self.sd.words(1, 10).split(" "),
blocked_code=blocked_code)
project.is_looking_for_people = counter in LOOKING_FOR_PEOPLE_PROJECTS_POSITIONS
if project.is_looking_for_people:
project.looking_for_people_note = self.sd.short_sentence()
project.is_featured = counter in FEATURED_PROJECTS_POSITIONS
project.is_kanban_activated = True
project.is_epics_activated = True
project.save()
take_snapshot(project, user=project.owner)
self.create_likes(project)
self.create_watchers(project, NotifyLevel.involved)
return project
def create_user(self,
counter=None,
username=None,
full_name=None,
email=None):
counter = counter or self.sd.int()
username = username or "user{0}".format(counter)
full_name = full_name or "{} {}".format(
self.sd.name('es'), self.sd.surname('es', number=1))
email = email or "user{0}@taigaio.demo".format(counter)
user = User.objects.create(username=username,
full_name=full_name,
email=email,
token=self.sd.hex_chars(10, 10),
color=self.sd.choice(COLOR_CHOICES))
user.set_password('123123')
user.save()
return user
def create_votes(self, obj):
for i in range(self.sd.int(*NUM_VOTES)):
user = self.sd.db_object_from_queryset(User.objects.all())
add_vote(obj, user)
def create_likes(self, obj):
for i in range(self.sd.int(*NUM_LIKES)):
user = self.sd.db_object_from_queryset(User.objects.all())
add_like(obj, user)
def create_watchers(self, obj, notify_level=None):
for i in range(self.sd.int(*NUM_WATCHERS)):
user = self.sd.db_object_from_queryset(User.objects.all())
if not notify_level:
obj.add_watcher(user)
else:
obj.add_watcher(user, notify_level)
def generate_color(self, tag):
color = sha1(tag.encode("utf-8")).hexdigest()[0:6]
return "#{}".format(color)
class Command(BaseCommand):
sd = SampleDataHelper(seed=12345678901)
@transaction.atomic
def handle(self, *args, **options):
# Prevent events emission when sample data is running
disconnect_events_signals()
self.users = [User.objects.get(is_superuser=True)]
# create users
if BASE_USERS:
for username, full_name, email in BASE_USERS:
self.users.append(self.create_user(username=username, full_name=full_name, email=email))
else:
for x in range(NUM_USERS):
self.users.append(self.create_user(counter=x))
# create project
for x in range(NUM_PROJECTS + NUM_EMPTY_PROJECTS):
project = self.create_project(x)
# added memberships
computable_project_roles = set()
for user in self.users:
if user == project.owner:
continue
role = self.sd.db_object_from_queryset(project.roles.all())
Membership.objects.create(email=user.email,
project=project,
role=role,
is_owner=self.sd.boolean(),
user=user)
if role.computable:
computable_project_roles.add(role)
# added invitations
for i in range(NUM_INVITATIONS):
role = self.sd.db_object_from_queryset(project.roles.all())
Membership.objects.create(email=self.sd.email(),
project=project,
role=role,
is_owner=self.sd.boolean(),
token=''.join(random.sample('abcdef0123456789', 10)))
if role.computable:
computable_project_roles.add(role)
# added custom attributes
if self.sd.boolean:
for i in range(1, 4):
UserStoryCustomAttribute.objects.create(name=self.sd.words(1, 3),
description=self.sd.words(3, 12),
project=project,
order=i)
if self.sd.boolean:
for i in range(1, 4):
TaskCustomAttribute.objects.create(name=self.sd.words(1, 3),
description=self.sd.words(3, 12),
project=project,
order=i)
if self.sd.boolean:
for i in range(1, 4):
IssueCustomAttribute.objects.create(name=self.sd.words(1, 3),
description=self.sd.words(3, 12),
project=project,
order=i)
if x < NUM_PROJECTS:
start_date = now() - datetime.timedelta(55)
# create milestones
for y in range(self.sd.int(*NUM_MILESTONES)):
end_date = start_date + datetime.timedelta(15)
milestone = self.create_milestone(project, start_date, end_date)
# create uss asociated to milestones
for z in range(self.sd.int(*NUM_USS)):
us = self.create_us(project, milestone, computable_project_roles)
# create tasks
rang = NUM_TASKS_FINISHED if start_date <= now() and end_date <= now() else NUM_TASKS
for w in range(self.sd.int(*rang)):
if start_date <= now() and end_date <= now():
task = self.create_task(project, milestone, us, start_date,
end_date, closed=True)
elif start_date <= now() and end_date >= now():
task = self.create_task(project, milestone, us, start_date,
now())
else:
# No task on not initiated milestones
pass
start_date = end_date
# created unassociated uss.
for y in range(self.sd.int(*NUM_USS_BACK)):
us = self.create_us(project, None, computable_project_roles)
# create bugs.
for y in range(self.sd.int(*NUM_ISSUES)):
bug = self.create_bug(project)
# create a wiki page
wiki_page = self.create_wiki(project, "home")
# Set a value to total_story_points to show the deadline in the backlog
defined_points = sum(project.defined_points.values())
project.total_story_points = int(defined_points * self.sd.int(5,12) / 10)
project.save()
def create_attachment(self, obj, order):
attached_file = self.sd.file_from_directory(*ATTACHMENT_SAMPLE_DATA)
membership = self.sd.db_object_from_queryset(obj.project.memberships
.filter(user__isnull=False))
attachment = Attachment.objects.create(project=obj.project,
name=path.basename(attached_file.name),
size=attached_file.size,
content_object=obj,
order=order,
owner=membership.user,
is_deprecated=self.sd.boolean(),
description=self.sd.words(3, 12),
attached_file=attached_file)
return attachment
def create_wiki(self, project, slug):
wiki_page = WikiPage.objects.create(project=project,
slug=slug,
content=self.sd.paragraphs(3,15),
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user)
for i in range(self.sd.int(*NUM_ATTACHMENTS)):
attachment = self.create_attachment(wiki_page, i+1)
take_snapshot(wiki_page,
comment=self.sd.paragraph(),
user=wiki_page.owner)
# Add history entry
wiki_page.content=self.sd.paragraphs(3,15)
wiki_page.save()
take_snapshot(wiki_page,
comment=self.sd.paragraph(),
user=wiki_page.owner)
return wiki_page
def create_bug(self, project):
bug = Issue.objects.create(project=project,
subject=self.sd.choice(SUBJECT_CHOICES),
description=self.sd.paragraph(),
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
severity=self.sd.db_object_from_queryset(Severity.objects.filter(
project=project)),
status=self.sd.db_object_from_queryset(IssueStatus.objects.filter(
project=project)),
priority=self.sd.db_object_from_queryset(Priority.objects.filter(
project=project)),
type=self.sd.db_object_from_queryset(IssueType.objects.filter(
project=project)),
tags=self.sd.words(1, 10).split(" "))
bug.save()
custom_attributes_values = {str(ca.id): self.sd.words(1, 12) for ca in project.issuecustomattributes.all()
if self.sd.boolean()}
if custom_attributes_values:
bug.custom_attributes_values.attributes_values = custom_attributes_values
bug.custom_attributes_values.save()
for i in range(self.sd.int(*NUM_ATTACHMENTS)):
attachment = self.create_attachment(bug, i+1)
if bug.status.order != 1:
bug.assigned_to = self.sd.db_object_from_queryset(project.memberships.filter(
user__isnull=False)).user
bug.save()
watching_user = self.sd.db_object_from_queryset(project.memberships.filter(user__isnull=False)).user
bug.watchers.add(watching_user)
take_snapshot(bug,
comment=self.sd.paragraph(),
user=bug.owner)
# Add history entry
bug.status=self.sd.db_object_from_queryset(IssueStatus.objects.filter(project=project))
bug.save()
take_snapshot(bug,
comment=self.sd.paragraph(),
user=bug.owner)
return bug
def create_task(self, project, milestone, us, min_date, max_date, closed=False):
task = Task(subject=self.sd.choice(SUBJECT_CHOICES),
description=self.sd.paragraph(),
project=project,
owner=self.sd.db_object_from_queryset(project.memberships.filter(user__isnull=False)).user,
milestone=milestone,
user_story=us,
finished_date=None,
assigned_to = self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
tags=self.sd.words(1, 10).split(" "))
if closed:
task.status = project.task_statuses.get(order=4)
else:
task.status = self.sd.db_object_from_queryset(project.task_statuses.all())
if task.status.is_closed:
task.finished_date = self.sd.datetime_between(min_date, max_date)
task.save()
custom_attributes_values = {str(ca.id): self.sd.words(1, 12) for ca in project.taskcustomattributes.all()
if self.sd.boolean()}
if custom_attributes_values:
task.custom_attributes_values.attributes_values = custom_attributes_values
task.custom_attributes_values.save()
for i in range(self.sd.int(*NUM_ATTACHMENTS)):
attachment = self.create_attachment(task, i+1)
take_snapshot(task,
comment=self.sd.paragraph(),
user=task.owner)
watching_user = self.sd.db_object_from_queryset(project.memberships.filter(user__isnull=False)).user
task.watchers.add(watching_user)
# Add history entry
task.status=self.sd.db_object_from_queryset(project.task_statuses.all())
task.save()
take_snapshot(task,
comment=self.sd.paragraph(),
user=task.owner)
return task
def create_us(self, project, milestone=None, computable_project_roles=[]):
us = UserStory.objects.create(subject=self.sd.choice(SUBJECT_CHOICES),
project=project,
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
description=self.sd.paragraph(),
milestone=milestone,
status=self.sd.db_object_from_queryset(project.us_statuses.filter(
is_closed=False)),
tags=self.sd.words(1, 3).split(" "))
for role_points in us.role_points.filter(role__in=computable_project_roles):
if milestone:
role_points.points = self.sd.db_object_from_queryset(
us.project.points.exclude(value=None))
else:
role_points.points = self.sd.db_object_from_queryset(
us.project.points.all())
role_points.save()
us.save()
custom_attributes_values = {str(ca.id): self.sd.words(1, 12) for ca in project.userstorycustomattributes.all()
if self.sd.boolean()}
if custom_attributes_values:
us.custom_attributes_values.attributes_values = custom_attributes_values
us.custom_attributes_values.save()
for i in range(self.sd.int(*NUM_ATTACHMENTS)):
attachment = self.create_attachment(us, i+1)
if self.sd.choice([True, True, False, True, True]):
us.assigned_to = self.sd.db_object_from_queryset(project.memberships.filter(user__isnull=False)).user
us.save()
watching_user = self.sd.db_object_from_queryset(project.memberships.filter(user__isnull=False)).user
us.watchers.add(watching_user)
take_snapshot(us,
comment=self.sd.paragraph(),
user=us.owner)
# Add history entry
us.status=self.sd.db_object_from_queryset(project.us_statuses.filter(is_closed=False))
us.save()
take_snapshot(us,
comment=self.sd.paragraph(),
user=us.owner)
return us
def create_milestone(self, project, start_date, end_date):
milestone = Milestone.objects.create(project=project,
name='Sprint {0}-{1}-{2}'.format(start_date.year,
start_date.month,
start_date.day),
owner=self.sd.db_object_from_queryset(
project.memberships.filter(user__isnull=False)).user,
created_date=start_date,
modified_date=start_date,
estimated_start=start_date,
estimated_finish=end_date,
order=10)
take_snapshot(milestone, user=milestone.owner)
return milestone
def create_project(self, counter):
is_private=self.sd.boolean()
anon_permissions = not is_private and list(map(lambda perm: perm[0], ANON_PERMISSIONS)) or []
public_permissions = not is_private and list(map(lambda perm: perm[0], ANON_PERMISSIONS)) or []
project = Project.objects.create(slug='project-%s'%(counter),
name='Project Example {0}'.format(counter),
description='Project example {0} description'.format(counter),
owner=random.choice(self.users),
is_private=is_private,
anon_permissions=anon_permissions,
public_permissions=public_permissions,
total_story_points=self.sd.int(600, 3000),
total_milestones=self.sd.int(5,10))
project.is_kanban_activated = True
project.save()
take_snapshot(project, user=project.owner)
return project
def create_user(self, counter=None, username=None, full_name=None, email=None):
counter = counter or self.sd.int()
username = username or "user{0}".format(counter)
full_name = full_name or "{} {}".format(self.sd.name('es'), self.sd.surname('es', number=1))
email = email or "user{0}@taigaio.demo".format(counter)
user = User.objects.create(username=username,
full_name=full_name,
email=email,
token=''.join(random.sample('abcdef0123456789', 10)),
color=self.sd.choice(COLOR_CHOICES))
user.set_password('123123')
user.save()
return user
class Command(BaseCommand):
help = 'Populate an empty database with data for development purpose.'
sd = SampleDataHelper(seed=1234567890)
def add_arguments(self, parser):
parser.add_argument(
"--from-fixtures",
action="store_true",
dest="from-fixtures",
default=False,
help="Load more real dates from a fixture (default false)",
)
@transaction.atomic
def handle(self, *args, **options):
# Create admin user
self.stdout.write(
" -> Create admin user [ username: '******' | password: '******' ]. "
)
self._create_admin_user()
if options["from-fixtures"]:
self.stdout.write(" -> Load data from fixtures.")
self._populate_with_fixtures()
else:
self.stdout.write(" -> Generate sample data.")
self._populate_with_sampledata()
def _populate_with_fixtures(self):
from django.core.management import call_command
call_command("loaddata", "initial_data", traceback=True)
def _populate_with_sampledata(self):
# Create cinemas
for name, address, price in CINEMAS:
self._create_cinema(name, address, price)
# Create movies
for i in MOVIES_IDS:
self._create_movie(i)
# Create shows
for i in range(1, NUM_SHOWS + 1):
self._create_show()
# Create users
for i in range(1, NUM_USERS + 1):
self._create_user(i)
# Create favorites
for user in User.objects.all():
shows = Show.objects.all()
for i in range(self.sd.int(RANGE_EVENTS[0], RANGE_EVENTS[1])):
show = self.sd.db_object_from_queryset(shows)
self._create_favorite(user, show)
shows = shows.exclude(id=show.id)
def _create_admin_user(self):
user = User.objects.create(username="******",
email="*****@*****.**",
full_name="Administrator",
is_superuser=True)
user.set_password("123123")
user.save()
return user
def _create_user(self, id):
user = User.objects.create(username="******".format(id),
email="user{}@cinemair.com".format(id),
full_name="{} {}".format(
self.sd.name('es'),
self.sd.surname('es', number=1)))
user.set_password("123123")
user.save()
return user
def _create_cinema(self, name, address, approximate_price):
return Cinema.objects.create(name=name,
address=address,
approximate_price=approximate_price,
city="Madrid",
country="Spain")
def _create_movie(self, id):
return Movie.objects.create(name=self.sd.words(1, 5), tmdb_id=id)
def _create_show(self):
return Show.objects.create(
movie=self.sd.db_object(Movie),
cinema=self.sd.db_object(Cinema),
datetime=self.sd.future_datetime(max_distance=60 * 24 * 90))
def _create_favorite(self, user, show):
return Favorite.objects.create(user=user, show=show)
class Command(BaseCommand):
sd = SampleDataHelper(seed=12345678901)
@transaction.atomic
def handle(self, *args, **options):
self.users = []
self.conferences = []
self.proposals = []
self.proposal_reviewers = []
print(' Updating domain to localhost:8000') # Update site url
site = Site.objects.get_current()
site.domain, site.name = 'localhost:8000', 'Local'
site.save()
print(' Creating Superuser') # create superuser
super_user = self.create_user(is_superuser=True, username='******',
is_active=True)
EmailAddress.objects.get_or_create(user=super_user,
verified=True,
primary=True,
email=super_user.email)
print(' Creating sample Users') # create users
for x in range(NUM_USERS):
self.users.append(self.create_user(counter=x))
print(' Creating proposal sections')
self.proposal_sections = self.create_proposal_sections()
print(' Create proposal types')
self.proposal_types = self.create_proposal_types()
# create conferences
print(' Creating sample Conferences')
for x in range(NUM_CONFERENCES + NUM_EMPTY_CONFERENCES):
conference = self.create_conference(x)
self.conferences.append(conference)
if x < NUM_CONFERENCES:
self.create_moderators(conference)
self.proposal_reviewers = self.create_propsoal_reviewers(conference)
# attach all proposal sections
for section in self.proposal_sections:
conference.proposal_sections.add(section)
# attach all proposal types
for proposal_type in self.proposal_types:
conference.proposal_types.add(proposal_type)
# create proposals
print(' Creating sample proposals')
for x in range(NUM_PUBLIC_PROPOSALS):
self.proposals.append(self.create_proposal(proposal_type="Public"))
for x in range(NUM_DRAFT_PROPOSALS):
self.proposals.append(self.create_proposal(proposal_type="Draft"))
for x in range(NUM_CANCELLED_PROPOSALS):
self.proposals.append(self.create_proposal(proposal_type="Cancelled"))
print(' Create sample Schedule')
for proposal in self.proposals:
if not proposal.get_status_display() == 'Public':
continue
self.create_scheduled_item(proposal=proposal)
self.create_scheduled_item(proposal='Break',
conference=self.conferences[0])
# create comments
print(' Creating sample proposal comments')
for x in range(NUM_PUBLIC_COMMENTS):
self.create_proposal_comment(users=self.users)
reviewers = [i.reviewer for i in self.proposal_reviewers]
for x in range(NUM_REVIEWER_COMMENTS):
self.create_proposal_comment(users=reviewers)
print(' Creating default choices for proposal reviewer vote values.')
for vote in constants.ProposalReviewVote.CHOICES:
ProposalSectionReviewerVoteValue.objects.create(vote_value=vote[0], description=vote[1])
def create_proposal_sections(self):
sections = []
for count in range(NUM_PROPOSAL_SECTIONS):
sections.append(ProposalSection.objects.create(**{
'name': "Proposal Section %d" % count,
'description': "Proposal Section %d description" % count,
'active': True
}))
return sections
def create_proposal_types(self):
types = []
for count in range(NUM_PROPOSAL_TYPES):
types.append(ProposalType.objects.create(**{
'name': "Proposal Type %d" % count,
'description': "Proposal Section %d description" % count,
'active': True
}))
return types
def create_moderators(self, conference):
moderators = []
count = self.sd.int(1, len(self.users))
for user in random.sample(self.users, count):
moderators.append(conference.moderators.create(
moderator=user, active=self.sd.boolean()))
return moderators
def create_propsoal_reviewers(self, conference):
proposal_reviewers = []
count = self.sd.int(1, len(self.users))
for user in random.sample(self.users, count):
proposal_reviewers.append(conference.proposal_reviewers.create(
reviewer=user, active=self.sd.boolean()))
return proposal_reviewers
def create_scheduled_item(self, proposal, conference=None):
kwargs = {}
kwargs['conference'] = conference if conference \
else proposal.conference
kwargs['event_date'] = kwargs['conference'].start_date
kwargs['start_time'] = datetime.datetime.time(datetime.datetime.now())
kwargs['end_time'] = datetime.datetime.time(
datetime.datetime.now() + datetime.timedelta(minutes=45))
if isinstance(proposal, six.string_types):
ScheduleItem.objects.create(
alt_name=proposal,
**kwargs)
else:
ScheduleItem.objects.create(
session=proposal,
**kwargs)
def create_conference(self, counter, start_date=None, end_date=None):
if counter == 0:
min_days_from_creation = 30
start_date = now() + datetime.timedelta(
days=min_days_from_creation)
# 2 day conference
end_date = now() + datetime.timedelta(
days=min_days_from_creation + 2)
else:
start_date = start_date or now() + datetime.timedelta(
random.randrange(-55, 55))
end_date = end_date or start_date + datetime.timedelta(
random.randrange(1, 4))
conference = Conference.objects.create(
name='%s Conference' % self.sd.words(1, 2).title(),
description=self.sd.paragraph(),
status=self.sd.choices_key(constants.ConferenceStatus.CHOICES),
start_date=start_date,
end_date=end_date,
created_by=self.sd.choice(self.users),
modified_by=self.sd.choice(self.users))
return conference
def create_user(self, counter=None, username=None, email=None, **kwargs):
counter = counter or self.sd.int()
params = {
"username": username or 'user{0}'.format(counter),
"first_name": kwargs.get('first_name', self.sd.name("us", 1)),
"last_name": kwargs.get('last_name', self.sd.surname("us", 1)),
"email": email or self.sd.email(),
"is_active": kwargs.get('is_active', self.sd.boolean()),
"is_superuser": kwargs.get('is_superuser', False),
"is_staff": kwargs.get('is_staff', kwargs.get('is_superuser', self.sd.boolean())),
}
user = get_user_model().objects.create(**params)
password = '******'
user.set_password(password)
user.save()
print("User created with username: {username} and password: {password}".format(
username=params.get('username'), password=password))
return user
def create_proposal(self, proposal_type):
status = next((i[0] for i in constants.ProposalStatus.CHOICES if
i[1] == proposal_type))
proposal = Proposal.objects.create(
conference=self.sd.choice(self.conferences),
proposal_section=self.sd.choice(self.proposal_sections),
proposal_type=self.sd.choice(self.proposal_types),
author=self.sd.choice(self.users),
title='%s Proposal' % self.sd.words(1, 2).title(),
description=self.sd.paragraph(),
status=status,
deleted=self.sd.boolean())
return proposal
def create_proposal_comment(self, users):
commenter = self.sd.choice(users)
comment = ProposalComment.objects.create(
proposal=self.sd.choice(self.proposals),
private=self.sd.boolean(),
comment='Comment',
commenter=commenter)
return comment
class Command(BaseCommand):
sd = SampleDataHelper(seed=12345678901)
@transaction.atomic
def handle(self, *args, **options):
self.users = [User.objects.get(is_superuser=True)]
# create users
for x in range(10):
self.users.append(self.create_user(x))
# create project
for x in range(4):
project = self.create_project(x)
# added memberships
computable_project_roles = set()
for user in self.users:
if user == project.owner:
continue
role = self.sd.db_object_from_queryset(Role.objects.all())
Membership.objects.create(email=user.email,
project=project,
role=role,
user=user)
if role.computable:
computable_project_roles.add(role)
start_date = now() - datetime.timedelta(55)
# create milestones
for y in range(self.sd.int(1, 5)):
end_date = start_date + datetime.timedelta(15)
milestone = self.create_milestone(project, start_date,
end_date)
# create uss asociated to milestones
for z in range(self.sd.int(3, 7)):
us = self.create_us(project, milestone,
computable_project_roles)
# create tasks
rang = (
1,
4) if start_date <= now() and end_date <= now() else (
0, 6)
for w in range(self.sd.int(*rang)):
if start_date <= now() and end_date <= now():
task = self.create_task(project,
milestone,
us,
start_date,
end_date,
closed=True)
elif start_date <= now() and end_date >= now():
task = self.create_task(project, milestone, us,
start_date, now())
else:
# No task on not initiated milestones
pass
start_date = end_date
# created unassociated uss.
for y in range(self.sd.int(8, 20)):
us = self.create_us(project, None, computable_project_roles)
# Set a value to total_story_points to show the deadline in the backlog
defined_points = sum(project.defined_points.values())
project.total_story_points = int(defined_points *
self.sd.int(5, 12) / 10)
project.save()
# create bugs.
for y in range(self.sd.int(15, 25)):
bug = self.create_bug(project)
# create a wiki page
wiki_page = self.create_wiki(project, "home")
def create_attachment(self, object):
attachment = Attachment.objects.create(
project=object.project,
content_type=ContentType.objects.get_for_model(object.__class__),
content_object=object,
object_id=object.id,
owner=self.sd.db_object_from_queryset(
object.project.memberships.all()).user,
attached_file=self.sd.image_from_directory(
*ATTACHMENT_SAMPLE_DATA))
return attachment
def create_wiki(self, project, slug):
wiki_page = WikiPage.objects.create(
project=project,
slug=slug,
content=self.sd.paragraphs(3, 15),
owner=self.sd.db_object_from_queryset(
project.memberships.all()).user)
for i in range(self.sd.int(0, 4)):
attachment = self.create_attachment(wiki_page)
return wiki_page
def create_bug(self, project):
bug = Issue.objects.create(
project=project,
subject=self.sd.choice(SUBJECT_CHOICES),
description=self.sd.paragraph(),
owner=self.sd.db_object_from_queryset(
project.memberships.all()).user,
severity=self.sd.db_object_from_queryset(
Severity.objects.filter(project=project)),
status=self.sd.db_object_from_queryset(
IssueStatus.objects.filter(project=project)),
priority=self.sd.db_object_from_queryset(
Priority.objects.filter(project=project)),
type=self.sd.db_object_from_queryset(
IssueType.objects.filter(project=project)),
tags=self.sd.words(1, 5).split(" "))
for i in range(self.sd.int(0, 4)):
attachment = self.create_attachment(bug)
if bug.status.order != 1:
bug.assigned_to = self.sd.db_object_from_queryset(
project.memberships.all()).user
bug.save()
return bug
def create_task(self,
project,
milestone,
us,
min_date,
max_date,
closed=False):
task = Task(subject=self.sd.choice(SUBJECT_CHOICES),
description=self.sd.paragraph(),
project=project,
owner=self.sd.db_object_from_queryset(
project.memberships.all()).user,
milestone=milestone,
user_story=us,
finished_date=None,
assigned_to=self.sd.db_object_from_queryset(
project.memberships.all()).user)
if closed:
task.status = project.task_statuses.get(order=4)
else:
task.status = self.sd.db_object_from_queryset(
project.task_statuses.all())
if task.status.is_closed:
task.finished_date = self.sd.datetime_between(min_date, max_date)
task.save()
for i in range(self.sd.int(0, 4)):
attachment = self.create_attachment(task)
return task
def create_us(self,
project,
milestone=None,
computable_project_roles=list(Role.objects.all())):
us = UserStory.objects.create(
subject=self.sd.choice(SUBJECT_CHOICES),
project=project,
owner=self.sd.db_object_from_queryset(
project.memberships.all()).user,
description=self.sd.paragraph(),
milestone=milestone,
status=self.sd.db_object_from_queryset(
project.us_statuses.filter(is_closed=False)),
tags=self.sd.words(1, 3).split(" "))
for role_points in us.role_points.filter(
role__in=computable_project_roles):
if milestone:
role_points.points = self.sd.db_object_from_queryset(
us.project.points.exclude(value=None))
else:
role_points.points = self.sd.db_object_from_queryset(
us.project.points.all())
role_points.save()
for i in range(self.sd.int(0, 4)):
attachment = self.create_attachment(us)
if self.sd.choice([True, True, False, True, True]):
us.assigned_to = self.sd.db_object_from_queryset(
project.memberships.all()).user
us.save()
return us
def create_milestone(self, project, start_date, end_date):
milestone = Milestone.objects.create(
project=project,
name='Sprint {0}-{1}-{2}'.format(start_date.year, start_date.month,
start_date.day),
owner=self.sd.db_object_from_queryset(
project.memberships.all()).user,
created_date=start_date,
modified_date=start_date,
estimated_start=start_date,
estimated_finish=end_date,
order=10)
return milestone
def create_project(self, counter):
project = Project.objects.create(
name='Project Example {0}'.format(counter),
description='Project example {0} description'.format(counter),
owner=random.choice(self.users),
domain_id=1,
public=True,
total_story_points=self.sd.int(600, 3000),
total_milestones=self.sd.int(5, 10))
return project
def create_user(self, counter):
user = User.objects.create(username='******'.format(counter),
first_name=self.sd.name('es'),
last_name=self.sd.surname('es', number=1),
email=self.sd.email(),
token=''.join(
random.sample('abcdef0123456789', 10)),
color=self.sd.choice(COLOR_CHOICES))
user.set_password('user{0}'.format(counter))
user.save()
return user
class Command(BaseCommand):
sd = SampleDataHelper(seed=12345678901)
@transaction.atomic
def handle(self, *args, **options):
self.users = []
# Update site url
print(' Updating domain to localhost:8000')
site = Site.objects.get_current()
site.domain = 'localhost:8000'
site.name = 'Local'
site.save()
# create superuser
print(' Creating Superuser')
super_user = self.create_user(is_superuser=True,
username='******',
is_active=True)
EmailAddress.objects.get_or_create(user=super_user,
verified=True,
primary=True,
email=super_user.email)
# create users
print(' Creating sample Users')
for x in range(NUM_USERS):
self.users.append(self.create_user(counter=x))
print(' Creating proposal sections')
self.proposal_sections = self.create_proposal_sections()
print(' Create proposal types')
self.proposal_types = self.create_proposal_types()
# create conferences
print(' Creating sample Conferences')
for x in range(NUM_CONFERENCES + NUM_EMPTY_CONFERENCES):
conference = self.create_conference(x)
if x < NUM_CONFERENCES:
self.create_moderators(conference)
self.create_propsoal_reviewers(conference)
# attach all proposal sections
for section in self.proposal_sections:
conference.proposal_sections.add(section)
# attach all proposal types
for proposal_type in self.proposal_types:
conference.proposal_types.add(proposal_type)
def create_proposal_sections(self):
sections = []
for count in range(NUM_PROPOSAL_SECTIONS):
sections.append(
ProposalSection.objects.create(
**{
'name': "Proposal Section %d" % count,
'description': "Proposal Section %d description" %
count,
'active': True
}))
return sections
def create_proposal_types(self):
types = []
for count in range(NUM_PROPOSAL_TYPES):
types.append(
ProposalType.objects.create(
**{
'name': "Proposal Type %d" % count,
'description': "Proposal Section %d description" %
count,
'active': True
}))
return types
def create_moderators(self, conference):
moderators = []
count = self.sd.int(1, len(self.users))
for user in random.sample(self.users, count):
moderators.append(
conference.moderators.create(moderator=user,
active=self.sd.boolean()))
return moderators
def create_propsoal_reviewers(self, conference):
proposal_reviewers = []
count = self.sd.int(1, len(self.users))
for user in random.sample(self.users, count):
proposal_reviewers.append(
conference.proposal_reviewers.create(reviewer=user,
active=self.sd.boolean()))
return proposal_reviewers
def create_conference(self, counter, start_date=None, end_date=None):
if counter == 0:
min_days_from_creation = 30
start_date = now() + datetime.timedelta(
days=min_days_from_creation)
# 2 day conference
end_date = now() + datetime.timedelta(days=min_days_from_creation +
2)
else:
start_date = start_date or now() + datetime.timedelta(
random.randrange(-55, 55))
end_date = end_date or start_date + datetime.timedelta(
random.randrange(1, 4))
conference = Conference.objects.create(
name='%s Conference' % self.sd.words(1, 2).title(),
description=self.sd.paragraph(),
status=self.sd.choices_key(constants.CONFERENCE_STATUS_LIST),
start_date=start_date,
end_date=end_date,
created_by=self.sd.choice(self.users),
modified_by=self.sd.choice(self.users))
return conference
def create_user(self, counter=None, username=None, email=None, **kwargs):
counter = counter or self.sd.int()
params = {
"username":
username or 'user{0}'.format(counter),
"first_name":
kwargs.get('first_name', self.sd.name("us", 1)),
"last_name":
kwargs.get('last_name', self.sd.surname("us", 1)),
"email":
email or self.sd.email(),
"is_active":
kwargs.get('is_active', self.sd.boolean()),
"is_superuser":
kwargs.get('is_superuser', False),
"is_staff":
kwargs.get('is_staff', kwargs.get('is_superuser',
self.sd.boolean())),
}
user = get_user_model().objects.create(**params)
password = '******'
user.set_password(password)
user.save()
print(
"User created with username: {username} and password: {password}".
format(username=params.get('username'), password=password))
return user
