def setUp(self):
self.superuser, created = User.objects.get_or_create(
username='******', is_superuser=True)
self.user1 = User.objects.all()[0]
self.user2 = User.objects.all()[1]
self.superuser2, x = User.objects.get_or_create(username='******',
is_superuser=True)
self.regular_user = User.objects.filter(
is_active=True, is_superuser=False).exclude(
pk__in=[x.pk for x in [self.user1, self.user2]])[0]
self.team1 = Team(name='test11', slug='test11')
self.team1.save()
self.team1_member = TeamMember(team=self.team1, user=self.user1)
self.team1_member.save()
self.team2 = Team(name='test22', slug='test22')
self.team2.save()
self.team2_member = TeamMember(team=self.team2, user=self.user2)
self.team2_member.save()
self.video = Video.objects.all()[0]
for user in User.objects.all():
user.set_password(user.username)
user.save()
def setUp(self):
self.client.login(username='******', password='******')
self.user = auth.get_user(self.client)
self.team = Team(name='team-with-one-user')
self.team.save()
self.team.members.add(self.user)
self.team.save()
def new_team(teams=[], ty="CAMPUS"):
for team in teams:
c, made = City.objects.get_or_create(name=team[2], state="CA")
loc, made = Locality.objects.get_or_create(city=c)
t = Team(name=team[0], code=team[1], type=ty, locality=loc)
t.save()
def scrape_teams(week_number, season):
page_id = str(1467)
week = str(week_number)
url = 'http://www.tff.org/Default.aspx?pageID=' + page_id + '&hafta=' + week
selector = '#ctl00_MPane_m_1467_9827_ctnr_m_1467_9827_Panel1 table tr td b a'
contents = requests.get(url).text
soup = BeautifulSoup(contents, 'lxml')
team_links = soup.select(selector)
for team_link in team_links:
link = 'http://www.tff.org/' + team_link['href']
name = re.sub(r'\d+\.', '', team_link.get_text())
if not Team.objects.filter(tff_link=link).exists():
team = Team(name=name,
country=Country.objects.get(name='Turkey'),
tff_link=link)
team.save()
else:
team = Team.objects.filter(tff_link=link).first()
if not TeamAlternativeName.objects.filter(name=name).exists():
alternative_name = TeamAlternativeName(name=name, team=team)
alternative_name.save()
def post(self, request):
form = self.form_class(request.POST)
if form.is_valid():
Team = form.instance
if len(Team.name) < 5:
messages.error(self.request,
'Your team name must be 5 or more characters')
return redirect('teams:create')
Team.founder = self.request.user
Team.save()
invite = TeamInvite()
invite.expire = timezone.now()
invite.user = self.request.user
invite.captain = 'founder'
invite.hasPerms = True
invite.accepted = True
invite.inviter = self.request.user
invite.inviter_id = self.request.user.id
invite.team_id = Team.id
invite.save()
messages.success(self.request,
'Your Team has been created successfully')
return redirect('teams:list')
class MatchModelTestCase(TestCase):
def setUp(self):
self.phase = Tournament.FIRST_PHASE
self.group_letter = 'A'
self.team_a_name = 'Brazil'
self.team_b_name = 'Germany'
self.tournament = Tournament(phase=self.phase)
self.tournament.save()
self.group = Group(letter=self.group_letter)
self.group.tournament_id = self.tournament.id
self.group.save()
self.team_a_goals = random.randint(0, 10)
self.team_b_goals = random.randint(0, 10)
self.team_a = Team(name=self.team_a_name)
self.team_b = Team(name=self.team_b_name)
self.team_a.group_id = self.group.id
self.team_b.group_id = self.group.id
self.team_a.save()
self.team_b.save()
def test_model_can_create_match(self):
old_count = Match.objects.count()
match = Match(away_team=self.team_a,
home_team=self.team_b,
away_team_goals=self.team_a_goals,
home_team_goals=self.team_b_goals,
tournament=self.tournament,
phase=self.tournament.phase)
match.save()
new_count = Match.objects.count()
created_match = Match.objects.last()
self.assertNotEquals(old_count, new_count)
self.assertEquals(created_match.phase, self.tournament.phase)
self.assertEquals(created_match.away_team.id, self.team_a.id)
self.assertEquals(created_match.away_team_goals, self.team_a_goals)
self.assertEquals(created_match.home_team.id, self.team_b.id)
self.assertEquals(created_match.home_team_goals, self.team_b_goals)
self.assertFalse(created_match.played)
self.assertIsNone(created_match.winner)
def test_model_cannot_create_match_without_teams(self):
match_without_teams = Match()
with self.assertRaises(IntegrityError):
match_without_teams.save()
def test_model_can_create_match_without_input_goals(self):
expected_amount_goals = 0
match_without_goals = Match(away_team=self.team_a,
home_team=self.team_b,
tournament=self.tournament,
phase=self.tournament.phase)
match_without_goals.save()
created_match = Match.objects.last()
self.assertEquals(created_match.away_team_goals, expected_amount_goals)
self.assertEquals(created_match.away_team_goals, expected_amount_goals)
self.assertEquals(created_match.phase, self.phase)
def test_join_request_sent(self):
u = User(username='******',
password='******',
email='*****@*****.**')
t = Team(name='team')
u.save()
t.save()
j = JoinRequest(team=t, user=u)
j.save()
self.assertEqual(j.user, u)
def _create_base_team(self):
self.team = Team(slug="new-team",
membership_policy=4,
video_policy=1,
name="New-name")
self.team.save()
user, created = User.objects.get_or_create(
username=self.auth["username"])
TeamMember.objects.create_first_member(self.team, user)
return self.team
def mutate(self, info, name, email, affiliation, accesscode=None):
validate_user_is_admin(info.context.user)
try:
newTeam = Team(name=name, email=email, affiliation=affiliation, accesscode=''.join(random.choices(string.ascii_uppercase + string.digits, k=10)))
newTeam.save()
code = 0
except:
code = 1
return AddTeam(code=code)
def makeTeam(team_name, hidden, accesscode):
team = Team(name=team_name, hidden=hidden)
team.save()
AccessCode(team=team, value=accesscode).save()
for x in range(1, 6):
makeUser("user" + str(x) + "_" + team_name,
"user" + str(x) + "-" + team_name + "@yactf.com", "password",
team, True)
return team
def makeAdminUser():
admin = User.objects.create_superuser("admin", "*****@*****.**",
"yacfadmin")
admin.first_name = "Admin"
admin.save()
team = Team(name='Admin', hidden=True)
team.save()
profile = Profile(user=admin, team=team, verified=True, hidden=True)
profile.save()
def test_join_request_creation(self):
u = User(username='******',
password='******',
email='*****@*****.**')
t = Team(name='team')
u.save()
t.save()
j = JoinRequest(team=t, user=u)
j.save()
join_request_count = JoinRequest.objects.all().count()
self.assertEqual(join_request_count, 1)
def scrape_team(link, league):
bhv_id = parsing.parse_team_bhv_id(link)
name = link.text
url = Team.build_source_url(league.bhv_id, bhv_id)
html = http.get_text(url)
dom = parsing.html_dom(html)
game_rows = parsing.parse_game_rows(dom)
short_team_names = parsing.parse_team_short_names(game_rows)
short_team_name = Team.find_matching_short_name(name, short_team_names)
Team.create_or_update_team(name, short_team_name, league, bhv_id, LOGGER)
def saveTeam(self):
if self.thisTeamInDb():
print("already matched!")
else:
print("saving...")
t = Team(name=self.name,
nickname=self.nickname,
city=self.city,
division=self.division,
twitterLink=self.twitterLink)
t.save()
print(t)
def regConTeam(request):
name = request.POST['name']
major = request.POST['major']
captain = request.POST['captain']
memCount = request.POST['memCount']
qs = Team(t_name=name,
t_major=major,
t_captain=captain,
t_memCount=memCount)
qs.save()
return HttpResponseRedirect(reverse('teams:teamAll'))
def test_join_request_identity(self):
#we should change this, you shouldnt be able to send a join request to your own team
u = User(username='******',
password='******',
email='*****@*****.**')
t = Team(name='team')
u.save()
t.save()
t.members.add(u)
j = JoinRequest(team=t, user=u)
j.save()
join_request_count = JoinRequest.objects.all().count()
self.assertEqual(join_request_count, 1)
def test_invite_identity(self):
#we should change this, you shouldnt be able to invite yourself to a team you created
u1 = User(username='******',
password='******',
email='*****@*****.**')
t = Team(name='team')
u1.save()
t.save()
t.members.add(u1)
i = Invite(team=t, user=u1)
i.save()
invite_count = Invite.objects.all().count()
self.assertEqual(invite_count, 1)
def mutate(self, info, name, email, affiliation, accesscode=None):
validate_user_is_admin(info.context.user)
team = Team(name=name, email=email, affiliation=affiliation)
team.save()
if accesscode:
AccessCode(team=team, value=accesscode).save()
else:
AccessCode(team=team,
value=''.join(
random.choices(string.ascii_uppercase +
string.digits,
k=10))).save()
return AddTeam(code=0)
def test_two_to_one(self):
name = 'irrelevant'
short_names = ['two', 'one', 'two']
actual = Team.find_matching_short_name(name, short_names)
self.assertEqual('two', actual)
def test_same_count_depend_on_name_other(self):
name = 'TSV Eins'
short_names = ['eins', 'zwei', 'zwei', 'eins']
actual = Team.find_matching_short_name(name, short_names)
self.assertEqual('eins', actual)
def test_three_options_max_count(self):
name = 'irrelevant'
short_names = ['four', 'one', 'four', 'two', 'three', 'four']
actual = Team.find_matching_short_name(name, short_names)
self.assertEqual('four', actual)
def insert_into_database(teams: List[Dict[Any, Any]]) -> Dict[int, Team]:
all_teams = clean_teams(teams)
all_teams = (Team(external_id=team['TeamId'],
team_name=team['TeamName'],
team_icon_url=team['TeamIconUrl']) for team in all_teams)
created_teams = Team.objects.bulk_create(all_teams)
return {team.external_id: team for team in created_teams}
def edit_members(request, slug):
team = Team.get(slug, request.user)
if not team.is_member(request.user):
raise Http404
qs = team.members.select_related()
ordering = request.GET.get('o')
order_type = request.GET.get('ot')
if ordering == 'username' and order_type in ['asc', 'desc']:
pr = '-' if order_type == 'desc' else ''
qs = qs.order_by(pr + 'user__first_name', pr + 'user__last_name',
pr + 'user__username')
elif ordering == 'role' and order_type in ['asc', 'desc']:
qs = qs.order_by(('-' if order_type == 'desc' else '') + 'is_manager')
extra_context = {
'team': team,
'ordering': ordering,
'order_type': order_type
}
return object_list(request,
queryset=qs,
paginate_by=MEMBERS_ON_PAGE,
template_name='teams/edit_members.html',
template_object_name='members',
extra_context=extra_context)
def add_video(request, slug):
team = Team.get(slug, request.user)
if not team.is_member(request.user):
raise Http404
if not team.can_add_video(request.user):
messages.error(request, _(u'You can\'t add video.'))
return {'team': team}
initial = {
'video_url': request.GET.get('url', ''),
'title': request.GET.get('title', '')
}
form = AddTeamVideoForm(team,
request.POST or None,
request.FILES or None,
initial=initial)
if form.is_valid():
obj = form.save(False)
obj.added_by = request.user
obj.save()
return redirect(obj)
return {'form': form, 'team': team}
def delete(self, request, pk):
try:
is_agency_admin = Agency.objects.filter(
admin=request.user).exists()
is_permission = is_agency_admin | request.user.is_superuser
if not is_permission:
return Response(
{
"result": False,
"errorCode": 3,
"errorMsg": "You don't have the permission."
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
Team(id=pk).delete()
return Response({
"result": True,
"data": {
"msg": "Team removed successfully."
}
})
except ObjectDoesNotExist:
return Response(
{
"result": False,
"errorCode": 1,
"errorMsg": "Invalid team id."
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def edit(request, slug):
team = Team.get(slug, request.user)
if not team.is_member(request.user):
raise Http404
if not team.is_manager(request.user):
return {'team': team}
if request.method == 'POST':
if request.user.is_staff:
form = EditTeamFormAdmin(request.POST,
request.FILES,
instance=team)
else:
form = EditTeamForm(request.POST, request.FILES, instance=team)
if form.is_valid():
form.save()
messages.success(request, _(u'Your changes have been saved'))
return redirect(team.get_edit_url())
else:
if request.user.is_staff:
form = EditTeamFormAdmin(instance=team)
else:
form = EditTeamForm(instance=team)
return {'form': form, 'team': team}
def detail_members(request, slug):
#just other tab of detail view
q = request.REQUEST.get('q')
team = Team.get(slug, request.user)
qs = team.members.all()
if q:
qs = qs.filter(Q(user__first_name__icontains=q)|Q(user__last_name__icontains=q) \
|Q(user__username__icontains=q)|Q(user__biography__icontains=q))
extra_context = widget.add_onsite_js_files({})
extra_context.update({'team': team, 'query': q})
if team.video:
extra_context['widget_params'] = base_widget_params(
request, {
'video_url': team.video.get_video_url(),
'base_state': {}
})
return object_list(request,
queryset=qs,
paginate_by=MEMBERS_ON_PAGE,
template_name='teams/detail_members.html',
extra_context=extra_context,
template_object_name='team_member')
def makeUser(user_name, user_email, user_password, hidden):
# Validate admin user command line arguments
validate_username(user_name)
validate_email(user_email)
validate_password(user_password)
# Create team for admin user
token = str(uuid.uuid4())
while Team.objects.filter(token__iexact=token).exists():
token = str(uuid.uuid4())
user_team = Team(name=user_name, token=token, hidden=hidden)
user_team.save()
user = User(username=user_name,
email=user_email,
team=user_team,
hidden=hidden)
user.set_password(user_password)
user.save()
# Push admin team to rethinkdb database
connection = r.connect(host=RDB_HOST, port=RDB_PORT)
try:
r.db(CTF_DB).table('teams').insert({
'sid':
user.team.id,
'name':
user.team.name,
'points':
user.team.points,
'hidden':
hidden,
'correct_flags':
user.team.correct_flags,
'wrong_flags':
user.team.wrong_flags,
'solved': [],
'created':
format(user.team.created, 'U')
}).run(connection)
except RqlRuntimeError as e:
raise Exception('Error adding user team to realtime database: %s' %
(e))
finally:
connection.close()
def setUp(self):
self.team = Team(team_name="TestTeam")
self.team.save()
self.service = Service(
service_name="1 year subscription",
price=10000,
service_description="Price per team per year. Pay annually and \
save over 20%! Unlimited number of team members.")
self.service.save()
self.payer = User(username="******",
email="*****@*****.**",
password="******")
self.payer.save()
# Log in user
self.client.force_login(self.payer, backend=None)
def create_teams_normal(request):
template_name = 'index.html'
heading_message = 'Welcome to tournament'
# max_number_teams = 2 cv
if request.method == 'GET':
formset = TeamFormset(request.GET or None)
elif request.method == 'POST':
formset = TeamFormset(request.POST)
list_teams = []
team_a = []
team_b = []
if formset.is_valid():
try:
# a_div = Division.objects.get_or_create(name="A")
# b_div = Division.objects.get_or_create(name="A")
a_div = Division.objects.get(name="A")
b_div = Division.objects.get(name="B")
except:
Division(name = "A").save()
Division(name = "B").save()
a_div = Division.objects.get(name="A")
b_div = Division.objects.get(name="B")
for form in formset:
name = form.cleaned_data.get('name')
list_teams.append(name)
random.shuffle(list_teams)
team_a = list_teams[:9]
team_b = list_teams[9:]
for form in formset:
# extract name from each form and save
name = form.cleaned_data.get('name')
# save book instance
if name:
if name in team_a:
Team(name=name, division=a_div).save()
else:
Team(name=name, division=b_div).save()
# redirect('divisions')
# once all books are saved, redirect to book list view
return redirect('divisions')
return render(request, template_name, {
'formset': formset,
'heading': heading_message,
})
