from django.urls import path
from . import views

app_name = 'social'

urlpatterns = []

from django.contrib import admin
from django.urls import path, include

urlpatterns = [Z
    path('admin/', admin.site.urls),
    path('', include('social.urls'), name='social'),
]

from django.db import models
from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
    profile_image = models.ImageField(upload_to='profile_images', blank=True, null=True)
    bio = models.TextField(max_length=500, blank=True, null=True)
    birth_date = models.DateField(blank=True, null=True)
    job = models.CharField(max_length=100, blank=True, null=True)
    phone_number = models.CharField(max_length=11, blank=True, null=True)


    class Meta:
        ordering = ['-username']
        indexes = [models.Index(fields=['-username'])]

    def __str__(self):
        return self.username

AUTH_USER_MODEL = 'app_name.model_name'
# --------------------------------------
AUTH_USER_MODEL = 'social.User'

pip install pillow

MEDIA_URL = '/images/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'images')

# changes 1:
from django.conf.urls.static import static
from django.conf import settings
# ----------------------------------------

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('social.urls'), namespace='social'),
]

# changes 2:
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from .models import *

@admin.register(User)
class UserAdmin(UserAdmin):
    list_display = ('username', 'profile_image', 'first_name', 'last_name', 'phone_number')
    fieldsets = UserAdmin.fieldsets + (
        ('additional info', {'fields': ('profile_image', 'bio', 'birth_date', 'job', 'location', 'gender', 'phone_number')}),
    )

from django import forms
from django.contrib.auth.forms import AuthenticationForm
from .models import *


class LoginForm(AuthenticationForm):
    username = forms.CharField(label='Username', required=True)
    password = forms.CharField(label='Password', required=True, widget=forms.PasswordInput)

from django.contrib.auth import logout
from django.shortcuts import redirect

def log_out(request):
    logout(request)
    return redirect('social:login')

urlpatterns = [
    path('login/', auth_views.LoginView.as_view(authentication_form=LoginForm), name='login'),
    # path('logout/', auth_views.LogoutView.as_view(), name='logout'),
    path('logout/', views.log_out, name='logout'),  
]

urlpatterns = [
    path('profile/', views.profile, name='profile'),
]

LOGIN_REDIRECT_URL = "/profile/"
LOGIN_URL = "/login/"
LOGOUT_URL = "/logout/"

from .models import User


# login with phone-number:
class PhoneAuthBackend:
    def authenticate(self, request, username=None, password=None):
        # username = phoneNumber
        try:
            user = User.objects.get(phone_number=username)
            if user.check_password(password):
                return user
            return None
        except (User.DoesNotExist, User.MultipleObjectsReturned):
            return None

    def get_user(self, user_id):
        try:
            return User.objects.get(pk=user_id)
        except User.DoesNotExist:
            return None

# login with Email:
class EmailAuthBackend:
    def authenticate(self, request, username=None, password=None):
        # username = Email
        try:
            user = User.objects.get(email=username)
            if user.check_password(password):
                return user
            return None
        except (User.DoesNotExist, User.MultipleObjectsReturned):
            return None

    def get_user(self, user_id):
        try:
            return User.objects.get(pk=user_id)
        except User.DoesNotExist:
            return None

# structure:
'app_name.script_name.class_name'

AUTHENTICATION_BACKENDS = [
    'django.contrib.auth.backends.ModelBackend',
    'social.authentication.PhoneAuthBackend',
    'social.authentication.EmailAuthBackend',
]

urlpatterns = [
    path('register/', views.register, name='register'),
    path('user/edit/', views.edit_profile, name='edit_profile'),
]

class RegisterForm(forms.ModelForm):
    password = forms.CharField(widget=forms.PasswordInput, required=True)
    password_repeat = forms.CharField(widget=forms.PasswordInput, required=True)

    class Meta:
        model = User
        fields = ('username', 'email', 'phone_number')

    def clean_password_repeat(self):
        password = self.cleaned_data.get('password')
        password_repeat = self.cleaned_data.get('password_repeat')

        if password != password_repeat:
            raise forms.ValidationError('Passwords must match')
        else:
            return password_repeat

    # جلوگیری از ثبت نام با شماره تکراری
    def clean_phone_number(self):
        phone = self.cleaned_data.get('phone_number')
        if User.objects.filter(phone_number=phone).exists():
            raise forms.ValidationError('Phone number already exists')
        else:
            return phone

def register(request):
    if request.method == 'POST':
        form = RegisterForm(request.POST)
        if form.is_valid():
            user = form.save(commit=False)
            user.set_password(form.cleaned_data['password'])
            user.save()
            return redirect('social:profile')
    else:
        form = RegisterForm()

    return render(request, 'registration/register.html', {"form": form})

class EditProfileForm(forms.ModelForm):
    class Meta:
        model = User
        fields = ('profile_image', 'username', 'first_name', 'last_name', 'email', 'phone_number', 'bio', 'job',
                  'location', 'gender', 'birth_date')

    def clean_phone_number(self):
        phone = self.cleaned_data.get('phone_number')
        if User.objects.exclude(id=self.instance.id).filter(phone_number=phone).exists():
            raise forms.ValidationError('Phone number already exists')
        else:
            return phone

    def clean_username(self):
        username = self.cleaned_data.get('username')
        if User.objects.exclude(id=self.instance.id).filter(username=username).exists():
            raise forms.ValidationError('Username already exists')
        else:
            return username

@login_required
def edit_profile(request):
    if request.method == 'POST':
        form = EditProfileForm(request.POST, files=request.FILES, instance=request.user)
        if form.is_valid():
            form.save()
            return redirect('social:profile')
    else:
        form = EditProfileForm(instance=request.user)

    return render(request, 'registration/edit_profile.html', {"form": form})

urlpatterns = [
    path('ticket/', views.ticket, name='ticket'),
]

class TicketForm(forms.Form):
    title = forms.CharField(max_length=100, required=True)
    name = forms.CharField(max_length=100, required=True)
    content = forms.CharField(widget=forms.Textarea, required=True)
    email = forms.CharField(required=True)

EMAIL_HOST = 'smtp.gmail.com'
EMAIL_HOST_USER = 'example@gmail.com'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_PASSWORD = '---- ---- ---- ----'
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'

from django.core.mail import send_mail

def ticket(request):
    sent = False
    if request.method == 'POST':
        form = TicketForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data

            message = (f"sender: {cd['name']},\n"
                       f"email: {cd['email']}\n\n"
                       f"content: {cd['content']}"
            )

            send_mail(
                subject=cd['title'],
                message=message,
                from_email='sender@gmail.com',
                recipient_list=['recipient@gmail.com'],
                fail_silently=False,
            )

            sent = True
            return redirect("social:index")

    else:
        form = TicketForm()

    return render(request, 'forms/ticket.html', {"form": form, "sent": sent})

urlpatterns = [
    # password_change
    path('password-change/', auth_views.PasswordChangeView.as_view(success_url='done'), name='password_change'),
    path('password-change/done/', auth_views.PasswordChangeDoneView.as_view(), name='password_change_done'),

    # password_reset
    path('password-reset', auth_views.PasswordResetView.as_view(success_url='/password-reset/done'), name='password_reset'),
    path('password-reset/done/', auth_views.PasswordResetDoneView.as_view(), name='password_reset_done'),
    path('password-reset/confirm/<uidb64>/<token>/', auth_views.PasswordResetConfirmView.as_view(success_url='/password-reset/complete'), name='password_reset_confirm'),
    path('password-reset/complete/', auth_views.PasswordResetCompleteView.as_view(), name='password_reset_complete'),
]

class Post(models.Model):
    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='user_posts')
    description = models.TextField()

    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

    # ordering & indexing
    class Meta:
        ordering = ['-created']
        indexes = [
            models.Index(fields=['-created']),
            models.Index(fields=['-total_likes']),
        ]

    def __str__(self):
        return self.description

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ['author', 'updated', 'created']
    ordering = ['-created', '-author']
    search_fields = ['author', 'description']

urlpatterns = [
    path('posts-list/', views.post_list, name='post_list'),
]

def post_list(request):

    posts = Post.objects.all()

    return render(request, 'social/post_list.html', {'posts': posts})

pip install django-taggit

INSTALLED_APPS = [
    # ...
    'taggit',
]

from taggit.managers import TaggableManager

from taggit.managers import TaggableManager


class Post(models.Model):
    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='user_posts')
    description = models.TextField()

    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

    tags = TaggableManager()

    # ordering & indexing
    class Meta:
        ordering = ['-created']
        indexes = [
            models.Index(fields=['-created']),
            models.Index(fields=['-total_likes']),
        ]

    def __str__(self):
        return self.description

{% for post in posts %}
    {{ post.description | truncatewords:20 | linebreaks }}
    <br>
    published at {{ post.created }} by {{ post.author }}
    <br>

    {{ post.tags.all | join:', ' }}
{% endfor %}

urlpatterns = [
    path('posts-list/', views.post_list, name='post_list'),
    path('posts-list/<slug:tag_slug>', views.post_list, name='post_list_tags'),
]

from taggit.models import Tag


def post_list(request, tag_slug=None):
    tag = None
    posts = Post.objects.all()

    if tag_slug:
        tag = get_object_or_404(Tag, slug=tag_slug)
        posts = Post.objects.filter(tags__in=[tag])

    return render(request, 'social/post_list.html', {'posts': posts, 'tag': tag})

{% if tag %}
    <h2>posts tagged with {{ tag.name }}</h2>
{% endif %} 

{% for post in posts %}
    {{ post.description | truncatewords:20 | linebreaks }}
    published at {{ post.created }} by {{ post.author }}
    <br>
    
    {% for tag in post.tags.all %}
        <a href="{% url 'social:post_list_tags' tag.slug %}">{{ tag.name }}</a>
        
        {% if not forloop.last %}, {% endif %} 
    {% endfor %}
{% endfor %}

urlpatterns = [
    path('create-post/', views.create_post, name='create_post'),
]

class CreatePostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ('description', 'tags')

@login_required
def create_post(request):
    if request.method == 'POST':
        form = CreatePostForm(request.POST)
        if form.is_valid():
            post = form.save(commit=False)
            post.author = request.user
            post.save()

            form.save_m2m()
            return redirect('social:post_list')
    else:
        form = CreatePostForm()

    return render(request, 'forms/create_post.html', {'form': form})

urlpatterns = [
    path('posts/detail/<int:post_id>', views.post_detail, name='post_detail'),
]

{% if tag %}
    <h2>posts tagged with {{ tag.name }}</h2>
{% endif %} 

{% for post in posts %}

    <!-- لینک انتقال به صفحه جزئیات پست -->
    <a href="{% url 'social:post_detail' post.id %}">
        {{ post.description | truncatewords:20 | linebreaks }}
    </a>

    published at {{ post.created }} by {{ post.author }}
    <br>
    
    {% for tag in post.tags.all %}
        <a href="{% url 'social:post_list_tags' tag.slug %}">{{ tag.name }}</a>
        
        {% if not forloop.last %}, {% endif %} 
    {% endfor %}
{% endfor %}

def post_detail(request, post_id):
    post = get_object_or_404(Post, pk=pk)

    post_tags_ids = post.tags.values_list('id', flat=True)

    similar_posts = Post.objects.filter(tags__in=post_tags_ids)

    similar_posts = similar_posts.annotate(same_tags=Count('tags')).exclude(id=pk).order_by('-same_tags', '-created')[:3]

    context = {
        'post': post, 
        'similar_posts': similar_posts
        }

    return render(request, 'social/post_detail.html', context=context)

{{ post.description | truncatewords:20 | linebreaks }}

published at {{ post.created }} by {{ post.author }}
<br>

{% for tag in post.tags.all %}
    <a href="{% url 'social:post_list_tags' tag.slug %}">{{ tag.name }}</a>
    
    {% if not forloop.last %}, {% endif %} 
{% endfor %}

<h2>Similar Posts</h2>

{% for post in similar_posts %}
    <p>
        <a href="{% url 'social:post_detail' post.id %}">
            {{ post.description | truncatewords:10 | linebreaks }}
        </a>
    </p>
{% empty %}
    There are no similar posts!
{% endfor %}

class SearchForm(forms.Form):
    query = forms.CharField(max_length=250)

urlpatterns = [
    path('search/', views.post_search, name='post_search'),
]

def post_search(request):
    query = None
    results = []

    if 'query' in request.GET:
        form = SearchForm(request.GET)
        if form.is_valid():
            query = form.cleaned_data['query']

            results = Post.objects.annotate(
                similarity=TrigramSimilarity('tags', query) + 
                           TrigramSimilarity('description', query)).filter(similarity__gt=0.18).order_by('-similarity')

    context = {
        "query": query,
        "results": results,
    }

    return render(request, 'blog/search_result.html', context=context)

INSTALLED_APPS = [
    # ...
    'django.contrib.postgres',
]

class Comment(models.Model):
    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='comments')

    name = models.CharField(max_length=250)
    content = models.TextField()
    # date
    created = models.DateTimeField(auto_now_add=True)

    # status for show in template
    active = models.BooleanField(default=False)

    class Meta:
        ordering = ['-created']
        indexes = [models.Index(fields=['-created'])]

    def __str__(self):
        return f'Written by: {self.name}\n{self.post} Post'

class CommentForm(forms.ModelForm):
    class Meta:
        model = Comment
        fields = ['name', 'content']

urlpatterns = [
    path('post-detail/<int:post_id>/comment/', views.post_comment, name='post_comment'),
]

def post_comment(request, post_id):
    post = get_object_or_404(Post, id=post_id)
    comment = None

    if request.method == 'POST':
        form = CommentForm(request.POST)
        if form.is_valid():
            comment = form.save(commit=False)
            comment.post = post
            comment.save()
    else:
        form = CommentForm()

    context = {
        'comment': comment,
        'post': post,
        'form': form
    }

    return render(request, "forms/comment.html", context=context)

{% load static %}
<link rel="stylesheet" href="{% static 'css/pagination.css' %}">

<nav class="my-5" aria-label="navigation">
    <ul class="pagination d-inline-block d-md-flex justify-content-center">

        {% if page.has_previous %}
            <li class="page-item">
                <a class="page-link1" href="?page={{ page.previous_page_number }}" tabindex="-1" aria-disabled="true">«</a>
            </li>

            {% if page.number > 3 %}
                <li class="page-item"><a class="page-link" href="?page=1">1</a></li>
                {% if page.number > 4 %}
                    <li class="page-item disabled"><a class="page-link" href="#">...</a></li>
                {% endif %}
            {% endif %}

        {% endif %}

        {% for num in page.paginator.page_range %}
            {% if page.number == num %}
                <li class="page-item"><a class="page-link active" href="?page={{ num }}">{{ num }}</a></li>
            {% elif num > page.number|add:'-3' and num < page.number|add:'3' %}
                <li class="page-item"><a class="page-link" href="?page={{ num }}">{{ num }}</a></li>
            {% endif %}
        {% endfor %}

        {% if page.has_next %}
            {% if page.number < page.paginator.num_pages|add:'-3' %}
                <li class="page-item disabled"><a class="page-link" href="#">...</a></li>
                <li class="page-item"><a class="page-link" href="?page={{ page.paginator.num_pages }}">{{ page.paginator.num_pages }}</a></li>
            {% elif page.number < page.paginator.num_pages|add:'-2' %}
                <li class="page-item"><a class="page-link" href="?page={{ page.paginator.num_pages }}">{{ page.paginator.num_pages }}</a></li>

            {% endif %}
            <li class="page-item">
                <a class="page-link1" href="?page={{ page.next_page_number }}">»</a>
            </li>
        {% endif %}

    </ul>
</nav>

{% if tag %}
    <h2>posts tagged with {{ tag.name }}</h2>
{% endif %} 

{% for post in posts %}

    <!-- لینک انتقال به صفحه جزئیات پست -->
    <a href="{% url 'social:post_detail' post.id %}">
        {{ post.description | truncatewords:20 | linebreaks }}
    </a>

    published at {{ post.created }} by {{ post.author }}
    <br>
    
    {% for tag in post.tags.all %}
        <a href="{% url 'social:post_list_tags' tag.slug %}">{{ tag.name }}</a>
        
        {% if not forloop.last %}, {% endif %} 
    {% endfor %}
{% endfor %}

<!-- ساختار صفحه بندی -->
{% include 'partials/pagination.html' with page=posts %}

from taggit.models import Tag
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger


def post_list(request, tag_slug=None):
    tag = None
    posts = Post.objects.all()

    if tag_slug:
        tag = get_object_or_404(Tag, slug=tag_slug)
        posts = Post.objects.filter(tags__in=[tag])

    # صفحه بندی برای پست ها
    paginator = Paginator(posts, 10)
    page_number = request.GET.get('page', 1)

    try:
        posts = paginator.page(page_number)
    except EmptyPage:
        posts = paginator.page(paginator.num_pages)
    except PageNotAnInteger:
        posts = paginator.page(1)

    return render(request, 'social/post_list.html', {'posts': posts, 'tag': tag})

urlpatterns = [
    path('profile/edit-post/<post_id>', views.edit_post, name='edit_post'),
]

from django.contrib.auth.decorators import login_required

@login_required
def edit_post(request, post_id):
    post = get_object_or_404(Post, pk=post_id, author=request.user)

    if request.method == 'POST':
        form = CreatePostForm(request.POST, instance=post)
        if form.is_valid():
            post = form.save(commit=False)
            post.author = request.user
            post.save()

            return redirect('social:index')
    else:
        form = CreatePostForm(instance=post)

    return render(request, 'forms/create_post.html', {'post': post, 'form': form})

urlpatterns = [
    path('profile/delete-post/<post_id>', views.delete_post, name='delete_post'),
]

{% if tag %}
    <h2>posts tagged with {{ tag.name }}</h2>
{% endif %} 

{% for post in posts %}

    <!-- لینک انتقال به صفحه جزئیات پست -->
    <a href="{% url 'social:post_detail' post.id %}">
        {{ post.description | truncatewords:20 | linebreaks }}
    </a>

    published at {{ post.created }} by {{ post.author }}
    <br>
    
    {% for tag in post.tags.all %}
        <a href="{% url 'social:post_list_tags' tag.slug %}">{{ tag.name }}</a>
        
        {% if not forloop.last %}, {% endif %} 
    {% endfor %}

    <a href="{% url 'social:delete_post' post.id %}">delete post</a>
{% endfor %}

<!-- ساختار صفحه بندی -->
{% include 'partials/pagination.html' with page=posts %}

def delete_post(request, post_id):
    post = get_object_or_404(Post, pk=post_id)

    if request.method == 'POST':
        post.delete()

        return redirect('social:post_list')

    return render(request, 'forms/delete-post.html', {'post': post})

<h2>آیا از حذف پست مطمئن هستید؟!</h2>
<br>

<a href="{% url 'social:post_list' %}">بازگشت به صفحه لیست پست ها</a>

<form method="post">
    {% csrf_token %}

    <input type="submit" value="حذف">
</form>

class Image(models.Model):
    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='images', null=True, blank=True)

    image = ResizedImageField(upload_to='post_images/', size=[125, 125], scale=1, crop=['middle', 'center'], null=True, blank=True)
    title = models.CharField(max_length=250, null=True, blank=True)
    description = models.TextField(null=True, blank=True)
    created = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ['-created']
        indexes = [models.Index(fields=['-created'])]

    def __str__(self):
        return f"Title: {self.title}" if self.title else f"Image_name: {self.image}"

class CreatePostForm(forms.ModelForm):
    img1 = forms.ImageField(label='pic1', required=False)
    img2 = forms.ImageField(label='pic2', required=False)

    class Meta:
        model = Post
        fields = ('description', 'tags')

@login_required
def create_post(request):
    if request.method == 'POST':
        form = CreatePostForm(request.POST)
        if form.is_valid():
            post = form.save(commit=False)
            post.author = request.user
            post.save()

            form.save_m2m()

            # اسم فیلدهای تصویر در فرم
            all_images = ['img1', 'img2']

            for img in all_images:
                img_file = form.cleaned_data.get(img)
                if img_file:
                    Image.objects.create(image=img_file, post=post)

            return redirect('social:post_list')
    else:
        form = CreatePostForm()

    return render(request, 'forms/create_post.html', {'form': form})