Profile socials link

src/app/api/socials/route.ts

@@ -0,0 +1,16 @@
+import SocialsLink from "@/server/controllers/socials-controller";
+
+export async function POST(request: Request) {
+    const body = await request.json();
+    const { userId, twitchUrl } = body;
+    try {
+        await SocialsLink({ userId, twitchUrl });
+        return Response.json({ message: "Social added successfully" }, { status: 200 });
+    } catch (error) {
+        console.error("Error adding socials:", error);
+        return Response.json(
+            { error: "Error adding socials" },
+            { status: 500 }
+        );
+    }
+}

src/app/api/twitch/route.ts

@@ -0,0 +1,32 @@
+import twitchLive from "@/server/controllers/twitch-live";
+
+export async function GET(request: Request) {
+    const { searchParams } = new URL(request.url); 
+    const userId = searchParams.get('userId') || "";
+
+
+    try {
+        const res = await twitchLive({ userId });
+        const userName = res.twitchUrl.split('/').pop(); 
+        const clientId = process.env.TWITCH_CLIENT_ID;
+        const accessToken = process.env.TWITCH_ACCESS_TOKEN;
+
+        if (!clientId || !accessToken) {
+            throw new Error("Twitch credentials are not defined");
+        }
+
+        const liveStreamData = await fetch(`https://api.twitch.tv/helix/streams?user_login=${userName}`, {
+            headers: {
+                "Client-ID": clientId,
+                "Authorization": `Bearer ${accessToken}`
+            }
+        });
+
+        const data = await liveStreamData.json();
+        const isLive = data.data.length > 0;
+        return Response.json({ isLive });
+    } catch (err) {
+        console.error("Error in GET function:", err);
+        return Response.json({ Message: "Failed to fetch Twitch data." }, { status: 500 });
+    }
+}

src/app/socials/page.tsx

@@ -0,0 +1,5 @@
+import Socials from "@/components/socials";
+
+export default function SocialsPage() {
+    return <Socials/>
+}

src/auth.ts

@@ -29,6 +29,10 @@ export const {
             }),
           ]
         : []),
-    ],
+    ],callbacks: {
+    async session({session}) {
+        return session
+      }
+    }
   };
 });

src/components/data-table.tsx

@@ -64,8 +64,7 @@ export function DataTable<TData, TValue>({
   });
 
   const handleRowClick = (row: any) => {
-    const route = `/profile/${row.original.profile_id}`;
-    router.push(route);
+    console.log(data)
   };
 
   return (

src/components/leaderboard.tsx

@@ -38,6 +38,21 @@ export default function Leaderboard() {
 
   const { limit, onPaginationChange, skip, pagination } = usePagination();
 
+  const getLiveStatus = async (userId:string) => {
+    try {
+    const abc = "66e2cc127feec120c8fa955f"
+    const response = await fetch(`/api/twitch?userId=${abc}`);
+    if (!response.ok) {
+      throw new Error(`Error: ${response.statusText}`);
+    }
+    const { isLive } = await response.json();
+    return isLive;
+  } catch (error) {
+    console.error(`Failed to fetch live status for userId ${userId}:`, error);
+    return false; // Default to false if there's an error
+  }
+  };
+
   const getLeaderboardData = useCallback(
     async (searchQuery: string) => {
       try {
@@ -63,6 +78,9 @@ export default function Leaderboard() {
         }
 
         const { leaderboardPlayers, totalRecords } = await response.json();
+
+
+
         setLeaderboardData(leaderboardPlayers);
         setTotalRecords(totalRecords);
       } catch (error) {

src/components/socials.tsx

@@ -0,0 +1,51 @@
+"use client";
+import { Twitch } from "lucide-react";
+import { useSession } from "next-auth/react";
+import { useState } from "react";
+import { toast } from "./ui/use-toast";
+
+export default function Socials() {
+    const [twitchUrl, setTwitchUrl] = useState("");
+    const { data: session } = useSession();
+    const loggedInUserId = session?.userId;
+    async function handleSubmit(e:React.FormEvent<HTMLFormElement>):Promise<void> {
+        e.preventDefault();
+        const response = await fetch("/api/socials", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ userId: loggedInUserId, twitchUrl }),
+        });
+
+        if (response.ok) {
+            const data = await response.json();
+            toast({
+                title: data.message || "Twitch URL added successfully",
+                duration: 3000,
+            });
+        } else {
+            const errorData = await response.json(); 
+            toast({
+                title: errorData.error || "Error adding Twitch URL",
+                duration: 3000,
+            });
+        }
+    }
+    return (
+        <div className="flex items-center justify-center min-h-screen">
+            <div className="flex items-center">
+                <Twitch className="w-10 h-10 text-purple-500 transition-transform duration-300 ease-in-out transform hover:scale-110 hover:text-purple-700" />
+                <form className="flex items-center ml-2" onSubmit={handleSubmit}>
+                    <input 
+                        type="text" 
+                        placeholder="Enter your twitch channel url" 
+                        className="border rounded-l-md px-2 py-1 w-[250px]"
+                        onChange={(e)=>{setTwitchUrl(e.target.value)}}
+                    />
+                    <button className="bg-purple-500 text-white rounded-r-md px-3 py-1 hover:bg-purple-700 transition ml-4">
+                        Submit
+                    </button>
+                </form>
+            </div>
+        </div>
+    );
+}

src/db/mongo/model/SocialsModel.ts

@@ -0,0 +1,5 @@
+import mongoose, { model } from "mongoose";
+import { SocialsSchema } from "../schemas/SocialsSchema";
+import { Socials } from "@/types/Socials";
+
+export const SocialsModel = mongoose.models.Socials || model<Socials>("Socials", SocialsSchema);

src/db/mongo/schemas/LeaderboardPlayerSchema.ts

@@ -26,4 +26,5 @@ export const LeaderboardPlayerSchema = new Schema({
   country: { type: String, required: true },
   winPercent: { type: Number, required: true },
   totalGames: { type: Number, required: true },
+  isLive: { type: Boolean, required: true },
 });

src/db/mongo/schemas/SocialsSchema.ts

@@ -0,0 +1,8 @@
+import { Schema } from "mongoose";
+
+export const SocialsSchema = new Schema({
+    userId: { type: String, required: true },
+    twitchUrl: { type: String, default: null },
+}, {
+    timestamps: true,
+});

src/server/controllers/socials-controller.ts

@@ -0,0 +1,17 @@
+import { SocialsModel } from "@/db/mongo/model/SocialsModel";
+import getMongoClient from "@/db/mongo/mongo-client";
+import { Socials } from "@/types/Socials";
+
+export default async function SocialsLink(params:Socials): Promise<void> {
+    const { userId, twitchUrl } = params;
+    await getMongoClient();
+    try {
+        const result = await SocialsModel.create({ userId, twitchUrl });
+        if (result.matchedCount === 0) {
+            throw new Error(`Error creating social`);
+        }
+    } catch (error) {
+        console.error("Error editing game title:", error);
+        throw error;
+    }
+}

src/server/controllers/twitch-live.ts

@@ -0,0 +1,18 @@
+import { SocialsModel } from "@/db/mongo/model/SocialsModel";
+import getMongoClient from "@/db/mongo/mongo-client";
+
+type Params = {
+    userId: string;
+};
+
+export default async function twitchLive(params: Params): Promise<any> {
+    const { userId } = params; 
+    await getMongoClient();
+    try {
+        const twitchName = await SocialsModel.findOne({ userId });
+        return twitchName;
+    } catch (err) {
+        console.error("Error fetching Twitch name:", err);
+        throw new Error("Failed to fetch Twitch name.");
+    }
+}

src/types/LeaderboardPlayer.ts

@@ -24,4 +24,5 @@ export interface ILeaderboardPlayer {
   country: String;
   winPercent: Number;
   totalGames: Number;
+  isLive: Boolean;
 }

src/types/Socials.ts

@@ -0,0 +1,4 @@
+export type Socials = {
+    userId: string;
+    twitchUrl: string;
+};