Gecko [ 35.178.45.201 ]

Name	Size	Permission
data	[ DIR ]	drwxrwxr-x
migrations	[ DIR ]	drwxrwxr-x
static	[ DIR ]	drwxrwxr-x
templates	[ DIR ]	drwxrwxr-x
__init__.py	0 B	-rw-rw-r--
admin.py	370 B	-rw-rw-r--
apps.py	89 B	-rw-rw-r--
models.py	2.68 KB	-rw-rw-r--
tests.py	6.94 KB	-rw-rw-r--
urls.py	804 B	-rw-rw-r--
views.py	8.78 KB	-rw-rw-r--

Code Editor : views.py

import os
import urllib.request
import json
from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
from django.urls import reverse
from django.views import generic
from django.utils import timezone
from django.core import serializers
from django.contrib.auth.decorators import login_required
from django.contrib.auth import authenticate, login, logout
from django.template import RequestContext
from jsonschema import validate
from uuid import uuid4
from datetime import datetime
from django.contrib.auth.models import User

from .models import Event, Player, EventOption, Bet

def get_new_events(request):
	# username = "mike.okafor88"
	# response = {}
	# token = "6d9c1cbe2b43302c44f5afed8c9aeb0e"
	# base_url = "https://api.soccersapi.com/v2.2/"
	# url = f"{base_url}fixtures/?user={username}&token={token}&t=season&season_id=7225"
	# # try:
	# response = urllib.request.urlopen(url)
	filepath = os.path.dirname(os.path.realpath(__file__)) + "/data/football.json";
	with open(filepath, "r") as fh:
		data = json.load(fh)
		for event in data:
			teamA = event['teams']['home']['name']
			image = event['teams']['home']['img']
			teamB = event['teams']['away']['name']
			start = datetime.fromtimestamp(event['time']['timestamp'])
			end = datetime.fromtimestamp(event['time']['timestamp'])
			name = f"{teamA} VS {teamB}"
			e = Event(name=name, image=image, start_date=start, end_date=end)
			e.save()
			e.eventoption_set.create(name=f"{teamA} wins")
			e.eventoption_set.create(name=f"{teamB} wins")
			e.eventoption_set.create(name="Draw")

return HttpResponse("done")
		
	# except AttributeError as e:
	# 	print("hello")
	# 	print(e)

# return response.json()

def index(request):
	evs = Event.objects.all()
	# evs = Event.objects.raw(f"""SELECT 1 as id, 
	# 	T.id, T.name as pn, 
	# 	COUNT(T.id) as ck, 
	# 	SUM(no_bets) as cnt 
	# 	FROM 
	# 		(SELECT e.id, 
	# 		e.name, COUNT(e.id) as no_bets 
	# 		FROM betting_event e 
	# 		INNER JOIN betting_eventoption eo 
	# 		ON e.id = eo.event_id 
	# 		INNER JOIN betting_playerbet pb 
	# 		ON eo.id = pb.selection_id 
	# 		INNER JOIN betting_bet b 
	# 		ON pb.bet_id = b.id 
	# 		AND b.private = 0 
	# 		GROUP BY e.id, e.name, b.id) 
	# 	AS T GROUP BY T.id, T.name""")
	return render(request, 'events/index.html', {"events": evs})

@login_required
def detail(request, event_id):
	event = get_object_or_404(Event, pk=event_id)
	player = Player.objects.get(user=request.user)

bets = Event.objects.raw(f"""SELECT e.id, b.bet_key, max(pb.amount) as max_bet, b.type,  
		MIN(pb.amount) AS min_bet, 
		COUNT(pb.id) AS total_bets, 
		SUM(pb.amount) AS total_stake, 
		b.initiator_id,
		GROUP_CONCAT(eo.name SEPARATOR ', ') AS selected 
		FROM betting_event as e
		INNER JOIN betting_eventoption as eo
		ON e.id = eo.event_id
		INNER JOIN betting_playerbet as pb 
		ON eo.id = pb.selection_id 
		INNER JOIN betting_bet b 
		ON pb.bet_id = b.id
		INNER JOIN betting_player p
		ON pb.player_id = p.id
		WHERE e.id = '{event_id}'
		AND b.private = 0
		GROUP BY b.bet_key, b.initiator_id, e.id""")

# my_bets = Event.objects.raw(f"""SELECT e.id, b.bet_key, b.private, 
	# 	COUNT(pb.id) AS total_bets, eo.name as selected,
	# 	pb.amount AS amount,
	# 	pb.date_placed,
	# 	b.initiator_id
	# 	FROM betting_eventoption as eo 
	# 	INNER JOIN betting_playerbet as pb 
	# 	ON eo.id = pb.selection_id 
	# 	INNER JOIN betting_bet b 
	# 	ON pb.bet_id = b.id
	# 	INNER JOIN betting_event e
	# 	ON eo.event_id = e.id
	# 	LEFT JOIN betting_player p
	# 	ON pb.player_id = p.id
	# 	WHERE e.id = '{event_id}'
	# 	AND p.id = '{player.id}'
	# 	AND b.initiator_id = '{player.id}'
	# 	GROUP BY b.bet_key, b.initiator_id, e.id, eo.name, pb.amount, pb.date_placed""")
	
	return render(request, 'events/detail.html', {"event": event, "bets": bets, "player": player})

@login_required
def bet(request, event_id):
	event = get_object_or_404(Event, pk=event_id)
	if request.method == 'POST':
		try:
			selected_option = event.eventoption_set.get(pk=request.POST['event_option'])
			private = True if request.POST['private'] == 'yes' else False
			bet_type = request.POST['type']
			player = Player.objects.get(user=request.user)
			amount = int(request.POST['amount'])
			player.balance = player.balance - amount
			player.save()
			minimum = request.POST.get('minamount', amount // 2) if bet_type != 'fixed' else amount
			bet = Bet(private=private, type=bet_type, bet_key=uuid4(), initiator=player, minimum=minimum)
			bet.save()
			player_bet = selected_option.playerbet_set.create(
					player=player,
					amount=amount,
					bet=bet)

return HttpResponseRedirect(reverse('event_detail', args=(event.id, )))
		except (KeyError, EventOption.DoesNotExist):
			return render(request, 'events/detail.html', {
				'event': event,
				'error_message': "Check your entries and try again.",
			})
	else:
		return HttpResponse(status=400, reason="Bad Request")

@login_required
def match(request, bet_key):
	bet = Bet.objects.get(bet_key=bet_key)
	player_bets = bet.playerbet_set.order_by('date_placed')
	first_bet = player_bets[0]
	event = first_bet.selection.event
	
	error_message = ""
	current_player = Player.objects.get(user=request.user)
	involved = bet.playerbet_set.filter(player=current_player)

if request.method == 'POST':
		try:
			option = event.eventoption_set.get(pk=request.POST['option'])
			if bet.type == 'fixed':
				amount = first_bet.amount
			elif int(request.POST.get('amount', 0)) < bet.minimum:
				amount = bet.minimum
			else:
				amount = int(request.POST['amount'])
			
			option.playerbet_set.create(
				player=current_player,
				amount=amount,
				bet=bet
			)
			
			current_player.balance = current_player.balance - amount
			current_player.save()

return HttpResponseRedirect(reverse('event_detail', args=(event.id, )))
		except (KeyError, ValueError, Player.DoesNotExist, EventOption.DoesNotExist) as e:
			error_message = e

options = Event.objects.raw(f"""SELECT e.id, eo.name, eo.id as optid
			FROM betting_eventoption eo 
			INNER JOIN betting_event e 
			ON e.id = eo.event_id 
			WHERE e.id = '{event.id}' 
			AND eo.id not in 
				(SELECT pb.selection_id 
				FROM betting_bet b 
				INNER JOIN betting_playerbet pb 
				ON b.id = pb.bet_id 
				WHERE b.bet_key = '{bet_key}')""")

return render(request, 'events/match.html', {
			"options": options, 
			"event": event, 
			"bet": bet,
			"playerbets": player_bets,
			"involved": involved,
			"error_message": error_message
		}
	)

@login_required
def delete_bet(request, evt, bet_key):
	bet = Bet.objects.get(bet_key=bet_key)
	bets = bet.playerbet_set.all()
	player = Player.objects.get(user=request.user)
	if len(bets) == 1 and bet.initiator == player:
		player.balance = player.balance + bets[0].amount
		player.save()
		bet.delete()

return HttpResponseRedirect(reverse('event_detail', args=(evt, )))
	elif len(bets) > 1:
		return render(request, 'events/detail.html', {"event": evt, "error": "Can't delete bet with more than one player"})

def get_events(request):
	evs = Event.objects.filter(end_date__gt=timezone.now())
	# evs = Event.objects.raw(f"""SELECT 1 as id, 
	# 	T.id, T.name as pn, 
	# 	COUNT(T.id) as ck, 
	# 	SUM(no_bets) as cnt 
	# 	FROM 
	# 		(SELECT e.id, 
	# 		e.name, COUNT(e.id) as no_bets 
	# 		FROM betting_event e 
	# 		INNER JOIN betting_eventoption eo 
	# 		ON e.id = eo.event_id 
	# 		INNER JOIN betting_playerbet pb 
	# 		ON eo.id = pb.selection_id 
	# 		INNER JOIN betting_bet b 
	# 		ON pb.bet_id = b.id 
	# 		AND b.private = 0 
	# 		GROUP BY e.id, e.name, b.id) 
	# 	AS T GROUP BY T.id, T.name""")
	return render(request, 'events/index.html', {"events": evs})

def login_user(request):
	error_message = ""
	if request.method == 'POST':
		try:
			username = request.POST['username']
			password = request.POST['password']
			user = authenticate(request, username=username, password=password)
			if user is not None:
				login(request, user)

return HttpResponseRedirect(reverse('get_events'))
		except KeyError:
			error_message = "invalid details"

return render(request, 'security/login.html', {"error": error_message})

def register_user(request):
	error_message = ""
	if request.method == 'POST':
		try:
			username = request.POST['username']
			email = request.POST['email']
			password = request.POST['password']
			user = User.objects.create_user(username, email, password)
			
			if user is not None:
				player = Player(user=user, name=username)
				player.save()
				login(request, user)

return HttpResponseRedirect(reverse('get_events'))
		except KeyError:
			error_message = "invalid details"

return render(request, 'security/register.html', {"error": error_message})

@login_required
def logout_view(request):
	logout(request)

return HttpResponseRedirect(reverse('get_events'))

@login_required
def get_balance(request):
	player = Player.objects.get(user=request.user)

return JsonResponse({"balance": player.balance})

${this.title}

Code Editor : views.py