def login_user(request):
err = {}
if "username" not in request.data:
err["username"] = ["This field is required."]
if "password" not in request.data:
err["password"] = ["This field is required."]
if err:
return Response(data=err, status=status.HTTP_400_BAD_REQUEST)
try:
user = DvUser.objects.get(username=request.data["username"])
except DvUser.DoesNotExist:
return Response(
data={"username": ["No such username exists."]},
status=status.HTTP_400_BAD_REQUEST,
)
if bcrypt.hashpw(request.data["password"].encode("utf-8"), user.password.encode("utf-8")) == user.password.encode("utf-8"):
ser = DvUserSerializer(user)
token = "".join(
[random.choice(string.ascii_letters) for _ in range(32)]
)
new_token = Session(user=user, key=token)
new_token.save()
return Response({"token": token})
else:
return Response(
data={"password": ["Incorrect password."]},
status=status.HTTP_400_BAD_REQUEST,
)
def new_workout(request):
print(request.user)
workout_name = request.POST.get('name')
if workout_name is None:
workout_name = 'New Workout'
new_session = Session(name=workout_name, user=request.user)
new_session.save()
return HttpResponse(json.dumps(SessionSerializer(new_session).data))
def create(self, validated_data: Dict) -> Session:
page_size = validated_data[
'page_size'] if 'page_size' in validated_data else None
location = validated_data[
'location'] if 'location' in validated_data else None
session = Session(user_id=validated_data['user_id'],
page_size=page_size,
location=location)
session.save()
return session
def login_user(request):
print(request.data["password"])
err = {}
if "username" not in request.data:
err["username"] = ["This field is required."]
if "password" not in request.data:
err["password"] = ["This field is required."]
if "role" not in request.data:
err["role"] = ["This field is required."]
if err:
return Response(data=err, status=status.HTTP_400_BAD_REQUEST)
try:
user = DvUser.objects.get(username=request.data["username"])
except DvUser.DoesNotExist:
return Response(
data={"username": ["No such username exists."]},
status=status.HTTP_400_BAD_REQUEST,
)
if bcrypt.hashpw(request.data["password"].encode("utf-8"), user.password.encode("utf-8")) == user.password.encode("utf-8"):
ser = DvUserSerializer(user)
token = "".join(
[random.choice(string.ascii_letters) for _ in range(32)]
)
new_token = Session(user=user, key=token)
new_token.save()
try:
user = DvUser.objects.get(username=request.data["username"])
check_role = UserRoles.objects.get(user_id=user)
assignrole = Role.objects.get(name="admin").role_id
if(check_role.role_id == assignrole):
return Response({"token": token}, status=status.HTTP_201_CREATED)
else:
if(request.data["role"] == "User"):
return Response({"token": token}, status=status.HTTP_201_CREATED)
else:
return Response(
data={"username": ["You've no admin access!"]},
status=status.HTTP_400_BAD_REQUEST,)
except UserRoles.DoesNotExist:
if(request.data["role"] == "User"):
return Response({"token": token}, status=status.HTTP_201_CREATED)
else:
return Response(
data={"username": ["You've no admin access!"]},
status=status.HTTP_400_BAD_REQUEST,)
else:
return Response(
data={"password": ["Incorrect password."]},
status=status.HTTP_400_BAD_REQUEST,
)
def start_session(self, request):
session = Session()
session.start = datetime.datetime.now()
players = [player for player in request.data['players']]
players.append(Player.objects.get(user=request.user))
session.save()
for player in players:
link = PlayerSessionLink()
link.player = player
link.session = self
link.save()
return Response({"message": "Session started"},
status=status.HTTP_201_CREATED)
def add_sessions_speakers_and_tags():
first_tag = Tag(pk=uuid.uuid4(), description="javascript")
last_tag = Tag(pk=uuid.uuid4(), description="python")
first_tag.save()
last_tag.save()
first_session = Session(pk=uuid.uuid4(), name="first")
last_session = Session(pk=uuid.uuid4(), name="last")
first_session.save()
last_session.save()
first_session.tags.add(first_tag)
last_session.tags.add(last_tag)
first_session.save()
last_session.save()
first_speaker = Speaker(pk=uuid.uuid4(), name="foo", session=first_session)
last_speaker = Speaker(pk=uuid.uuid4(), name="bar", session=last_session)
first_speaker.save()
last_speaker.save()
return first_session, last_session, first_speaker, last_speaker, first_tag, last_tag
def test_successful_login(self):
body = {"username": "******", "password": "******"}
response = self.post(body)
assert response.code == 200
body = loads(response.body)
assert "token" in body
assert Services.redis.exists(f"{body['token']}")
session = Session.get(body["token"])
assert session.username == "admin"
assert session.role == 3
def list(self, request):
try:
user_id = int(request.query_params.get('user'))
session = Session.find_by_user(user_id)
arr_preferences = session.preferences.values()
preference_set = PreferenceSerializer(
[Preference for Preference in arr_preferences if Preference.type == "LIKE"], many=True).data
return Response(preference_set, status=status.HTTP_200_OK)
except Exception as error:
print(error)
raise APIException(error)
finally:
sys.stdout.flush()
def create(self, request):
try:
serializer = PreferenceSerializer(
data=request.data,
partial=True
)
if serializer.is_valid():
preference: Preference = serializer.save()
user_id = int(request.data.get('user'))
session = Session.find_by_user(user_id)
session.preferences[preference.restaurant_id] = preference
session.save()
return Response({'success': True}, status=status.HTTP_200_OK)
raise APIException(str(serializer.errors),
code=status.HTTP_400_BAD_REQUEST)
except Exception as error:
print(error)
raise APIException(error)
finally:
sys.stdout.flush()
def retrieve(self, request: Request):
try:
user_id = int(request.query_params.get('user_id'))
session = Session.find_by_user(user_id)
page_size = request.query_params.get('page_size')
page_size = int(page_size) if page_size else None
if session is None:
ip_address, _is_routable = get_client_ip(request)
location = geocoder.ip(ip_address)
if not location.lat:
location = geocoder.ip('me')
print('create a session for {}, ip: {}'.format(
location.city, ip_address))
serializer = SessionSerializer(
data={
'user_id': user_id,
'page_size': page_size,
'location': location.latlng
}
)
if not serializer.is_valid():
raise APIException(str(serializer.errors),
code=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response(
serializer.data, status=status.HTTP_201_CREATED)
else:
if page_size:
session.page_size = page_size
serializer = SessionSerializer(instance=session)
session.save()
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as error:
print(error)
raise APIException(error)
finally:
sys.stdout.flush()
def seconds(request):
global max_rounds
if 'round' not in request.session or request.session['round'] == 0:
request.session['round'] = 0
request.session['player'] = 0
request.session['scoreteam1'] = 0
request.session['scoreteam2'] = 0
request.session['team1'] = []
request.session['team2'] = []
api_session = Session()
api_session.save()
request.session['token'] = api_session.id
request.session['secret'] = api_session.secret
# get teams
team1_players = []
for i in range(1, 5):
if request.POST[f't1{i}'] == '':
message = 'Please enter four players for each team'
return redirect('index')
team1_players.append(request.POST[f't1{i}'])
request.session['team1'] = team1_players
team2_players = []
for j in range(1, 5):
if request.POST[f't2{j}'] == '':
message = 'Please enter four players for each team'
return redirect('index')
team2_players.append(request.POST[f't2{j}'])
request.session['team2'] = team2_players
hits = request.POST.getlist("words")
round = request.session['round']
# append points
if round % 2 == 0:
points = len(hits)
request.session['scoreteam1'] += points
if round != max_rounds:
request.session['turn'] = request.session['team1'][int(round / 2)]
else:
points = len(hits)
request.session['scoreteam2'] += points
if round != max_rounds:
request.session['turn'] = request.session['team2'][int(round / 2)]
# determine winner
if round == max_rounds:
request.session['round'] = 0
team1_points = request.session['scoreteam1']
team2_points = request.session['scoreteam2']
request.session['scoreteam1'] = 0
request.session['scoreteam2'] = 0
request.session['turn'] = 0
request.session['team1'] = []
request.session['team2'] = []
if team1_points == team2_points:
tie = True
return render(request, "game/end.html", {'tie': tie})
elif team1_points > team2_points:
winner_name = 'Team 1'
winner_points = team1_points
loser_name = 'Team 2'
loser_points = team2_points
return render(
request, "game/end.html", {
'winner_name': winner_name,
'winner_points': winner_points,
'loser_name': loser_name,
'loser_points': loser_points
})
elif team1_points < team2_points:
winner_name = 'Team 2'
winner_points = team2_points
loser_name = 'Team 1'
loser_points = team1_points
return render(
request, "game/end.html", {
'winner_name': winner_name,
'winner_points': winner_points,
'loser_name': loser_name,
'loser_points': loser_points
})
# get cards to play with
token = request.session['token']
secret = request.session['secret']
player = request.session['turn']
# link = request.build_absolute_uri(reverse("api:get-card"))
# card = requests.get(f"{link}?token={token}&secret={secret}").json()['words']
card = Session.objects.get(id__exact=token,
secret__exact=secret).get_card().json()['words']
request.session['round'] += 1
return render(request, "game/seconds.html", {
'card': card,
'player': player
})