class TestSignupView(TestCase):
def setUp(self) -> None:
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.user_profile = UserProfile()
self.user_profile.user = self.user
self.user_profile.save()
self.team = Team(name='Kitchen', description='Cook stuff.', max_size=2)
self.team.save()
self.membership = TeamMembership(team=self.team,
member=self.user)
self.membership.save()
def test_signup_form_validation(self):
data = {
'first_name': 'Foo',
'last_name': 'Bar',
'years_on_playa': 2,
'invited_by': 'Baz Qux',
'email': '*****@*****.**',
'password': '******',
'duplicate_password': '******',
'phone': '555-555-5555',
'zipcode': '12345',
'g-recaptcha-response': 'PASSED',
'interested_team': self.team.id,
}
os.environ['RECAPTCHA_TESTING'] = 'True'
form = SignUpForm(data)
self.assertTrue(form.is_valid())
class TestSignupView(TestCase):
def setUp(self) -> None:
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.user_profile = UserProfile()
self.user_profile.user = self.user
self.user_profile.save()
self.team = Team(name='Kitchen', description='Cook stuff.', max_size=2)
self.team.save()
self.membership = TeamMembership(team=self.team, member=self.user)
self.membership.save()
def test_signup_form_validation(self):
data = {
'first_name': 'Foo',
'last_name': 'Bar',
'years_on_playa': 2,
'invited_by': 'Baz Qux',
'email': '*****@*****.**',
'password': '******',
'duplicate_password': '******',
'phone': '555-555-5555',
'zipcode': '12345',
'g-recaptcha-response': 'PASSED',
'interested_teams': [self.team.id],
}
os.environ['RECAPTCHA_TESTING'] = 'True'
form = SignUpForm(data)
self.assertTrue(form.is_valid())
def form_valid(self, form):
team = Team(name=form.cleaned_data['team_name'])
team.save()
team.nodes_visible.add(1)
team.nodes_visible.add(2)
team.nodes_visible.add(3)
team.nodes_visible.add(4)
def add_player(username, first_name, last_name, team):
if username:
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username)
user.first_name = first_name
user.last_name = last_name
user.save()
team.members.add(user)
print form.cleaned_data
for i in range(1,4):
add_player(
form.cleaned_data['player{0}_crsid'.format(i)],
form.cleaned_data['player{0}_first_name'.format(i)],
form.cleaned_data['player{0}_last_name'.format(i)],
team)
return super(SignupView, self).form_valid(form)
class DB_Teams_Interface:
def __init__(self):
self.g = None
def create_single_rating_info(self, team, conf, div):
self._add_to_db(team, conf, div, False)
def create_teams_from_dict(self, dict):
for i in dict:
div = i
cur_div = dict.get(i)
for j in cur_div:
team = j
conf = cur_div.get(j)
self._add_to_db(team, conf, div, False)
def _add_to_db(self, team, conf, div, override):
if not override:
if not Team.objects.filter(
team_name=team, conference=conf, division=div).exists():
self.g = Team(team_name=team, conference=conf, division=div)
self.g.save()
else:
self.g = Team(team_name=team, conference=conf, division=div)
self.g.save()
def clear_table(self):
for i in Team.objects.all():
i.delete()
def _add_to_db(self, team, conf, div, override):
if not override:
if not Team.objects.filter(
team_name=team, conference=conf, division=div).exists():
self.g = Team(team_name=team, conference=conf, division=div)
self.g.save()
else:
self.g = Team(team_name=team, conference=conf, division=div)
self.g.save()
def setUp(self) -> None:
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.user_profile = UserProfile()
self.user_profile.user = self.user
self.user_profile.save()
self.team = Team(name='Kitchen', description='Cook stuff')
self.team.save()
class TestTeamView(TestCase):
def setUp(self) -> None:
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.user_profile = UserProfile()
self.user_profile.user = self.user
self.user_profile.save()
self.team = Team(name='Kitchen', description='Cook stuff')
self.team.save()
def setUp(self):
self.early_crew = Team(name='Early Crew',
description='Build stuff',
is_early_crew=True)
self.early_crew.save()
self.late_crew = Team(name='Late Crew',
description='Tear stuff down',
is_late_crew=True)
self.late_crew.save()
super(TestUserProfileChangeAttendingView, self).setUp()
def setUp(self):
self.early_crew = Team(name='Early Crew',
description='Build stuff',
is_early_crew=True)
self.early_crew.save()
self.late_crew = Team(name='Late Crew',
description='Tear stuff down',
is_late_crew=True)
self.late_crew.save()
super(TestUserProfileChangeAttendingView, self).setUp()
def db_init():
# 建立小組
for i in range(5):
team = Team()
db.session.add(team)
db.session.commit()
# 建立使用者
for key, value in user_list.items():
user = User(nickname=key, account=key, password=key, team_id=value)
db.session.add(user)
db.session.commit()
# 小隊帳號
for i in range(4):
client = User(
nickname=team_nickname_list[i], account=team_account_list[i],
password=team_password_list[i], team_id=i+1)
db.session.add(client)
db.session.commit()
# 建立 BanCard 資料
for i in range(4):
ban_card = BanCard()
db.session.add(ban_card)
db.session.commit()
# 建立 Domain 資料
for i in range(8):
domain = Domain()
db.session.add(domain)
db.session.commit()
def test_details(self):
team = Team(name='Test Team',
description='This is a test.')
team.save()
alice = User.objects.create_user('alice', '*****@*****.**', 'passwd')
alice.save()
bob = User.objects.create_user('bob', '*****@*****.**', 'passwd')
bob.save()
alice_membership = TeamMembership(team=team, member=alice, is_lead=True)
alice_membership.save()
bob_membership = TeamMembership(team=team, member=bob)
bob_membership.save()
self.assertEqual(set(team.members.all()), {alice, bob})
self.assertEqual(list(team.leads), [alice])
def create_team(self, **kwargs):
kwargs = merge_args(
dict(region=Region.EU,
mode=Mode.TEAM_1V1,
season=self.season,
version=Version.HOTS,
league=League.GOLD,
member0=self.player,
member1=None,
member2=None,
member3=None,
race0=Race.ZERG,
race1=Race.UNKNOWN,
race2=Race.UNKNOWN,
race3=Race.UNKNOWN), **kwargs)
self.team = Team(**kwargs)
self.team.save()
return self.team
def list(request: HttpRequest) -> HttpResponse:
teams = Team.objects_ordered_by_remaining_space().all()
my_team_ids = [team.id for team in request.user.teams.all()]
return render(request,
'team/list.html',
context={
'profile': request.user.profile,
'my_team_ids': my_team_ids,
'teams': teams,
})
def test_details(self):
team = Team(name='Test Team', description='This is a test.')
team.save()
alice = User.objects.create_user('alice', '*****@*****.**', 'passwd')
alice.save()
bob = User.objects.create_user('bob', '*****@*****.**', 'passwd')
bob.save()
alice_membership = TeamMembership(team=team,
member=alice,
is_lead=True)
alice_membership.save()
bob_membership = TeamMembership(team=team, member=bob)
bob_membership.save()
self.assertEqual(set(team.members.all()), {alice, bob})
self.assertEqual(list(team.leads), [alice])
def list_teams(request):
action = request.POST.get('action')
if action == 'create_team':
regex = re.compile('[^a-zA-Z0-9]')
name = regex.sub('', request.POST.get('name'))
if len(name) > 0:
team = Team(name=name, owner=request.user)
team.save()
teamuser = TeamUser(team=team, user=request.user)
teamuser.save()
if action == 'delete_team':
team_id = request.POST.get('id')
if team_id:
team = Team.objects.get(id=team_id)
if team and team.owner == request.user:
team.delete()
teams = Team.objects.filter(teamuser__user=request.user)
context = {
'teams': teams,
}
return render(request, 'teams/list.html', context)
def setUp(self) -> None:
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.user_profile = UserProfile()
self.user_profile.user = self.user
self.user_profile.save()
self.team = Team(name='Kitchen', description='Cook stuff.', max_size=2)
self.team.save()
self.membership = TeamMembership(team=self.team,
member=self.user)
self.membership.save()
def post(self, request, **kwargs):
"""新建团队，同时调用融云接口为该团队创建一个对应的群聊
:param kwargs:
name: 团队名称
description: 团队描述
url: 团队链接
province:
city:
county:
fields: 团队领域，格式:'field1|field2'
tags: 标签，格式：'tag1|tag2|tag3|...'
:return: team_id: 团队id
"""
name = kwargs.pop('name')
fields = kwargs.pop('fields', None)
tags = kwargs.pop('tags', None)
# 昵称唯一性验证
if Team.enabled.filter(name=name).count() != 0:
abort(403, '团队名已被注册')
# 昵称非法词验证
if check_bad_words(name):
abort(403, '团队名含非法词汇')
team = Team(owner=request.user, name=name)
team.save()
for k in kwargs:
setattr(team, k, kwargs[k])
fields = fields.split('|')[:2] if fields is not None else ('', '')
team.field1, team.field2 = fields[0].strip(), fields[1].strip()
if tags:
tags = tags.split('|')[:5]
with transaction.atomic():
team.tags.all().delete()
order = 0
for tag in tags:
tag = tag.strip()
if tag:
team.tags.create(name=tag, order=order)
order += 1
team.save()
action.create_team(request.user, team)
request.user.score += get_score_stage(2)
request.user.score_records.create(
score=get_score_stage(2), type="能力", description="成功创建一个团队")
request.user.save()
return JsonResponse({'team_id': team.id})
class SignUpForm(forms.Form):
first_name = forms.CharField(label="What's your first name, little dino?",
max_length=30)
last_name = forms.CharField(label="And your last name?", max_length=30)
years_on_playa = forms.IntegerField(
label=
"Nice to meet you! So how many years have you gone to Burning Man?")
interested_teams = forms.ModelMultipleChoiceField(
label=
'Which teams are you interested in joining? (you can always change it later)',
widget=forms.CheckboxSelectMultiple,
queryset=Team.objects_ordered_by_remaining_space().filter(
num_members__lt=F('max_size')))
invited_by = forms.CharField(label="Who invited you to LED Dinosaur?",
max_length=64)
email = forms.EmailField(
label="Cool! What's your email so we can keep you up to date?")
password = forms.CharField(label="And a password so we can identify you!",
widget=forms.PasswordInput,
min_length=8)
duplicate_password = forms.CharField(
label=" What was that password again? (in case you typo-ed)",
widget=forms.PasswordInput,
min_length=8)
phone = forms.CharField(label="And your phone number, por favor?")
zipcode = forms.CharField(label="Last one. What's your zip code?",
max_length=5,
min_length=5)
captcha = ReCaptchaField(label='')
def clean(self):
super().clean()
password = self.cleaned_data['password']
duplicate_password = self.cleaned_data['duplicate_password']
if password != duplicate_password:
raise ValidationError('Passwords must match!')
def clean_phone(self) -> str:
return UserProfile.parse_phone_number(self.cleaned_data['phone'])
def define():
if current_user.permission_lvl < 4:
flash('You have no permission to do this action.')
return redirect(url_for('req.index'))
identifier = request.args.get('id')
if identifier:
form = RelationshipForm(begin=Team.query.filter_by(id=identifier).first().from_team,
end=Team.query.filter_by(id=identifier).first().to_team,
team_id=identifier)
else:
form = RelationshipForm()
if form.validate_on_submit():
if not identifier: # This is an add operation
to_add = Team(from_team=form.begin.data, to_team=form.end.data)
db.session.add(to_add)
db.session.commit()
flash('Relationship successfully added.')
return redirect(url_for('admin.admin'))
else: # This is an edit operation
to_edit = Team.query.filter_by(id=identifier).first()
if to_edit.from_team == form.begin.data and to_edit.to_team == form.end.data:
flash('No change was made to the database.')
return redirect(url_for('admin.admin'))
to_edit.from_team = form.begin.data
to_edit.to_team = form.end.data
db.session.commit()
flash('Relationship successfully edited.')
return redirect(url_for('admin.admin'))
return render_template('admin/define.html', title='Relationship Manager', form=form)
def createTeam(request):
if not request.user.is_authenticated():
return HttpResponseRedirect("/")
if request.method == 'POST': # If the form has been submitted...
form = TeamForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
theName = form.cleaned_data['teamName']
aTeam = Team()
aTeam.name = theName
aTeam.dateCreated = datetime.datetime.utcnow().replace(tzinfo=utc)
aTeam.active = True
aTeam.save()
return HttpResponseRedirect('/team/edit/' + aTeam.id.__str__() + '/') # Redirect after POST
else:
form = TeamForm() # An unbound form
context = {
'form': form,
}
return render(request, 'createTeam.html', context)
class TestUserProfileChangeAttendingView(TestUserProfileView):
def setUp(self):
self.early_crew = Team(name='Early Crew',
description='Build stuff',
is_early_crew=True)
self.early_crew.save()
self.late_crew = Team(name='Late Crew',
description='Tear stuff down',
is_late_crew=True)
self.late_crew.save()
super(TestUserProfileChangeAttendingView, self).setUp()
def test_change_attending_view(self) -> None:
self.client.login(username='******', password='******')
expected_redirect_url = get_absolute_url_from_relative(
reverse('user-profile-me'))
response = self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
},
follow=True,
secure=True)
self.assertRedirects(response, expected_redirect_url)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(
include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
response = self.client.post(reverse('changed-attending'), {
'is-attending': 'off',
},
follow=True,
secure=True)
self.assertRedirects(response, expected_redirect_url)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(
include_soft_deleted=True)
self.assertTrue(attendance.deleted_at)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
response = self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
},
follow=True,
secure=True)
self.assertRedirects(response, expected_redirect_url)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(
include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
def test_update_attendance_record(self) -> None:
self.client.login(username='******', password='******')
self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
},
follow=True,
secure=True)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(
include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
attendance_form = AttendanceProfileForm(
{field: ''
for field in AttendanceProfileForm.Meta.fields},
instance=attendance)
self.assertTrue(attendance_form.is_valid())
data = {'is-attending': 'on'}
data.update(attendance_form.data)
self.client.post(reverse('changed-attending'),
data,
follow=True,
secure=True)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(
include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
def test_update_attendance_record_early_crew(self) -> None:
self.client.login(username='******', password='******')
self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
},
follow=True,
secure=True)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(
include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
attendance_form = AttendanceProfileForm(
{field: ''
for field in AttendanceProfileForm.Meta.fields},
instance=attendance)
attendance_form.data['job_preferences'] = []
attendance_form.data['arrival_date'] = 'wednesday1'
self.assertTrue(attendance_form.is_valid())
data = {'is-attending': 'on'}
data.update(attendance_form.data)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
self.client.post(reverse('changed-attending'),
data,
follow=True,
secure=True)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
early_crew = self.user_profile.user.teams.filter(
pk=self.early_crew.pk).first()
self.assertIsNotNone(early_crew)
attendance_form.data['arrival_date'] = 'sunday'
self.assertTrue(attendance_form.is_valid())
data.update(attendance_form.data)
self.client.post(reverse('changed-attending'),
data,
follow=True,
secure=True)
early_crew = self.user_profile.user.teams.filter(
pk=self.early_crew.pk).first()
self.assertIsNone(early_crew)
def test_update_attendance_record_late_crew(self) -> None:
self.client.login(username='******', password='******')
self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
},
follow=True,
secure=True)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(
include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
attendance_form = AttendanceProfileForm(
{field: ''
for field in AttendanceProfileForm.Meta.fields},
instance=attendance)
attendance_form.data['job_preferences'] = []
attendance_form.data['departure_date'] = 'monday'
self.assertTrue(attendance_form.is_valid())
data = {'is-attending': 'on'}
data.update(attendance_form.data)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
self.client.post(reverse('changed-attending'),
data,
follow=True,
secure=True)
self.assertEqual(
len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
late_crew = self.user_profile.user.teams.filter(
pk=self.late_crew.pk).first()
self.assertIsNotNone(late_crew)
attendance_form.data['departure_date'] = 'sunday'
self.assertTrue(attendance_form.is_valid())
data.update(attendance_form.data)
self.client.post(reverse('changed-attending'),
data,
follow=True,
secure=True)
late_crew = self.user_profile.user.teams.filter(
pk=self.late_crew.pk).first()
self.assertIsNone(late_crew)
def handle_win(number, sections, loser_submit=False):
# check that both players exist in system
winner = get_object(Player, phone_number=number)
if not winner:
return HttpResponse(createSmsResponse("Join Undisputed first"))
loser_username = sections[1]
loser = get_object(Player, username=loser_username)
if not loser:
return HttpResponse(createSmsResponse(loser_username + " does not exist. Please try again."))
# check if the result is just a competition
competition_name = sections[-1]
league = get_object(League, shorthand_name=competition_name)
if not league:
league = get_object(League, name=competition_name)
# if this flag is true, swap
if loser_submit:
temp = winner
winner = loser
loser = temp
teams = Team.objects.filter(league=league)
# check that message was not malformed
if len(sections) != 4:
return HttpResponse(createSmsResponse('multiperson teams and multiword competitions not implemented yet'))
# search for existing teams
winning_team = get_object(Team, name=winner.username)
losing_team = get_object(Team, name=loser.username)
if not winning_team:
new_team = Team(league=league,rating=2000,ranking=100, name=winner.username)
new_team.members = winner
new_team.name = winner.username
new_team.save()
winning_team = new_team
# search for the loser's team
if not losing_team:
new_l_team = Team(league=league,rating=2000, ranking=100)
new_l_team.members = loser
new_l_team.name = loser.username
new_l_team.save()
losing_team = new_l_team
# save the result
#Todo- add teams to results
new_result = Result.objects.create(league=league,time=datetime.now(),winner=winning_team,loser=losing_team)
# use Elo's algorithm to calculate the new ratings
calculate_elo_update(winning_team, losing_team)
# update each team's streaks
winning_team.update_streak(True)
losing_team.update_streak(False)
# use the new ratings to calculate new rankings
teams = Team.objects.filter(league=league).order_by("rating").all().reverse()
rank = 1
for team in teams:
team.ranking = rank
team.save()
rank += 1
winning_team = Team.objects.get(name=winner.username)
losing_team = Team.objects.get(name=loser.username)
NOTIFICATIONS = True
loser_string = "You were defeated by %s in %s. Your new rating is %s and you are ranked %s" % (winner.username.upper(), league.name, int(losing_team.rating), losing_team.ranking)
winner_string = "Congrats on beating %s! Your new rating is %s and you are ranked #%s in %s. A notification was sent to %s." % (loser.username.upper(), int(winning_team.rating), int(winning_team.ranking), winning_team.league.name, loser.username.upper())
if loser_submit:
to_msg = winner_string
return_msg = loser_string
to_phone_number = winner.phone_number
else:
to_msg = loser_string
return_msg = winner_string
to_phone_number = loser.phone_number
if competition_name == "ksfifa":
TWILIO_NUMBER = "+19786730440"
elif competition_name == "kspingpong":
TWILIO_NUMBER = "+14793163917"
if NOTIFICATIONS:
client.sms.messages.create(
to=str(to_phone_number),
from_=TWILIO_NUMBER,
body=to_msg)
return HttpResponse(
createSmsResponse(return_msg
))
class Db(object):
""" Helper class to create test data in db. """
def __init__(self):
self.db_name = connection.settings_dict['NAME']
print(self.db_name)
self.team = None
self.cache = None
self.player = None
self.season = None
self.ladder = None
self.ranking = None
self.ranking_data = None
self.default_ranking_data__data = {}
self.clear_defaults()
def clear_defaults(self):
self.default_ranking_data__data = {}
@staticmethod
def filter(klass, *args, **kwargs):
return klass.objects.filter(*args, **kwargs)
@staticmethod
def count(klass, *args, **kwargs):
return klass.objects.filter(*args, **kwargs).count()
@staticmethod
def get(klass, *args, **kwargs):
return klass.objects.get(*args, **kwargs)
@staticmethod
def objects(klass):
return klass.objects
@staticmethod
def all(klass):
return klass.objects.all()
@staticmethod
def execute(sql):
cursor = connection.cursor()
cursor.execute(sql)
return cursor
def delete_all(self, keep=None, delete=None):
for d in (delete or [
RankingData, RankingStats, Cache, Ranking, Team, Player,
Ladder, Season
]):
if d not in (keep or []):
if d == Ranking:
cursor = connection.cursor()
cursor.execute("update cache set ranking_id = NULL")
if d == Ladder:
cursor = connection.cursor()
cursor.execute("update cache set ladder_id = NULL")
self.all(d).delete()
def create_season(self, **kwargs):
kwargs = merge_args(
{
'id': 16,
'start_date': '2013-11-11',
'end_date': '2014-01-03',
'name': '2013 Season 6',
'year': 2013,
'number': 6,
'version': Version.HOTS
}, **kwargs)
try:
self.get(Season, id=kwargs['id'])
raise AssertionError("Season with id %d already exists." %
kwargs['id'])
except Season.DoesNotExist:
pass
self.season = Season(**kwargs)
self.season.save()
return self.season
def create_cache(self, type=Cache.LADDER, members=None, **kwargs):
data = kwargs.pop('data', None)
if data is None and members is not None:
data = gen_ladder_data(members)
kwargs = merge_args(
{
'bid': randint(1, 1e6),
'url': 'http://bnet/' + uniqueid(10),
'type': type,
'region': Region.EU,
'created': utcnow(),
'updated': utcnow(),
'status': 200,
'retry_count': 0
}, **kwargs)
kwargs['data'] = json.dumps(data)
self.cache = Cache(**kwargs)
self.cache.save()
return self.cache
def create_ladder(self, **kwargs):
kwargs = merge_args(
{
'bid': 1,
'region': Region.EU,
'strangeness': Ladder.GOOD,
'league': League.GOLD,
'tier': 0,
'version': Version.HOTS,
'mode': Mode.TEAM_1V1,
'season': self.season,
'first_join': utcnow(),
'last_join': utcnow(),
'created': utcnow(),
'updated': utcnow(),
'max_points': 20
}, **kwargs)
self.ladder = Ladder(**kwargs)
self.ladder.save()
return self.ladder
def create_player(self, **kwargs):
kwargs = merge_args(
{
'bid': randint(0, 1e9),
'region': Region.EU,
'realm': 1,
'mode': Mode.TEAM_1V1,
'season': self.season,
'race': Race.ZERG,
'name': uniqueid(12),
'clan': uniqueid(32),
'tag': uniqueid(6)
}, **kwargs)
self.player = Player(**kwargs)
self.player.save()
return self.player
def create_team(self, **kwargs):
kwargs = merge_args(
dict(region=Region.EU,
mode=Mode.TEAM_1V1,
season=self.season,
version=Version.HOTS,
league=League.GOLD,
member0=self.player,
member1=None,
member2=None,
member3=None,
race0=Race.ZERG,
race1=Race.UNKNOWN,
race2=Race.UNKNOWN,
race3=Race.UNKNOWN), **kwargs)
self.team = Team(**kwargs)
self.team.save()
return self.team
def create_teams(self, count=1, **kwargs):
teams = []
for i in range(count):
self.create_player(name="%s-%d" % (uniqueid(8), i))
teams.append(self.create_team(**kwargs))
return teams
def get_teams_by_member0_bids(self, *bids, mode=Mode.TEAM_1V1):
tids = []
for bid in bids:
p = self.get(Player, bid=bid)
tids.append(self.get(Team, member0=p, mode=mode).id)
return tids
def create_ranking(self, **kwargs):
kwargs = merge_args(
dict(created=utcnow(),
data_time=utcnow(),
min_data_time=utcnow(),
max_data_time=utcnow(),
status=Ranking.COMPLETE_WITH_DATA,
season=self.season), **kwargs)
self.ranking = Ranking.objects.create(**kwargs)
return self.ranking
def _default_team_rank(self, team_rank):
""" Update a team_rank dict with defaults. """
for k, v in self.default_ranking_data__data.items():
team_rank.setdefault(k, v)
team_rank.setdefault("team_id", self.team.id)
team_rank.setdefault("data_time", to_unix(self.ranking.data_time))
team_rank.setdefault("version", Version.HOTS)
team_rank.setdefault("region", Region.EU)
team_rank.setdefault("mode", Mode.TEAM_1V1)
team_rank.setdefault("league", League.GOLD)
team_rank.setdefault("tier", 0)
team_rank.setdefault("ladder_id", self.ladder.id)
team_rank.setdefault("join_time", to_unix(self.ranking.data_time))
team_rank.setdefault("source_id", self.cache.id)
team_rank.setdefault("mmr", 1000)
team_rank.setdefault("points", 100.0)
team_rank.setdefault("wins", 10)
team_rank.setdefault("losses", 10)
team_rank.setdefault("race0", Race.ZERG)
team_rank.setdefault("race1", Race.UNKNOWN)
team_rank.setdefault("race2", Race.UNKNOWN)
team_rank.setdefault("race3", Race.UNKNOWN)
team_rank.setdefault("ladder_rank", 1)
team_rank.setdefault("ladder_count", 1)
team_rank.setdefault("league_rank", 1)
team_rank.setdefault("league_count", 1)
team_rank.setdefault("region_rank", 1)
team_rank.setdefault("region_count", 1)
team_rank.setdefault("world_rank", 1)
team_rank.setdefault("world_count", 1)
def create_ranking_data(self, raw=True, **kwargs):
kwargs = merge_args(dict(ranking=self.ranking, updated=utcnow()),
kwargs)
data = kwargs.pop('data', [])
ranking = kwargs['ranking']
for team_rank in data:
self._default_team_rank(team_rank)
ranking.sources.add(self.get(Cache, pk=team_rank['source_id']))
self.ranking_data = RankingData.objects.create(**kwargs)
sc2.save_ranking_data_raw(self.db_name, ranking.id, 0, data, True)
if not raw:
cpp = sc2.RankingData(self.db_name, Enums.INFO)
cpp.load(ranking.id)
cpp.save_data(ranking.id, ranking.season_id, to_unix(utcnow()))
cpp.release()
return self.ranking_data
def update_ranking_stats(self, ranking_id=None):
""" Will build ranking stats based of the ranking by calling c++. """
if ranking_id is None: ranking_id = self.ranking.id
cpp = sc2.RankingData(self.db_name, Enums.INFO)
cpp.load(ranking_id)
cpp.save_stats(ranking_id, to_unix(utcnow()))
cpp.release()
def save_teams(self, teams):
print('Saving teams found')
self.teams = Team.objects.bulk_create([Team(**team) for team in teams])
def form_teams_view(request, spaceurl):
member = get_user(request)
space = Space.objects.get(url=spaceurl)
msg = ""
user_preferences = ""
if member.username != space.teacher:
return redirect('/profile_redirect/')
setup_data = ""
if request.method == 'POST':
group_size_raw = request.POST.get('Group_Options', None)
iterative_soulmates_raw = '1'
algorithm_index_raw = request.POST.get('optradio', None)
alpha_raw = request.POST.get('alpha')
alpha_adjusted = float(alpha_raw) * 1000000
alpha_adjusted = int(alpha_adjusted)
theta_raw = request.POST.get('theta')
theta_adjusted = float(theta_raw) * 100
theta_adjusted = int(theta_adjusted)
members = space.member_set.exclude(name='Account in Progress')
number_members = members.count()
setup_data = str(number_members) + " " + group_size_raw + " " + iterative_soulmates_raw + " " \
+ algorithm_index_raw + " " + str(alpha_adjusted) + " " + str(theta_adjusted)
# get input in format to store in team model
algorithm_index = int(algorithm_index_raw)
iterative_soulmates = iterative_soulmates_raw == "1"
group_size = int(group_size_raw)
# Assigns each member a rank and sets up easy lookup between usernames and rankings
rank_to_user_dict = {}
user_to_rank_dict = {}
random_array = random.sample(range(0, members.count()),
members.count())
count = 0
for member in members:
rank = random_array[count]
rank_to_user_dict[rank] = member.username
user_to_rank_dict[member.username] = rank
count += 1
# Gets member preferences ready for the java program
user_preferences = ""
for member in members:
member_data = member.username + " " + str(
user_to_rank_dict[member.username]) + " "
wants_any_team = False
if Preferences.objects.filter(member=member, space=space).exists():
finished = False
pref_data = ""
preferences = Preferences.objects.get(member=member,
space=space)
preferenceArray = preferences.members_ranking.split(' ')
for preference in preferenceArray:
if preference == "@myself@":
finished = True
elif preferences == "@team@":
wants_any_team = True
if preference in user_to_rank_dict and not finished:
pref_data += str(user_to_rank_dict[preference]) + " "
if wants_any_team:
pref_data = "team " + pref_data
else:
pref_data = "alone " + pref_data
member_data += " " + pref_data
else:
member_data += "alone "
user_preferences += member_data
# Runs the team formation algorithms by passing in setup data and preference data to the Java executable
p = Popen([
'java', '-jar', 'JavaCode/TeamFormationAlgorithms.jar', setup_data,
user_preferences
],
stdout=PIPE,
stderr=STDOUT)
# Adds teams to the database by parsing the console output of the Java executable
master_team = MasterTeam(space=space,
iterative_soulmates=iterative_soulmates,
number_of_members=group_size,
algorithm_index=algorithm_index)
master_team.save()
space.teams_decided = False
space.save()
for raw_line in p.stdout:
line = raw_line.decode("utf-8")
if line[0:2] == 'T:':
teammates = line[3:]
user_list = teammates.split(" ")
team = Team(space=space, master=master_team)
team.save()
for username in user_list:
if Member.objects.filter(username=username).exists():
user = Member.objects.get(username=username)
user.teams.add(team)
user.save()
team.save()
if line[0:2] == 'S:':
solo_names = line[3:]
solo_list = solo_names.split(" ")
for username in solo_list:
if not username == '':
user = Member.objects.get(username=username)
team = Team(space=space, master=master_team)
team.save()
user.teams.add(team)
master_team.save()
return redirect("/choose_teams/" + space.url + "/")
return render(
request, "TeamFormation.html", {
'member': member,
'msg': "\"" + setup_data + "\" \"" + user_preferences + "\""
})
class TestUserProfileChangeAttendingView(TestUserProfileView):
def setUp(self):
self.early_crew = Team(name='Early Crew',
description='Build stuff',
is_early_crew=True)
self.early_crew.save()
self.late_crew = Team(name='Late Crew',
description='Tear stuff down',
is_late_crew=True)
self.late_crew.save()
super(TestUserProfileChangeAttendingView, self).setUp()
def test_change_attending_view(self) -> None:
self.client.login(username='******', password='******')
expected_redirect_url = get_absolute_url_from_relative(reverse('user-profile-me'))
response = self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
}, follow=True, secure=True)
self.assertRedirects(response, expected_redirect_url)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
response = self.client.post(reverse('changed-attending'), {
'is-attending': 'off',
}, follow=True, secure=True)
self.assertRedirects(response, expected_redirect_url)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(include_soft_deleted=True)
self.assertTrue(attendance.deleted_at)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
response = self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
}, follow=True, secure=True)
self.assertRedirects(response, expected_redirect_url)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
def test_update_attendance_record(self) -> None:
self.client.login(username='******', password='******')
self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
}, follow=True, secure=True)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
attendance_form = AttendanceProfileForm({
field: '' for field in AttendanceProfileForm.Meta.fields
}, instance=attendance)
self.assertTrue(attendance_form.is_valid())
data = {'is-attending': 'on'}
data.update(attendance_form.data)
self.client.post(reverse('changed-attending'), data, follow=True, secure=True)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
def test_update_attendance_record_early_crew(self) -> None:
self.client.login(username='******', password='******')
self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
}, follow=True, secure=True)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
attendance_form = AttendanceProfileForm({
field: '' for field in AttendanceProfileForm.Meta.fields
}, instance=attendance)
attendance_form.data['job_preferences'] = []
attendance_form.data['arrival_date'] = 'wednesday1'
self.assertTrue(attendance_form.is_valid())
data = {'is-attending': 'on'}
data.update(attendance_form.data)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
self.client.post(reverse('changed-attending'), data, follow=True, secure=True)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
early_crew = self.user_profile.user.teams.filter(pk=self.early_crew.pk).first()
self.assertIsNotNone(early_crew)
attendance_form.data['arrival_date'] = 'sunday'
self.assertTrue(attendance_form.is_valid())
data.update(attendance_form.data)
self.client.post(reverse('changed-attending'), data, follow=True, secure=True)
early_crew = self.user_profile.user.teams.filter(pk=self.early_crew.pk).first()
self.assertIsNone(early_crew)
def test_update_attendance_record_late_crew(self) -> None:
self.client.login(username='******', password='******')
self.client.post(reverse('changed-attending'), {
'is-attending': 'on',
}, follow=True, secure=True)
self.user_profile.refresh_from_db()
attendance = self.user_profile.try_fetch_current_attendance(include_soft_deleted=True)
self.assertIsNotNone(attendance)
self.assertFalse(attendance.deleted_at)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
attendance_form = AttendanceProfileForm({
field: '' for field in AttendanceProfileForm.Meta.fields
}, instance=attendance)
attendance_form.data['job_preferences'] = []
attendance_form.data['departure_date'] = 'monday'
self.assertTrue(attendance_form.is_valid())
data = {'is-attending': 'on'}
data.update(attendance_form.data)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
self.client.post(reverse('changed-attending'), data, follow=True, secure=True)
self.assertEqual(len(list(self.user_profile.user.attendanceprofile_set.all())), 1)
late_crew = self.user_profile.user.teams.filter(pk=self.late_crew.pk).first()
self.assertIsNotNone(late_crew)
attendance_form.data['departure_date'] = 'sunday'
self.assertTrue(attendance_form.is_valid())
data.update(attendance_form.data)
self.client.post(reverse('changed-attending'), data, follow=True, secure=True)
late_crew = self.user_profile.user.teams.filter(pk=self.late_crew.pk).first()
self.assertIsNone(late_crew)
