First Commit

users/views.py

@@ -0,0 +1,308 @@
+from django.shortcuts import render, redirect
+from django.contrib.auth import authenticate, login as auth_login
+from django.contrib.auth.forms import AuthenticationForm
+from django.contrib import messages
+from django.contrib.auth.decorators import login_required
+from .forms import PostForm, UserRegistrationForm, UserLoginForm, UserUpdateForm, ProfileUpdateForm
+from posts.models import Post
+from django.utils.text import slugify
+from django.template.loader import render_to_string
+from django.core.mail import send_mail
+from django.conf import settings
+from django.contrib.auth.tokens import PasswordResetTokenGenerator
+from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
+from django.utils.encoding import force_bytes, force_str
+from .models import User, UserLevel
+from django.db.models import F
+import urllib.request
+import json
+
+def register(request):
+    from messagerie.models import PrivateMessageSubject, PrivateMessage
+    if request.user.is_authenticated:
+        return redirect('profile')
+    
+    if request.method == "POST":
+        form = UserRegistrationForm(request.POST)
+        recaptcha = request.POST.get('g-recaptcha-response')
+        if form.is_valid():
+
+            url = 'https://www.google.com/recaptcha/api/siteverify'
+            values = {
+                'secret': settings.GOOGLE_PRIVATE_KEY,
+                'response': recaptcha
+            }
+            data = urllib.parse.urlencode(values).encode()
+            req =  urllib.request.Request(url, data=data)
+            response = urllib.request.urlopen(req)
+            result = json.loads(response.read().decode())
+
+            if result['success']:
+                user = User.objects.create_user(
+                    username=form.cleaned_data['username'],
+                    email=form.cleaned_data['email'],
+                    password=form.cleaned_data['password1'],
+                    theme='00s',
+                    active=True
+                )
+
+                messages.success(request, f"Bonjour et bienvenue {user.username} ! Ton compte à été créer avec succès. Tu peux désormais te connecter.")
+
+                subject = PrivateMessageSubject.objects.create(
+                    receiver=user,
+                    sender=User.objects.get(username='RetroBot'),
+                    subject="Bienvenue sur PassionRetro !"
+                )
+
+                PrivateMessage.objects.create(
+                    subject=subject,
+                    author=User.objects.get(username='RetroBot'),
+                    message=f"""[b]Bienvenue sur Passion Retro ![/b]
+
+Salut [b]{user.username}[/b] !,
+
+Merci de nous avoir rejoints dans cette aventure dédiée aux passionnés de rétro ! Que tu sois fan de consoles vintage, collectionneur d'objets d'époque ou simple curieux, tu es ici chez toi. 
+
+✨ [b]Découvre tout ce que Passion Retro a à offrir :[/b]  
+Plonge dans nos articles pour en apprendre plus sur les trésors du passé, participe aux discussions sur le forum et teste tes connaissances avec nos jeux rétro. Chaque section est là pour te permettre de partager ta passion et d'en apprendre davantage.  
+
+🚀 [b]Rejoins la communauté :[/b]  
+Ton avis et tes contributions sont précieux ! N’hésite pas à lancer une discussion sur le forum, à réagir aux articles ou à défier les autres membres sur nos jeux. Plus nous sommes actifs, plus l’expérience sera enrichissante pour tous.  
+
+Si tu as des questions ou des suggestions pour améliorer le site, contacte-nous. Nous sommes là pour t'accompagner !  
+
+Encore une fois, bienvenue parmi nous et prépare-toi à replonger dans l’univers du rétro !  
+
+À bientôt,  
+[b]L'équipe Passion Retro[/b]""")
+
+                return redirect('login')
+            else:
+                messages.error(request, f"On y est presque ! Vérifie bien le captcha pour finaliser ton inscription.")            
+
+    form = UserRegistrationForm()
+    return render(request, 'users/register.html', {'form': form, 'GOOGLE_PUBLIC_KEY': settings.GOOGLE_PUBLIC_KEY})
+
+def register_with_token(request):
+    # Si l'utilisateur est deja connecté, on le redirige vers la page de pr>
+    if request.user.is_authenticated:
+        return redirect('profile')
+    if request.method == 'POST':
+        form = UserRegistrationForm(request.POST)
+        if form.is_valid():
+            user = User.objects.create_user(
+                username=form.cleaned_data['username'],
+                email=form.cleaned_data['email'],
+                password=form.cleaned_data['password1']
+            )
+            genToken = PasswordResetTokenGenerator()
+            token = genToken.make_token(user)
+            uid = urlsafe_base64_encode(force_bytes(user.pk))
+
+            activation_link = request.build_absolute_uri(f"/users/activate/{uid}/{token}")
+           
+            email_subject = 'Activation de votre compte'
+            email_body = render_to_string('emails/activation_account.html', {
+                'user': user,
+                'activation_link': activation_link,
+            })
+
+            send_mail(
+                email_subject,
+                email_body,
+                settings.DEFAULT_FROM_EMAIL,
+                [user.email],
+                fail_silently=False,
+            )
+
+            messages.success(request, f"Ton compte a été créé avec succès, {user.username}! Un email d'activation t'a été envoyé pour valider ton inscription.")
+
+            return redirect('login')
+    else:
+        form = UserRegistrationForm()
+    return render(request, 'users/register.html', {'form': form})
+
+def activate(request, uidb64, token):
+    uid = None  # Initialisation de la variable uid
+    try:
+        uid = force_str(urlsafe_base64_decode(uidb64))
+        user = User.objects.get(pk=uid)
+    except (TypeError, ValueError, OverflowError, User.DoesNotExist):
+        user = None
+
+    token_generator = PasswordResetTokenGenerator()
+    if user is not None and token_generator.check_token(user, token):
+        user.active = True
+        user.save()
+        messages.success(request, "Votre compte a été activé avec succès.")
+        return redirect('login')
+    else:
+        messages.error(request, "Le lien d'activation est invalide.")
+        return redirect('register')
+
+def login(request):
+    if request.method == 'POST':
+        form = UserLoginForm(data=request.POST)
+        if form.is_valid():
+            username = form.cleaned_data.get('username')
+            password = form.cleaned_data.get('password')
+            user = authenticate(request, username=username, password=password)
+            if user is None:
+                messages.error(request, "Nom d'utilisateur ou mot de passe incorrect.")
+                return redirect('login')
+            
+            if user.active == False:
+                messages.error(request, "Votre compte n'est pas activé. Veuillez vérifier votre boîte mail.")
+                return redirect('login')
+            
+            auth_login(request, user)
+            messages.success(request, f"Bienvenue, {username}!")
+            return redirect('home')
+        else:
+            messages.error(request, "Nom d'utilisateur ou mot de passe incorrect.")
+    else:
+        form = UserLoginForm()
+    
+    return render(request, 'users/login.html', {'form': form})
+
+def profile(request):
+    from forum.models import Topic, Post
+    from posts.models import Post
+    user = User.objects.get(id=request.user.id)
+    # On compte le nombre de topics du forum de l'utilisateur
+    topics = Topic.objects.filter(author=user).count()
+    forum_posts = Post.objects.filter(author=user).count()
+    posts = Post.objects.filter(author=user).count()
+
+    return render(request, 'users/profile.html', { 'user': user, 'topics': topics, 'forum_posts': forum_posts, 'posts': posts })
+
+def another_profile(request, user_id):
+    from forum.models import Topic, Post
+    from posts.models import Post
+    user = User.objects.get(id=user_id)
+    # On compte le nombre de topics du forum de l'utilisateur
+    topics = Topic.objects.filter(author=user).count()
+    forum_posts = Post.objects.filter(author=user).count()
+    posts = Post.objects.filter(author=user).count()
+
+    return render(request, 'users/profile.html', {'user': user, 'topics': topics, 'forum_posts': forum_posts, 'posts': posts})
+
+@login_required(login_url='login')
+def profile_update(request):
+    if request.method == 'POST':
+        user_form = UserUpdateForm(request.POST, request.FILES, instance=request.user)
+        if user_form.is_valid():
+            user_form.save()
+            messages.success(request, 'Votre profil a été mis à jour avec succès !')
+            return redirect('profile')
+    else:
+        user_form = UserUpdateForm(instance=request.user)
+    return render(request, 'users/profile_update.html', {'user_form': user_form})
+
+@login_required
+def contribute(request):
+    return render(request, "users/contribute.html")
+
+@login_required(login_url='register')
+def form_contribute(request, type):
+    if request.method == 'POST':
+        # Initialisation des articles
+        form = PostForm(request.POST)
+        posts = []
+
+        # Traite l'article principal (parent)
+        main_title = request.POST.get('title')  # Titre principal du formulaire Django
+        main_content = request.POST.get('content')  # Contenu principal
+        parent_post = None
+
+        if main_title and main_content:
+            # Crée le parent
+            parent_post = Post.objects.create(
+                title=main_title,
+                slug=slugify(main_title),
+                content=main_content,
+                type=type,
+                author=request.user,
+                contribution=True,
+                parent=True
+            )
+            posts.append(parent_post)
+            UserLevel.objects.update(user=request.user, experience=F('experience') + 10)
+
+        # Vérifie si des articles dynamiques existent (type_form = multiple)
+        type_form = request.POST.get('type_form')
+
+        if type_form == 'multiple':
+            # Parcourt les champs dynamiques ajoutés en JS
+            for key in request.POST:
+                if key.startswith('title-post-'):
+                    # Récupère le numéro de l'article
+                    article_number = key.split('-')[-1]
+
+                    # Récupère les données de l'article enfant
+                    title = request.POST.get(f'title-post-{article_number}')
+                    content = request.POST.get(f'content-post-{article_number}')
+
+                    if title and content:
+                        # Crée l'article enfant
+                        child_post = Post.objects.create(
+                            title=title,
+                            slug=slugify(title),
+                            content=content,
+                            type=type,
+                            author=request.user,
+                            contribution=True,
+                            parent=False,
+                            post_parent=parent_post
+                        )
+                        posts.append(child_post)
+                        UserLevel.objects.update(user=request.user, experience=F('experience') + 5)
+
+        messages.success(request, "Vos articles ont été soumis avec succès !")
+
+    context = {
+        'type': type,
+        'form': PostForm(),
+    }
+    return render(request, "users/form_contribute.html", context)
+
+@login_required()
+def contributions(request):
+    posts = Post.objects.filter(author=request.user)
+
+    return render(request, "users/contributions.html", {'posts':posts})
+
+@login_required
+def new_feature_user(request):
+    # On créer une entree dans la table user_level pour l'utilisateur si il n'en a pas
+    if not request.user.level:
+        request.user.levels.create(level=1)
+        return render(request, "features/new_feature_user_level.html")
+
+    if not request.user.inventory.exists():
+        request.user.inventory.create(item_id=1, quantity=100)
+    return render(request, "features/new_feature_user_inventory.html")
+
+@login_required
+def use_item(request, item_id):
+    item = request.user.inventory.get(item_id=item_id)
+
+    # On slugify le nom de l'item pour l'utiliser dans les conditions
+    item_name = slugify(item.item.name)
+
+    if item.quantity > 0:
+        if item.item.category.name == 'cadres':
+            request.user.border_avatar = item_name
+        
+        if item.item.category.name == 'themes':
+            request.user.theme_active = item_name
+
+        if item.item.category.name == 'Décoration pseudo':
+            request.user.username_decoration = item_name
+        
+        request.user.save()
+        
+        messages.success(request, f"Vous avez utilisé {item.item.name}.")
+    else:
+        messages.error(request, f"Vous n'avez pass de {item.item.name}.")
+    return redirect('profile')