def create_players():
"""
Creates all players.
:return: List of created players
"""
logger.info('Creating players...')
player_objects = []
for team in Team.objects.all():
players = fetch_players(team.id)
if players:
for player in players:
player_objects.append(
Player(
team=team,
name=player['name'],
position=dict(Player.POSITION)[player['position']],
jersey_number=player['jerseyNumber'] or None,
date_of_birth=player['dateOfBirth'] or None,
nationality=dict(Player.NATIONALITY)[player['nationality']],
contract_until=player['contractUntil'] or None,
market_value=re.sub('[^0-9]', '', player['marketValue']) if player['marketValue'] else None,
image=get_wikipedia_image(player['name']),
)
)
created_players = Player.objects.bulk_create(player_objects)
logger.info('Created ' + str(len(created_players)) + ' players')
return created_players
def player_scorecard(data):
try:
if data['espn_object_id'] != None:
data['espn_object_id'] = int(data['espn_object_id'])
else:
pass
except:
data['espn_object_id'] = None
if data['espn_object_id'] != None and len(
Player.objects.filter(espn_object_id=data['espn_object_id'])) == 1:
return Player.objects.get(espn_object_id=data['espn_object_id'])
elif len(Player.objects.filter(fullname=data['name'])) == 1:
return Player.objects.get(fullname=data['name'])
elif len(Player.objects.filter(card_name=data['name'])) == 1:
return Player.objects.get(card_name=data['name'])
elif len(Player.objects.filter(nickname=data['name'])) == 1:
return Player.objects.get(nickname=data['name'])
elif len(Player.objects.filter(name=data['name'])) == 1:
return Player.objects.get(name=data['name'])
else:
p = Player(**data)
p.save()
return p
def create_player(cls, ep):
username = ep.get('username', '')
username += '_ai_' + User.objects.make_random_password(length=8)
newu = User(username=username)
newu.save()
p = Player(user=newu, ptype=ep['ptype'])
p.save()
return p
def test_player_set(self):
test = Player(id=10,
name="player3",
description="player3 description",
mac_address="00:00:00:q1:ss:88",
status=False)
test.save()
self.assertEqual(test.name, "player3")
self.assertEqual(test.mac_address, "00:00:00:q1:ss:88")
def test_meeting_between_players_without_challenge(self):
user_1 = User.objects.create_user('user_1', '*****@*****.**',
'qweqweqwe')
user_2 = User.objects.create_user('user_2', '*****@*****.**',
'qweqweqwe')
pos = GEOSGeometry('POINT(37.00000 -5.00000)')
player_1 = Player(user=user_1, pos=pos)
player_1.save()
player_2 = Player(user=user_2, pos=pos)
player_2.save()
response = self.c.authenticate(self.get_username(player_1.pk),
self.pwd)
self.assertEqual(response.status_code, 200)
# step 1
response = self.c.post('/api/player/meeting/{0}/'.format(player_2.pk),
{})
self.assertEqual(response.status_code, 201)
response = self.c.authenticate(self.get_username(player_2.pk),
self.pwd)
self.assertEqual(response.status_code, 200)
# step 2
response = self.c.post('/api/player/meeting/{0}/'.format(player_1.pk),
{})
self.assertEqual(response.status_code, 200)
secret = Meeting.objects.get(player1=player_1, player2=player_2).secret
response = self.c.authenticate(self.get_username(player_1.pk),
self.pwd)
self.assertEqual(response.status_code, 200)
# step 3
response = self.c.post(
'/api/player/meeting/{0}/captured/{1}/'.format(
player_2.pk, secret), {})
self.assertEqual(response.status_code, 200)
response = self.c.authenticate(self.get_username(player_2.pk),
self.pwd)
self.assertEqual(response.status_code, 200)
# step 4
response = self.c.get(
'/api/player/meeting/{0}/qrclue/'.format(player_1.pk), {})
self.assertEqual(response.status_code, 200)
def new(request):
if request.method == 'GET':
return render(request, 'player/new.html',{})
elif request.method == 'POST':
if request.POST['name'] == '':
return render(request,'player/new.html',{'error':'You must have a username'})
else:
player = Player(name = request.POST['name'])
player.save()
return HttpResponseRedirect('/player/%s/' % player.id)
def session():
engine = create_engine('sqlite:///:memory:')
DeclarativeBase.metadata.create_all(engine)
session_cls = sessionmaker(bind=engine)
rep = PlayerRepository(session_cls())
test_player = Player(username=TEST_USERNAME, password=TEST_PASSWORD, country="Chile")
rep.db.add(test_player)
return rep
def add_player(request):
if request.method == 'POST':
player = Player()
player_form = PlayerForm(request.POST, instance=player)
if player_form.is_valid():
player_form.save()
return redirect('player')
else:
context = {'status_code': 201}
context = {'errorlist': _(u'Ошибка во введенных данных')}
return render_to_response('player/player_add.html', context, context_instance=RequestContext(request))
else:
player_form = PlayerForm()
context = {'title': _(u'Создание игрока'), 'player_form': player_form}
return render_to_response('player/player_add.html', context, context_instance=RequestContext(request))
def create_player(self, username, password, country, elo=None):
try:
player = Player(username=username,
password=password,
country=country,
elo=elo)
except AssertionError:
return False
try:
self.rep.db.add(player)
self.rep.db.commit()
except exc.IntegrityError:
self.rep.db.rollback()
return False
return True
def register_view(request):
form = RegistrationForm(request.POST or None)
if request.method == 'POST' and form.is_valid():
name_ = form.cleaned_data['name']
username_ = form.cleaned_data['username']
email_ = form.cleaned_data['email']
password_ = form.cleaned_data['password']
re_password_ = form.cleaned_data['re_password']
user_type_ = form.cleaned_data['user_type']
user = User.objects.create_user(first_name=name_,
username=username_,
password=password_,
email=email_)
activation_string = user.email + SALT
activation_key = md5(activation_string.encode("ascii")).hexdigest()
activation_link = BASE_URL + "/accounts/activate?user="******"&activation_key=" + activation_key
print("Activation Url - " + activation_link)
with mail.get_connection() as connection:
mail.EmailMessage(
"GameStop - Activate your account",
"To activate your account, follow the link - " +
activation_link,
"*****@*****.**",
[email_],
connection=connection,
).send()
if (user_type_ == '1'):
dev_ = Developer(user=user)
dev_.registered = False
dev_.activation_key = activation_key
dev_.save()
else:
player_ = Player(user=user)
player_.registered = False
player_.activation_key = activation_key
player_.save()
#login(request, user)
return HttpResponseRedirect("/home")
context = {'form': form}
return render(request, 'accounts/register.html', context)
def setUp(self):
# User
self.username = "******"
self.email = "*****@*****.**"
self.password = "******"
self.user = User._default_manager.create_user(
username=self.username,
email=self.email,
)
self.user.set_password(self.password)
self.user.save()
# Board
self.board_name = 'boardcito'
self.board_owner = self.user
self.board = Board(
name=self.board_name,
owner=self.board_owner
)
self.board.save()
# Room
self.room = Room(
name='roomcito',
board=self.board,
game_has_started=True,
owner=self.user,
)
self.room.save()
# Game
self.game = Game(room=self.room)
self.game.save()
# Player
self.player = Player(
user=self.user,
game=self.game,
colour='colorcito'
)
self.player.save()
self.client.force_authenticate(self.user)
def __init__(self):
self.board = Board()
self.game = Game(AIPlayer(deep_blue_game_piece), Player(opponent_game_piece))
def post(cls, request, ev_id=None):
ev = request.data
if ev_id:
e = get_object_or_404(Event, pk=ev_id)
else:
e = Event()
for k, v in ev.items():
if k in ['pk', 'players', 'owners', 'task_id', 'place', 'game']:
continue
if 'date' in k:
try:
v = datetime.datetime.strptime(v, '%Y-%m-%d %H:%M %z')
except:
v = parse_datetime(v)
setattr(e, k, v)
# setting the place
place = ev.get('place', None)
if place:
if type(place) == str:
place = GEOSGeometry(place)
else:
place = GEOSGeometry(str(place['geometry']))
if isinstance(place, Polygon):
place = MultiPolygon(place)
e.place = place
# setting the game
g = ev.get('game', None)
if g:
g = get_object_or_404(Game, pk=g['pk'])
e.game = g
e.save()
e.owners.add(request.user)
players_ids = []
for ep in ev.get('players', []):
pk = ep['pk']
if pk < 0:
# negative pk will create the player
p = Player()
p = cls.create_player(ep)
else:
p = Player.objects.get(pk=pk)
p.about = ep['username']
p.set_position(*ep['pos'])
players_ids.append(p.pk)
e.set_playing(p, avoid_playing_event=True)
Clue.objects.filter(player=p, event=e).delete()
for ch in ep.get('challenges', []):
c = Challenge.objects.get(pk=ch['pk'], games=e.game)
clue = Clue(player=p, event=e, challenge=c, main=True)
clue.save()
players = e.players.exclude(membership__player__pk__in=players_ids)
for p in players:
p.user.delete()
return Response({'status': 'ok'})
def parse(self, excel):
# search player nick name from title of PS excel audit file
# working with RU files
head = pandas.read_excel(excel, nrows=0, usecols=[0])
player = head.columns[0]
lang = detect(player)
date_format = [
r'%d.%m.%Y %I:%M %p', r'%Y/%m/%d %I:%M %p', r'%Y-%m-%d %H:%M:%S'
]
if lang == 'ru':
player = re.search(r'для (\S+)', player)
else:
player = re.search(r'Audit .(\S+). ', player)
player = player.group(1)
# search for player object
# if there is now player - create new instance of Player model
if 'pk' in self.kwargs.keys():
player_obj = Player.objects.get(pk=self.kwargs['pk'])
if player_obj.name != player:
player_obj.name = player_obj.name + ', ' + player
player_obj.save()
else:
player_obj = Player.objects.filter(name=player)
if len(player_obj) < 1:
player_obj = Player(name=player)
player_obj.save()
else:
player_obj = player_obj[0]
# cutin empty colums
excel_rows = pandas.read_excel(excel, header=2, parse_dates=False)
excel_rows.dropna(axis=1, how='all', inplace=True)
excel.close()
# set list of keys
columns = excel_rows.columns.values.tolist()
keys = [
'date_played',
'action',
'action_number',
'game',
'curency',
'summary',
's_coins',
't_money',
'w_money',
'cashier',
'get_s_coins',
't_money_cashier',
'w_money_cashier',
]
# queryset of patterns
pattern_query = PatternBody.objects.all()
# run loop to create PlayerAudit instences,
# format date to date field and write action type
for _, row in excel_rows.iterrows():
kwargs = {}
for key in range(len(keys)):
kwargs[keys[key]] = row[columns[key]]
for item in date_format:
try:
kwargs['date_played'] = datetime.strptime(
str(kwargs[keys[0]]), item)
except ValueError:
continue
for item in pattern_query:
if item.pattern in kwargs['action']:
kwargs['action_type'] = item.pattern_type.pattern_name
break
audit = PlayerAudit(player=player_obj, **kwargs)
audit.save()
