test

server/serializers/auth_serializers.py

@@ -4,7 +4,6 @@
 )
 from rest_framework_simplejwt.settings import api_settings
 
-from datetime import timedelta
 from django.utils import timezone
 
 class CustomTokenObtainPairSerializer(TokenObtainPairSerializer):

server/serializers/product_serializers.py

@@ -1,40 +1,60 @@
+from django.contrib.auth import get_user_model
+
 from rest_framework import serializers
 
 from server.models import Product
-
 from .category_serializers import CategorySerializer
+from server.exeption import RESOURCE_NOT_FOUND
 
+User = get_user_model()
 
-class ProductCreateSerializer(serializers.ModelSerializer):
-    user = serializers.HiddenField(default=serializers.CurrentUserDefault())
+class ProductFieldsAllSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Product
+        fields = "__all__"
+
+class ProductBaseSerializer(serializers.ModelSerializer):
+    user_id = serializers.IntegerField(required=False)
 
     class Meta:
         model = Product
         fields = (
-            'id', 'title', 'metaTitle', 'summary',
+            'id', 'slug', 'title', 'metaTitle', 'summary',
             'accessibility', 'condition', 'warehouse',
             'promotional', 'checks', 'price', 'discount',
-            'category', 'user'
+            'category', 'user_id',
         )
-        extra_kwargs = {'id': {'read_only': True}}
+        extra_kwargs = {
+            'id': {
+                'read_only': True
+            },
+            'slug': {
+                "read_only": True
+            },
+        }
+    def validate(self, attrs):
+        user_id = attrs.pop("user_id", None)
 
+        try:
+            if user_id is None and not user_id:
+                user = self.context["request"].user
+            else:
+                user = User.objects.get(pk=user_id)
+        except User.DoesNotExist:
+            raise serializers.ValidationError(RESOURCE_NOT_FOUND)
+
+        attrs['user'] = user
+        return super().validate(attrs)
 
+class ProductCreateSerializer(ProductBaseSerializer):
+    pass
 
+class ProductUpdateSerializer(ProductBaseSerializer):
     def validate(self, attrs):
-        request = self.context.get("request")
-        if not request or not request.user.is_authenticated:
-            raise serializers.ValidationError("User is not authenticated")
         return super().validate(attrs)
 
-class ProductDetailSerializer(serializers.ModelSerializer):
+class ProductDetailSerializer(ProductFieldsAllSerializer):
     category = CategorySerializer(read_only=True)
 
-    class Meta:
-        model = Product
-        fields = "__all__"
-
-
-class ProductListSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Product
-        fields = "__all__"
+class ProductListSerializer(ProductFieldsAllSerializer):
+    pass

src/auth.ts

@@ -1,14 +1,10 @@
 import CredentialsProvider from "next-auth/providers/credentials"
 import { NextAuthOptions } from "next-auth";
-import { AuthenticatedFields, JWTUser } from "./types/app/auth.types";
+import { AuthenticatedFields, JWTUser, ReponseUserToken } from "./types/app/auth.types";
 import pages from "./service/route";
 
+import { requestTokenAuthorize, refreshAccessToken } from "./core/api/token.api";
 
-async function refreshAccessToken(token) {
-    try {
-
-    }
-}
 
 export const authOptions: NextAuthOptions = {
     providers: [
@@ -28,25 +24,17 @@ export const authOptions: NextAuthOptions = {
                     password: credentials.password
                 }
                 try {
-                    const resData = await fetch(
-                        `${process.env.PRODUCT_API_URL}/api/token/`,
-                        {
-                            method: "POST",
-                            headers: {
-                                "Content-Type": "application/json"
-                            },
-                            body: JSON.stringify(data)
-                        }
-                    )
+                    const resData = await requestTokenAuthorize<ReponseUserToken>(data);
 
-                    const { access, refresh, id, username, email } = await resData.json();
+                    const { access, refresh, id, username, email, accessTokenExpires  } = resData;
 
                     return {
                         id: String(id),
                         username: username,
                         email: email,
                         accessToken: access,
-                        refreshToken: refresh
+                        refreshToken: refresh,
+                        accessTokenExpires: accessTokenExpires
                     } as JWTUser
 
                 } catch(error) {
@@ -67,12 +55,21 @@ export const authOptions: NextAuthOptions = {
         async jwt({token, user}) {
             const jwtUser = user as JWTUser
 
+            console.log(token, user)
             if(user) {
-                token.accessToken = jwtUser.accessToken;
-                token.id = jwtUser.refreshToken;
+                return {
+                    user,
+                    accessToken: jwtUser.accessToken,
+                    refreshToken: jwtUser.refreshToken,
+                    accessTokenExpires: jwtUser.accessTokenExpires * 1000,
+                }
+            }
+
+            if(Date.now() < (token.accessTokenExpires as number)) {
+                return token;
             }
 
-            return token;
+            return await refreshAccessToken(token.refreshToken as string);
         },
 
         async session ({session, token}) {

src/components/layouts/Main/Store/ContentWrapper/ContentWrapper.tsx

@@ -14,8 +14,8 @@ interface ContentWrapperProps {
 }
 
 const ContentWrapper: FC<ContentWrapperProps> = async ({param}) => {
-    const session = await getServerSession(authOptions);
-    const accessToken = (session?.user as JWTUser).accessToken
+    // const session = await getServerSession(authOptions);
+    // const accessToken = (session?.user as JWTUser).accessToken
     const searchQuery = param.q ?? param.searchQuery;
     const currentPage = Number(param?.page) || 1;
 
@@ -24,7 +24,7 @@ const ContentWrapper: FC<ContentWrapperProps> = async ({param}) => {
             searchQuery,
             {isPagination: true,
             currentPage: currentPage},
-            accessToken
+            // accessToken
         )
 
         return (

src/core/api/product.api.ts

@@ -6,7 +6,7 @@ import { axios } from "@/service/axios";
 async function getProductsData<T>(search: ProductFunApiSearchAttributes, {
     isPagination = false,
     currentPage = null
-}: ProductFunApiPaginationAttributes = {}, authToken: string): Promise<T> {
+}: ProductFunApiPaginationAttributes = {}, authToken?: string): Promise<T> {
     "use server"
 
     try {
@@ -23,11 +23,17 @@ async function getProductsData<T>(search: ProductFunApiSearchAttributes, {
         if (params.length > 0)
             url += `?${params.join("&")}`;
 
-        const headers = {
-            "Authorization": `Bearer ${authToken}`
+
+        const options: [string, Record<string, string>?] = [url];
+
+        if(authToken) {
+            const headers = {
+                "Authorization": `Bearer ${authToken}`
+            }
+            options.push(headers)
         }
-        console.log(headers)
-        const data = await axios.get<T>(url, headers);
+
+        const data = await axios.get<T>(...options);
         return data;
     } catch(error) {
         console.error(error)

src/core/api/token.api.ts

@@ -0,0 +1,36 @@
+import { axios } from "@/service/axios";
+import { AuthenticatedFields } from "@/types/app/auth.types";
+
+async function requestTokenAuthorize<T>(body: AuthenticatedFields): Promise<T> {
+    "use server"
+
+    try {
+        const data = await axios.post<T, AuthenticatedFields>("/api/token/", body);
+        return data;
+    } catch(error) {
+        console.error(error)
+        throw error
+    }
+}
+
+async function refreshAccessToken(token: string) {
+    try {
+        const data = {
+            refresh: token
+        }
+        const resData = await axios.post<{access: string, access_expires_in: number}, {refresh: string}>(
+            "/api/v1/refresh/",
+            data
+        )
+        return {
+            accessToken: resData.access,
+            accessTokenExpires: resData.access_expires_in * 300,
+            refreshToken: token
+        }
+    } catch(error) {
+        console.error(error)
+        throw error
+    }
+}
+
+export {requestTokenAuthorize, refreshAccessToken};

src/types/app/auth.types.ts

@@ -6,14 +6,22 @@ export interface AuthenticatedFields {
     password: string
 }
 
-
-
 export interface JWTTokenType extends JWT {
     accessToken: string,
     refreshToken: string
 }
 
 export interface JWTUser extends User {
     accessToken: string,
-    refreshToken: string
+    refreshToken: string,
+    accessTokenExpires: number
+}
+
+export interface ReponseUserToken {
+    access: string;
+    refresh: string;
+    id: number;
+    username: string;
+    email: string;
+    accessTokenExpires: number
 }