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 my_cron_job():
today = date.today()
yesterday = date.today() - timedelta(days=1)
games = Schedule.objects.filter(date=yesterday)
for game in games:
time.sleep(1)
url = "https://api.sportradar.us/nba/trial/v7/en/games/{game.id}/boxscore.json?api_key={settings.API_KEY}"
if not game.game_data_saved:
try:
response = requests.get(url)
game_data = response.json()
data = {
'scheduled': game.id,
'lead_changes': game_data['lead_changes'],
'teams_string': f'{game.home.name} vs {game.away.name}',
'home_points': game_data['home']['points'],
'away_points': game_data['away']['points'],
'home_scoring': game_data['home']['scoring'],
'away_scoring': game_data['away']['scoring'],
}
game_data = GameData.objects.create(data)
game_data.get_rating()
game_data.check_OT()
print('Game Data Saved correctly ')
home_team = Team(name=game.home.name)
home_team.add_home_rating(game.id, game_data.rating)
away_team = Team(name=game.away.name)
away_team.add_away_rating(game.id, game_data.rating)
print('Team Ratings saved correctly ')
game.game_data_saved = True
game.save()
with open('success.json') as json_file:
data = json.load(json_file)
temp = data or []
y = {
'id': game.id,
'date': game.date,
'home': game.home.name,
'away': game.away.name
}
# appending data to file
temp.append(y)
except Exception as e:
# Get it to save error and ids to file
with open('error.json') as json_file:
data = json.load(json_file)
temp = data or []
y = {game.id, e}
# appending data to ids
temp.append(y)
print('Error as e')
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 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 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 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 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 for_teams_complete(request):
if request.method == 'POST' and request.user.is_authenticated():
team = Team(name=request.POST['team-name'],
email=request.POST['email'],
owner=request.user)
team.save()
user = User.objects.create_user(team.slug,
team.email,
str(uuid.uuid4()))
team.user = user
team.save()
send_mail('[Snipt] New team signup: {}'.format(team.name),
"""
Team: https://snipt.net/{}
Email: {}
""".format(team.slug, team.email),
'*****@*****.**',
['*****@*****.**'],
fail_silently=False)
return {
'team': team
}
else:
return HttpResponseBadRequest()
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,
})
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 testNumberofTeams(self):
teams = Team.objects.all()
team_count_before = teams.count()
a = Team(name="test team1")
b = Team(name="test team2")
c = Team(name="test team3")
d = Team(name="test team4")
e = Team(name="test team5")
a.save()
b.save()
c.save()
d.save()
e.save()
teams = Team.objects.all()
team_count_after = teams.count()
self.assertEqual(team_count_after, team_count_before + 5)
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 test_create_valid_team():
team = Team(name='Team1', grade=Grade.sixieme)
team.full_clean()
assert team.grade.bonus == Grade.sixieme.bonus
assert team.category == Category.Mindstorms
assert team.num is None
team.save()
assert team.num == 1
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 _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 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 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 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 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 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 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 for_teams_complete(request):
if request.method == 'POST' and request.user.is_authenticated():
team = Team(name=request.POST['team-name'],
email=request.POST['email'],
owner=request.user)
team.save()
user = User.objects.create_user(team.slug, team.email,
str(uuid.uuid4()))
team.user = user
team.save()
return {'team': team}
else:
return HttpResponseBadRequest()
def test_invite_count(self):
u1 = User(username='******',
password='******',
email='*****@*****.**')
u2 = User(username='******',
password='******',
first_name='123',
email='*****@*****.**')
t = Team(name='team')
u1.save()
u2.save()
t.save()
i1 = Invite(team=t, user=u1)
i2 = Invite(team=t, user=u2)
i1.save()
i2.save()
invite_count = Invite.objects.all().count()
self.assertEqual(invite_count, 2)
def setUp(self):
self.team = Team(name='test', slug='test')
self.team.save()
self.user = User.objects.all()[:1].get()
self.user.is_active = True
self.user.changes_notification = True
self.user.email = '*****@*****.**'
self.user.save()
self.tm = TeamMember(team=self.team, user=self.user)
self.tm.save()
v1 = Video.objects.all()[:1].get()
self.tv1 = TeamVideo(team=self.team, video=v1, added_by=self.user)
self.tv1.save()
v2 = Video.objects.exclude(pk=v1.pk)[:1].get()
self.tv2 = TeamVideo(team=self.team, video=v2, added_by=self.user)
self.tv2.save()
def post(self, request, competition_id):
from teams.models import Team
from operation.models import UserTeam
from users.models import UserProfile
signup_form = SignupForm(request.POST)
competition = Competition.objects.get(id=int(competition_id))
if signup_form.is_valid():
team = Team()
team.name = request.POST.get("name", "")
try:
if Team.objects.get(name=team.name):
return HttpResponse('{"status":"fail", "msg":"已有队名！"}',
content_type='application/json')
except:
pass
team.save()
user_team = UserTeam()
user_team.team = team
user_team.competition = Competition.objects.get(
id=int(competition_id))
students_str = request.POST.get("students", "")
student_strs = students_str.split(',')
user_team.save()
for student_str in student_strs:
student = UserProfile.objects.get(special_id=student_str)
if student:
user_team.students.add(student)
teacher_id = request.POST.get("teacher", "")
user_team.teacher = UserProfile.objects.get(
special_id=teacher_id).special_id
if user_team.teacher:
user_team.save()
else:
return HttpResponse('{"status":"fail", "msg":"未找到该老师！"}',
content_type='application/json')
return render(request, 'signup-success.html', {})
else:
return render(request, 'competition-signup.html', {
"competition": competition,
"signup_form": signup_form
})
def populate(teams, url, year):
for team in team_list:
url = base_url + team + "/" + str(year) + ".html"
bball_r = requests.get(url)
bball_soup = BeautifulSoup(bball_r.text, 'html.parser')
names = bball_soup.findAll('td', attrs={'data-stat': 'player'})
position = bball_soup.findAll('td', 'center')
height = bball_soup.findAll('td', attrs={'data-stat': 'height'})
weight = bball_soup.findAll('td', attrs={'data-stat': 'weight'})
born_on = bball_soup.findAll('td', attrs={'data-stat': 'birth_date'})
current_team = Team(team_name=team, season=year - 1)
current_team.save()
for (player, pos, ht, wt, bday) in zip(names, position, height, weight,
born_on):
new_player = Player(team=current_team,
player_name=player.getText(),
position=pos.getText(),
height=ht.getText(),
weight=wt.getText(),
birth_date=bday.getText()).save()
