stat

Dockerfile

@@ -3,7 +3,6 @@ FROM python:3.12.4
 WORKDIR /ft_transcendence
 
 RUN apt update && apt upgrade -y
-RUN apt install -y	vim 
 
 COPY requirements.txt .
 COPY manage.py .
@@ -12,11 +11,4 @@ RUN python3 -m venv venv
 RUN venv/bin/pip3 install --upgrade pip
 RUN venv/bin/pip3 install --no-cache-dir -r requirements.txt
 
-COPY . .
-
-#RUN venv/bin/python3 manage.py migrate --noinput
-#RUN venv/bin/python manage.py collectstatic --noinput
-
 EXPOSE 8000
-
-CMD ["venv/bin/python", "manage.py", "runserver", "0.0.0.0:8000"]

README.md

@@ -0,0 +1,36 @@
+# Installing Docker and Docker Compose on Ubuntu
+
+This guide will help you install Docker and Docker Compose on an Ubuntu system.
+
+## Prerequisites
+
+- A system running Ubuntu (preferably 20.04 LTS or later)
+- A user account with `sudo` privileges
+
+## Installing Docker
+
+1. **Update the package index:**
+
+```bash
+sudo apt update
+
+sudo apt install apt-transport-https ca-certificates curl software-properties-common
+
+curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
+
+sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
+
+sudo apt update
+
+sudo apt install docker-ce
+
+sudo systemctl status docker
+
+sudo usermod -aG docker $USER
+
+sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
+
+sudo chmod +x /usr/local/bin/docker-compose
+
+docker compose version
+

docker-compose.yaml

@@ -27,6 +27,7 @@ services:
     container_name: backend
     restart: always
     command: /bin/sh -c "sleep 5 && venv/bin/python3 manage.py migrate --noinput && venv/bin/python3 manage.py runserver 0.0.0.0:8000"
+    #&& venv/bin/python manage.py collectstatic --noinput 
     volumes:
       - helloword_project:/ft_transcendence/helloworld
     ports:
@@ -52,13 +53,13 @@ volumes:
     driver: local
     driver_opts:
       type: none
-      device: /home/theouche/trans/git_trans/data/db
+      device: ${POSTGRES_DATA_PATH}
       o: bind
   helloword_project:
     driver: local
     driver_opts:
       type: none
-      device: /home/theouche/trans/git_trans/helloworld
+      device: ${PROJECT_PATH}
       o: bind
 
 networks:

env_template

@@ -4,9 +4,12 @@ DEBUG=True
 DJANGO_ALLOWED_HOSTS=localhost 127.0.0.1 [::1]
 
 # PostgreSQL settings
-POSTGRES_DB= 
+POSTGRES_DB=
 POSTGRES_USER=
 POSTGRES_PASSWORD=
 
 DB_HOST=db
 DB_PORT=5432
+
+PROJECT_PATH=${PWD}/helloworld
+POSTGRES_DATA_PATH=${PWD}/data/db

helloworld/views.py

@@ -1,4 +1,4 @@
 from django.http import HttpResponse
 
 def index(request):
-    return HttpResponse("Hello, CHAKIB!")
+    return HttpResponse("Hello, QWER!")

makefile

@@ -1,24 +1,44 @@
-.PHONY: all build down clean logs
+COMPOSE_FILE=docker-compose.yaml
+COMPOSE=docker compose -f $(COMPOSE_FILE)
+CONTAINER=$(c)
 
-all: build
+up:
-	@echo "Building Docker images..."
 	sudo mkdir -p $$PWD/data/db
-	sudo docker compose -f ./docker-compose.yaml up -d --build
+	$(COMPOSE) build 
+	$(COMPOSE) up -d $(CONTAINER)
+
+build:
+	$(COMPOSE) build $(CONTAINER)
+
+start:
+	$(COMPOSE) start $(CONTAINER)
+
+stop:
+	$(COMPOSE) stop $(CONTAINER)
 
 down:
-	@echo "Stopping Docker containers..."
+	$(COMPOSE) down $(CONTAINER)
-	sudo docker compose -f ./docker-compose.yaml down
 
-clean:
+destroy:
-	@echo "Cleaning up Docker resources..."
+	$(COMPOSE) down -v --rmi all
-	sudo docker stop $$(docker ps -qa);\
+	sudo rm -rf $$PWD/data/db
-    sudo docker rm $$(docker ps -qa);\
-    sudo docker rmi $$(docker image ls -q);\
-    sudo docker volume rm $$(docker volume ls -q);\
-	sudo rm -rf $$PWD/data/db ;\
 
 logs:
-	@echo "Displaying Docker logs..."
+	$(COMPOSE) logs -f $(CONTAINER)
-	sudo docker compose logs -f
+
+ps:
+	$(COMPOSE) ps
+
+help:
+	@echo "Usage:"
+	@echo "  make build [c=service]        # Build images"
+	@echo "  make up [c=service]           # Start containers in detached mode"
+	@echo "  make start [c=service]        # Start existing containers"
+	@echo "  make down [c=service]         # Stop and remove containers"
+	@echo "  make destroy				   # Stop and remove containers and volumes"
+	@echo "  make stop [c=service]         # Stop containers"
+	@echo "  make restart [c=service]      # Restart containers"
+	@echo "  make logs [c=service]         # Tail logs of containers"
+	@echo "  make ps                       # List containers"
+	@echo "  make help                     # Show this help"
 
-re:	down clean build 

myapp/models.py

@@ -1,4 +1,5 @@
 from django.db import models
+from django.core.exceptions import ValidationError
 
 # Create your models here.
 
@@ -6,22 +7,23 @@ class Player(models.Model):
     name = models.CharField(max_length=100)
 
     def __str__(self):
-        return self.nom 
+        return self.name 
 
 class Tournoi(models.model):
-    nom = models.CharField(max_length=200)
+    name = models.CharField(max_length=200)
     nbr_player = models.PositiveSmallIntegerField()
     date = models.DateField()
     winner = models.ForeignKey('Player', on_delete=models.SET_NULL, null=True)
 
     def __str__(self):
-        return self.nom
+        return self.name
 
 class Match(models.Model):
     player1 = models.ForeignKey('Player', related_query_name='match_as_player1', on_delete=models.CASCADE)
     player2 = models.ForeignKey('Player', related_query_name='match_as_player2', on_delete=models.CASCADE)
     score_player1 = models.PositiveSmallIntegerField()
     score_player2 = models.PositiveSmallIntegerField()
+    winner = models.ForeignKey('Player', related_query_name='won_matches',on_delete=models.CASCADE)
     nbr_ball_touch_p1 = models.PositiveIntegerField()
     nbr_ball_touch_p2 = models.PositiveIntegerField()
     duration = models.DurationField()
@@ -32,6 +34,10 @@ class Match(models.Model):
     def clean(self):
         if self.score_player1 < 0 or self.score_player2 < 0:
             raise ValidationError('Les scores doivent être positifs.')
+        if self.score_player1 > self.score_player2 and self.winner != self.player1:
+            raise ValidationError('Le gagnant ne correspond pas aux scores.')
+        if self.score_player2 > self.score_player1 and self.winner != self.player2:
+            raise ValidationError('Le gagnant ne correspond pas aux scores.')
         super().clean()
 
     def save(self, *args, **kwargs):

myapp/utils.py

@@ -0,0 +1,60 @@
+from myapp.models import Player, Tournoi, Match
+from django.core.exceptions import ValidationError
+
+def create_player(name):
+    player = Player(name=name)
+    player.save()
+    return player
+
+def create_tournoi(name, nbr_player, date, winner=None):
+    tournoi = Tournoi(name=name, nbr_player=nbr_player, date=date, winner=winner)
+    tournoi.save()
+    return tournoi
+
+def create_match(player1, player2, score_player1=0, score_player2=0, winner=None, nbr_ball_touch_p1=0, nbr_ball_touch_p2=0, duration=None, is_tournoi=False, tournoi=None):
+    match = Match(
+        player1=player1,
+        player2=player2,
+        score_player1=score_player1,
+        score_player2=score_player2,
+        winner=winner,
+        nbr_ball_touch_p1=nbr_ball_touch_p1,
+        nbr_ball_touch_p2=nbr_ball_touch_p2,
+        duration=duration,
+        is_tournoi=is_tournoi,
+        tournoi=tournoi
+    )
+    match.save()
+    return match
+
+def complete_match(match_id, score_player1, score_player2, nbr_ball_touch_p1, nbr_ball_touch_p2, duration):
+    try:
+        match = Match.objects.get(id=match_id)
+    except Match.DoesNotExist:
+        raise ValidationError(f"Match with id {match_id} does not exist")
+
+    match.score_player1 = score_player1
+    match.score_player2 = score_player2
+    match.nbr_ball_touch_p1 = nbr_ball_touch_p1
+    match.nbr_ball_touch_p2 = nbr_ball_touch_p2
+    match.duration = duration
+
+    if score_player1 > score_player2:
+        match.winner = match.player1
+    elif score_player2 > score_player1:
+        match.winner = match.player2
+    else:
+        match.winner = None
+
+    match.save()
+    return match
+
+def complete_tournoi(tournoi_id, player):
+    try:
+        tournoi = Tournoi.objects.get(id = tournoi_id)
+    except Tournoi.DoesNotExist:
+        raise ValidationError(f"Tournoi with id {tournoi_id} does not exist")
+    
+    tournoi.winner = player
+    tournoi.save()
+    return tournoi

myapp/views.py

@@ -1,4 +1,50 @@
 # myapp/views.py
 
 from django.shortcuts import render, get_object_or_404
+from .models import Player, Match, Tournoi
+from django.http import JsonResponse
+from django.db.models import Max
+
+def player_statistics(request, player_name):
+    player = get_object_or_404(Player, nam = player_name)
+
+    #filtre on tab
+    matches_as_player1 = Match.objects.filter(player1=player)
+    matches_as_player2 = Match.objects.filter(player2=player)
+    won_matches = Match.objects.filter(winner=player)
+    part_tourn_as_p1 = Tournoi.objects.filter(matches__is_tournoi=True, matches__player1=player)
+    part_tourn_as_p2 = Tournoi.objects.filter(matches__is_tournoi=True, matches__player2=player)
+    won_tourn = Tournoi.objects.filter(winner=player)
+
+    # calulate stat
+    total_match = match_as_player1.count() + match_as_player2.count()
+    total_score = sum([match.score_player1 for match in matches_as_player1 ]) + sum([match.score_player2 for match in matches_as_player2])
+    total_score_adv = sum([match.score_player2 for match in matches_as_player1 ]) + sum([match.score_player1 for match in matches_as_player2])
+    total_win =  won_matches.count()
+    p_win = (total_win / total_match) * 100
+    m_score_match = total_score / total_match
+    m_score_adv_match = total_score_adv / total_match
+    nbr_ball_touch = sum([match.nbr_ball_touch_p1 for match in matches_as_player1]) + sum([match.nbr_ball_touch_p2 for match in matches_as_player2])
+    m_nbr_ball_touch = nbr_ball_touch / total_match
+    total_duration = sum([match.duration for match in matches_as_player1]) + sum(match.duration for match in matches_as_player2)
+    m_duration = total_duration / total_match
+    total_tourn_p = part_tourn_as_p1.count() + part_tourn_as_p2.count()
+    total_win_tourn = won_tourn.count()
+    p_win_tourn = (total_win_tourn / total_tourn_p) * 100
+
+    best_score_as_player1 = matches_as_player1.aggregate(Max('score_player1'))['score_player1__max']
+    best_score_as_player2 = matches_as_player2.aggregate(Max('score_player2'))['score_player2__max']
+    best_score = max(best_score_as_player1, best_score_as_player2)
+
+    data = {
+        'player_name': player.name,
+        'number of match played' : total_match
+        'number of win (matches)' : total_win
+        'pourcentage of victory' : p_win
+        'num_participated_tournaments': num_participated_tournaments,
+        'num_won_tournaments': num_won_tournaments
+    }
+
+
+