SECRET_KEY=-)=b-%-w+0_^slb(exmy*mfiaj&wz6_fb4m&s=az-zs!1^ui7j

from decouple import config SECRET_KEY = config('SECRET_KEY')

from django.contrib import admin from django.urls import path # Three modules for swagger: from rest_framework import permissions from drf_yasg.views import get_schema_view from drf_yasg import openapi schema_view = get_schema_view( openapi.Info( title="Flight Reservation API", default_version="v1", description="Flight Reservation API project provides flight and reservation info", terms_of_service="#", contact=openapi.Contact( email="rafe@clarusway.com"), # Change e-mail on this line! license=openapi.License(name="BSD License"), ), public=True, permission_classes=[permissions.AllowAny], ) urlpatterns = [ path("admin/", admin.site.urls), # Url paths for swagger: path("swagger(<format>\.json|\.yaml)", schema_view.without_ui(cache_timeout=0), name="schema-json"), path("swagger/", schema_view.with_ui("swagger", cache_timeout=0), name="schema-swagger-ui"), path("redoc/", schema_view.with_ui("redoc", cache_timeout=0), name="schemaredoc"), ]

from django.urls import include urlpatterns = [ # ... path('__debug__/', include('debug_toolbar.urls')), ]

MIDDLEWARE = [ "debug_toolbar.middleware.DebugToolbarMiddleware", # ... ]

INTERNAL_IPS = [ "127.0.0.1", ]

 'rest_framework', 'rest_framework.authtoken', 'dj_rest_auth',

path('auth/', include('user.urls'))

from django.urls import path, include urlpatterns = [ path('auth/', include('dj_rest_auth.urls')), ]

from django.db import models from django.conf import settings User = settings.AUTH_USER_MODEL class Category(models.Model): name = models.CharField(max_length=50) def __str__(self): return self.name class BlogPost(models.Model): STATUS = ( ("d", "DRAFT"), ("p", "PUBLISHED"), ) title = models.CharField(max_length=100) author = models.ForeignKey(User, related_name="post_user", on_delete=models.CASCADE) category = models.ForeignKey(Category, related_name="post_category", on_delete=models.CASCADE) content = models.TextField() image = models.URLField(max_length=200, blank=True, default="https://robohash.org/9c681a48b0ef374675df3ca8d6b014a5?set=set4&bgset=&size=400x400") published_date = models.DateTimeField(auto_now_add=True, blank=True) last_updated_date = models.DateTimeField(auto_now=False, blank=True) status = models.CharField(max_length=50, choises=STATUS) #! We use slug for the fields we want to appear instead of ID 👇 slug = models.SlugField() def __str__(self): return self.title class Like(models.Model): user = models.ForeignKey(User, related_name="like_user", on_delete=models.CASCADE) post = models.ForeignKey(BlogPost, related_name="like_post", on_delete=models.CASCADE) def __str__(self): return self.user.username class Comment(models.Model): content = models.TextField() time_stamp = models.DateTimeField(auto_now_add=True, blank=True) user = models.ForeignKey(User, related_name="comment_user", on_delete=models.CASCADE) post = models.ForeignKey(BlogPost, related_name="comment_post", on_delete=models.CASCADE) def __str__(self): return self.user.username class Post_view(models.Model): user = models.ForeignKey(User, related_name="post_viewed_user", on_delete=models.CASCADE) post = models.ForeignKey(BlogPost, related_name="viewed_post", on_delete=models.CASCADE) viewed_date_time = models.DateTimeField(auto_now_add=True, blank=True)

from django.db import models from django.contrib.auth.models import AbstractUser class User(AbstractUser): image = models.URLField(max_length=200, blank=True) bio = models.TextField(blank=True)

from django.contrib import admin from .models import User admin.site.register(User)

AUTH_USER_MODEL = 'user.User'

from rest_framework import serializers, validators from django.contrib.auth import get_user_model from django.contrib.auth.password_validation import validate_password from dj_rest_auth.serializers import TokenSerializer User = get_user_model() class RegisterSerializer(serializers.ModelSerializer): email = serializers.EmailField( required=True, validators=[validators.UniqueValidator(queryset=User.objects.all())] ) password = serializers.CharField( write_only=True, required=True, validators=[validate_password], style={"input_type": "password"} ) password1 = serializers.CharField( write_only=True, required=True, validators=[validate_password], style={"input_type": "password"} ) class Meta: model = User fields = ( 'username', 'email', 'first_name', 'last_name', 'password', 'password1', 'image', 'bio' ) def validate(self, data): if data['password'] != data['password1']: raise serializers.ValidationError( {"password": "Password didn't match..... "} ) return data def create(self, validated_data): password = validated_data.pop("password") validated_data.pop('password1') user = User.objects.create(**validated_data) user.set_password(password) user.save() return user class UserSerializer(serializers.ModelSerializer): class Meta: model = User fields = ( 'username', 'email' ) class CustomTokenSerializer(TokenSerializer): user = UserSerializer(read_only=True) class Meta(TokenSerializer.Meta): fields = ( 'key', 'user' )

from django.db.models.signals import post_save from django.dispatch import receiver from rest_framework.authtoken.models import Token from django.contrib.auth import get_user_model User = get_user_model() @receiver(post_save, sender=User) def create_token(sender, instance=None, created=False, **kwargs): if created: Token.objects.create(user=instance)

def ready(self): import user.signals

from rest_framework import generics, status from rest_framework.response import Response from rest_framework.authtoken.models import Token from .serializers import RegisterSerializer from django.contrib.auth import get_user_model User = get_user_model() class RegisterView(generics.CreateAPIView): queryset = User.objects.all() serializer_class = RegisterSerializer def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.save() data = serializer.data if Token.objects.filter(user=user).exists(): token = Token.objects.get(user=user) data['token'] = token.key else: data['error'] = 'User dont have token. Please login' headers = self.get_success_headers(serializer.data) return Response(data, status=status.HTTP_201_CREATED, headers=headers)

from django.urls import path, include from .views import RegisterView urlpatterns = [ path('', include('dj_rest_auth.urls')), path('register/', RegisterView.as_view()) ]

from rest_framework import serializers, validators from django.contrib.auth.models import User from django.contrib.auth.password_validation import validate_password class RegisterSerializer(serializers.ModelSerializer): email = serializers.EmailField( required = True, validators=[validators.UniqueValidator(queryset=User.objects.all())] ) password = serializers.CharField( required = True, write_only = True, validators = [validate_password], style = {"input_type":"password"} ) password1 = serializers.CharField( required = True, write_only = True, validators = [validate_password], style = {"input_type":"password"} ) class Meta: model = User fields = ( "username", "email", "first_name", "last_name", "password", "password1", ) def validate(self, data): if data["password"] != data["password1"]: raise serializers.ValidationError( {"password": "Password must be same with above !..."} ) return data def create(self, validated_data): password = validated_data.pop("password") validated_data.pop("password1") user = User.objects.create(**validated_data) user.set_password(password) user.save() return user

from rest_framework import generics from django.contrib.auth.models import User from .serializers import RegisterSerializer class RegisterView(generics.CreateAPIView): queryset = User.objects.all() serializer_class = RegisterSerializer def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.save() data = serializer.data if Token.objects.filter(user=user): token = Token.objects.get(user=user) data['token'] = token.key else: data['error'] = 'User does not have token . Try again ...' headers = self.get_success_headers(serializer.data) return Response(data, status=status.HTTP_201_CREATED, headers=headers)

from users.api.views import RegisterView path('register/', RegisterView.as_view()),

class UpdateUserSerializer(serializers.ModelSerializer): email = serializers.EmailField( required=True, validators=[validators.UniqueValidator(queryset=User.objects.all())] ) class Meta: model = User fields = ( "username", "id", "email", "first_name", "last_name", "profile_pic", "biography", )

class UpdateUserView(generics.RetrieveUpdateAPIView): #! We used RetrieveUpdateAPIView so that the user can only update. 👆 queryset = User.objects.all() serializer_class = UpdateUserSerializer

path('update-profile/<int:pk>', UpdateUserView.as_view()),

from django.db.models.signals import pre_save from django.dispatch import receiver from django.db import models from django.conf import settings from django.template.defaultfilters import slugify from blog.api.utils import get_random_code User = settings.AUTH_USER_MODEL class Category(models.Model): name = models.CharField(max_length=50) def __str__(self): return self.name class BlogPost(models.Model): STATUS = ( ("d", "DRAFT"), ("p", "PUBLISHED"), ) title = models.CharField(max_length=100) author = models.ForeignKey( User, related_name="post_user", on_delete=models.PROTECT, default='Anonymous User') category = models.ForeignKey( Category, related_name="post_category", on_delete=models.CASCADE) content = models.TextField() # image = models.ImageField(upload_to=None, height_field=None, width_field=None, max_length=None) image = models.URLField(max_length=200, blank=True, default="https://gravatar.com/avatar/2074b7945e3c6c493b0b2b94b24c35c2?s=400&d=robohash&r=x") published_date = models.DateTimeField(auto_now_add=True, blank=True) last_updated_date = models.DateTimeField(auto_now=True, blank=True) status = models.CharField(max_length=2, choices=STATUS) slug = models.SlugField(blank=True, null=True) def __str__(self): return self.title class Like(models.Model): user = models.ForeignKey( User, related_name="like_user", on_delete=models.PROTECT) post = models.ForeignKey( BlogPost, related_name="like_post", on_delete=models.CASCADE) def __str__(self): return self.user class Comment(models.Model): content = models.TextField() time_stamp = models.DateTimeField(auto_now_add=True, blank=True) user = models.ForeignKey(User, related_name="comment_user", on_delete=models.PROTECT, default='Anonymous User') post = models.ForeignKey( BlogPost, related_name="comment_post", on_delete=models.CASCADE) def __str__(self): return self.user class Post_view(models.Model): user = models.ForeignKey( User, related_name="post_viewed_user", on_delete=models.PROTECT) post = models.ForeignKey( BlogPost, related_name="viewed_post", on_delete=models.CASCADE) viewed_date_time = models.DateTimeField(auto_now_add=True, blank=True)

from django.contrib import admin from blog.models import BlogPost, Category, Comment, Like, Post_view admin.site.register(Category) admin.site.register(Like) admin.site.register(BlogPost) admin.site.register(Comment) admin.site.register(Post_view)

from django.db.models.signals import pre_save from django.dispatch import receiver from django.template.defaultfilters import slugify from blog.models import BlogPost from .utils import get_random_code @receiver(pre_save, sender=BlogPost) def pre_save_create_slug(sender, instance,**kwargs): if not instance.slug: instance.slug = slugify(instance.title + " " + get_random_code())

import uuid #! 👆 user uniqe id => Slug field must be uniqe def get_random_code(): code = str(uuid.uuid4())[:11].replace("-","") return code

from django.apps import AppConfig class BlogConfig(AppConfig): default_auto_field = "django.db.models.BigAutoField" name = "blog" def ready(self): import blog.api.signals

from rest_framework import serializers from blog.models import BlogPost, Category, Comment, Like, Post_view from users.api.serializers import UserSerializer from django.contrib.auth import get_user_model # User = settings.AUTH_USER_MODEL User = get_user_model() # class AllUserSerializer(serializers.ModelSerializer): # class Meta: # model = User # fields = ( # "username", # "first_name", # "last_name", # "profile_pic", # "biography" # ) class CategorySerializer(serializers.ModelSerializer): class Meta: model = Category fields = ( 'id', 'name' ) class CommentSerializer(serializers.ModelSerializer): # user = serializers.StringRelatedField(read_only=True) # user_id = serializers.IntegerField() # post = serializers.StringRelatedField() # post_id = serializers.IntegerField() # class Meta: # model = Comment # fields = "__all__" # kimin yorum yaptığını belirtmek için ilave edildi user = serializers.StringRelatedField(read_only=True) class Meta: model = Comment fields = ( "id", "content", "time_stamp", "user", ) class LikeSerializer(serializers.ModelSerializer): # like_user = AllUserSerializer(many=True, read_only=True) user = serializers.StringRelatedField() user_id = serializers.IntegerField() class Meta: model = Like fields = ( "id", "user", "user_id", "post", # "like_user" ) class BlogPostSerializer(serializers.ModelSerializer): comment_post = CommentSerializer(many=True, read_only=True) like_post = LikeSerializer(many=True, read_only=True) category = serializers.StringRelatedField(read_only=True) category_id = serializers.IntegerField() author = serializers.StringRelatedField(read_only=True) author_id = serializers.IntegerField(read_only=True) like_count = serializers.SerializerMethodField() comment_count = serializers.SerializerMethodField() post_view_count = serializers.SerializerMethodField() class Meta: model = BlogPost fields = ( "id", "title", "author", "author_id", "category_id", "category", "content", "image", "published_date", "last_updated_date", "status", "slug", "like_count", "comment_count", "post_view_count", "comment_post", "like_post", ) read_only_fields = ( "published_date", "updated_date", "slug", ) def get_like_count(self, obj): return Like.objects.filter(post=obj.id).count() def get_comment_count(self, obj): return Comment.objects.filter(post=obj.id).count() def get_post_view_count(self, obj): return Post_view.objects.filter(post=obj.id).count()

from rest_framework import permissions from rest_framework.exceptions import ValidationError from rest_framework.generics import get_object_or_404 from rest_framework import generics, status from blog.api.pagination import CustomLimitOffsetPagination from blog.api.permissions import IsAdminUserOrReadOnly, IsPostOwnerOrReadOnly from blog.api.serializers import BlogPostSerializer, CategorySerializer, CommentSerializer,LikeSerializer from rest_framework.response import Response from blog.models import BlogPost, Category, Post_view, Comment, Like class CategoryView(generics.ListCreateAPIView): queryset = Category.objects.all() serializer_class = CategorySerializer permission_classes = [IsAdminUserOrReadOnly] class BlogPostView(generics.ListCreateAPIView): queryset = BlogPost.objects.all() serializer_class = BlogPostSerializer pagination_class = CustomLimitOffsetPagination permission_classes = [permissions.IsAuthenticatedOrReadOnly] def perform_create(self, serializer): serializer.save(author=self.request.user) class BlogPostDetailView(generics.RetrieveUpdateDestroyAPIView): queryset = BlogPost.objects.all() serializer_class = BlogPostSerializer lookup_field = "slug" permission_classes = [IsPostOwnerOrReadOnly] def retrieve(self, request, *args, **kwargs): instance = self.get_object() serializer = self.get_serializer(instance) # Post_view.objects.get_or_create(user=request.user, post=instance) Post_view.objects.create(user=request.user, post=instance) return Response(serializer.data) class CommentView(generics.CreateAPIView): queryset = Comment.objects.all() serializer_class = CommentSerializer permission_classes = [permissions.IsAuthenticatedOrReadOnly] def perform_create(self, serializer): print(self.kwargs) slug = self.kwargs.get('slug') blog = get_object_or_404(BlogPost, slug=slug) user = self.request.user comments = Comment.objects.filter(post=blog, user=user) if comments.exists(): raise ValidationError( "You can not add another comment, for this Post !") serializer.save(post=blog, user=user) class LikeView(generics.ListCreateAPIView): queryset = Like.objects.all() serializer_class = LikeSerializer def create(self, request, *args, **kwargs): user = request.data.get('user_id') post = request.data.get('post') serializer = self.get_serializer(data=request.data) exists_like = Like.objects.filter(user_id=user, post=post) serializer.is_valid(raise_exception=True) if exists_like: exists_like.delete() else: self.perform_create(serializer) headers = self.get_success_headers(serializer.data) return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

from rest_framework import permissions class IsPostOwnerOrReadOnly(permissions.BasePermission): #! If the request.user is the same as the author, it can update/delete. Otherwise can view 👇 def has_object_permission(self, request, view, obj): if request.method in permissions.SAFE_METHODS: return True return request.user == obj.author class IsAdminUserOrReadOnly(permissions.IsAdminUser): #! "Admin" can do any action. If not it can only view 👇 def has_permission(self, request, view): is_admin = super().has_permission(request, view) return request.method in permissions.SAFE_METHODS or is_admin

from rest_framework.pagination import LimitOffsetPagination #! For 6 posts to appear on each page 👇 class CustomLimitOffsetPagination(LimitOffsetPagination): default_limit = 6

from .views import ( CategoryView, BlogPostView, BlogPostDetailView, CommentView, LikeView ) from django.urls import path from rest_framework import routers urlpatterns = [ path("category/", CategoryView.as_view()), path("posts/", BlogPostView.as_view()), path("like/", LikeView.as_view()), path("posts/<str:slug>/", BlogPostDetailView.as_view()), path("posts/<str:slug>/add_comment/", CommentView.as_view()), ]

 import os import sys # Set: Project Main Path: path = '/home/anyWhereUserName/ProjectName' if path not in sys.path: sys.path.append(path) # Set: Where is settings.py: os.environ['DJANGO_SETTINGS_MODULE'] = 'projectFolderName.settings' from django.core.wsgi import get_wsgi_application application = get_wsgi_application()

MIDDLEWARE = [ ..., "corsheaders.middleware.CorsMiddleware", ..., ]

CORS_ALLOW_ALL_ORIGINS=True

CORS_ALLOW_METHODS = [ "DELETE", "GET", "OPTIONS", "PATCH", "POST", "PUT", ]