Update src/routes/api/takeSnap.js

Reviewed-on: #26

Dockerfile

@@ -1,21 +1,26 @@
-ARG NODE_VERSION=18
+# Use an official Node.js runtime as a parent image
+FROM node:20-alpine
 
-FROM node:${NODE_VERSION}-alpine
+# Set the working directory inside the container
+WORKDIR /app
 
-ENV NODE_ENV production
+# Copy package files and set ownership
+COPY --chown=node:node package*.json ./
 
-RUN mkdir -p /usr/src/iimtt_api && chown -R node:node /usr/src/iimtt_api
-
-WORKDIR /usr/src/iimtt_api
-
-COPY package.json yarn.lock ./
-
-USER node
-
-RUN yarn install --pure-lockfile
+# Install dependencies
+RUN npm install --omit=dev
 
+# Copy the rest of the app's source code with correct ownership
 COPY --chown=node:node . .
 
-EXPOSE 5174
+# Use a non-root user for better security
+USER node
 
-CMD yarn start
+# Expose the application port
+EXPOSE 3000
+
+# Set environment variables (optional)
+ENV NODE_ENV=production
+
+# Start the application
+CMD ["npm", "run", "start"]

package.json

@@ -22,8 +22,7 @@
     "prettier:fix": "prettier --write **/*.js",
     "docker:prod": "docker-compose -f docker-compose.yml -f docker-compose.prod.yml up",
     "docker:dev": "docker-compose -f docker-compose.yml -f docker-compose.dev.yml up",
-    "docker:test": "docker-compose -f docker-compose.yml -f docker-compose.test.yml up",
-    "prepare": "husky install"
+    "docker:test": "docker-compose -f docker-compose.yml -f docker-compose.test.yml up"
   },
   "keywords": [
     "node",
@@ -49,19 +48,22 @@
   ],
   "dependencies": {
     "aws-sdk": "^2.1669.0",
-    "axios": "^1.7.7",
+    "axios": "^1.8.2",
     "bcryptjs": "^2.4.3",
     "body-parser": "^1.20.2",
     "compression": "^1.7.4",
     "cors": "^2.8.5",
     "cross-env": "^7.0.0",
     "dotenv": "^10.0.0",
-    "express": "^4.17.1",
+    "express": "^4.21.2",
     "express-mongo-sanitize": "^2.0.0",
     "express-rate-limit": "^5.0.0",
-    "form-data": "^4.0.1",
+    "form-data": "^4.0.2",
+    "formdata-node": "^6.0.3",
+    "fs": "^0.0.1-security",
     "helmet": "^4.1.0",
     "http-status": "^1.4.0",
+    "install": "^0.13.0",
     "joi": "^17.3.0",
     "jsonwebtoken": "^8.5.1",
     "mariadb": "^3.4.0",
@@ -69,10 +71,14 @@
     "mongoose": "^8.7.1",
     "morgan": "^1.9.1",
     "mysql2": "^3.11.0",
+    "node-fetch": "^3.3.2",
     "nodemailer": "^6.3.1",
+    "npm": "^11.0.0",
     "passport": "^0.4.0",
     "passport-jwt": "^4.0.0",
+    "path": "^0.12.7",
     "pm2": "^5.1.0",
+    "puppeteer": "^24.4.0",
     "swagger-jsdoc": "^6.0.8",
     "swagger-ui-express": "^4.1.6",
     "validator": "^13.0.0",
@@ -89,7 +95,6 @@
     "eslint-plugin-prettier": "^3.1.1",
     "eslint-plugin-security": "^1.4.0",
     "faker": "^5.1.0",
-    "husky": "7.0.4",
     "jest": "^26.0.1",
     "lint-staged": "^11.0.0",
     "node-mocks-http": "^1.8.0",

src/models/gameModel.js

@@ -2,12 +2,11 @@ const mongoose = require("mongoose");
 
 const gameSchema = new mongoose.Schema({
   gameName: { type: String, required: true },
-  userId: { type: String, required: true },
+  childId: { type: String, required: true },
   gameID: { type: String, required: true },
   gameTime: { type: String, required: false },
-  score: { type: String},
-  gameStar: { type: Number},
-  screenshotUrl: { type: String }, // Store the S3 URL of the screenshot
-});
+  gameStar: { type: Number },
+  screenshotUrl: { type: String },
+}, { collection: "gameData" });
 
 module.exports = mongoose.model("Game", gameSchema);

src/models/getGalleyImage.js

@@ -2,7 +2,7 @@ const mongoose = require('mongoose');
 
 // Define the GalleryImage schema
 const galleryImageSchema = new mongoose.Schema({
-    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },  // Assuming you have a User model
+    childId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },  // Assuming you have a User model
     gameName: { type: String, required: true },
     gameID: { type: String, required: true },
     screenshotUrl: { type: String, required: true },

src/models/imageGallery.js

@@ -2,7 +2,7 @@ const mongoose = require("mongoose");
 
 const galleryImageScema = new mongoose.Schema({
   gameName: { type: String, required: true },
-  userId: { type: String, required: true },
+  childId: { type: String, required: true },
   gameID: { type: String, required: true },
   screenshotUrl: { type: String }, 
 });

src/module/base64ToImageFile.js

@@ -0,0 +1,21 @@
+const fs = require('fs');
+const path = require('path');
+
+function base64ToImageFile(base64, fileName) {
+    const matches = base64.match(/^data:(.+);base64,(.+)$/);
+    if (!matches) {
+        throw new Error("Invalid Base64 string");
+    }
+
+    const mimeType = matches[1];  // e.g., image/png
+    const base64Data = matches[2];  // Actual base64 string
+
+    const buffer = Buffer.from(base64Data, 'base64');
+    const filePath = path.join(__dirname, fileName);
+
+    fs.writeFileSync(filePath, buffer);
+
+    return filePath;
+}
+
+module.exports = { base64ToImageFile };

src/routes/api/aiEvaluateImageToStar.js

@@ -1,30 +1,27 @@
 const AWS = require('aws-sdk');
 const axios = require('axios');
-const FormData = require('form-data');
 const mongoose = require('mongoose');
+const FormData = require('form-data'); 
 const Game = require('../../models/gameModel');
-
 const aiEvaluateImageToStar = async (req, res) => {
   try {
-    const { userId, gameName, gameID, gameTime, gameStar, screenShot } = req.body;
+    const { childId, gameName, gameID, gameTime, gameStar, screenShot } = req.body;
     if (!screenShot) {
       return res.status(400).json({ error: 'Screenshot is required' });
     }
 
-      const formData = new FormData();
-      formData.append('image', screenShot);
-      const screenshotUrl = await axios.post('https://teachertrainingchennai.in/api/uploadBase64/', formData, {
-        headers: {
-          'Content-Type': 'multipart/form-data',
-        },
-      })
-        // .then(response => {
-        //   console.log('Response:', response.data);
-        // })
-        // .catch(error => {
-        //   console.error('Error:', error);
-        // });
-        console.log(screenshotUrl.data.filePath)
+    // Upload screenshot
+    const formData = new FormData();
+    formData.append('image', screenShot);
+    
+    const screenshotUploadResponse = await axios.post('https://teachertrainingchennai.in/api/uploadBase64/', formData, {
+      headers: {
+        ...formData.getHeaders(),
+      },
+    });
+
+    const screenshotUrl = screenshotUploadResponse.data.filePath;
+    // The coloring was done by a 5-year-old kid. Give a score between 1 to 10 in JSON format.
     const openAiPayload = {
       model: 'gpt-4o-mini',
       messages: [
@@ -33,12 +30,12 @@ const aiEvaluateImageToStar = async (req, res) => {
           content: [
             {
               type: 'text',
-              text: 'The coloring was done by a 5-year-old kid. Give a score between 3 to 5 in JSON format.',
+              text: 'The coloring was done by a 5-year-old kid. Give a score between 1 to 10 the Respond ONLY with a valid JSON object like {"score": 7}. No extra text, no formatting, just raw JSON.',
             },
             {
               type: 'image_url',
               image_url: {
-                url: screenshotUrl.data.filePath,
+                url: screenshotUrl,
               },
             },
           ],
@@ -47,7 +44,6 @@ const aiEvaluateImageToStar = async (req, res) => {
       max_tokens: 300,
     };
 
-    // console.log('AAAAAA')
     const openAiResponse = await axios.post(
       'https://api.openai.com/v1/chat/completions',
       openAiPayload,
@@ -58,18 +54,29 @@ const aiEvaluateImageToStar = async (req, res) => {
         },
       }
     );
-const rResp=openAiResponse.data.choices[0].message;
-const cleanContent = rResp.content.replace(/```json|```/g, '').trim();
-const parsedScore = JSON.parse(cleanContent);
-// console.log(parsedScore); // { score: 8 }
+
+
+    if (!openAiResponse.data.choices || openAiResponse.data.choices.length === 0) {
+      throw new Error('Invalid OpenAI response format');
+    }
+
+    let scoreResponse = openAiResponse.data.choices[0].message.content.trim();
+
+    if (scoreResponse.startsWith('```json')) {
+      scoreResponse = scoreResponse.replace(/```json/, '').replace(/```/, '').trim();
+    }
+
+
+    const parsedScore = JSON.parse(scoreResponse);
+    // console.log('Parsed Score:', parsedScore);
+
     const gameData = new Game({
       gameName,
-      userId,
+      childId,
       gameID,
       gameTime,
-      score: parsedScore.score || 'N/A',
-      gameStar,
-      screenshotUrl:screenshotUrl.data.filePath,
+      gameStar: parsedScore.score || 'N/A',
+      screenshotUrl,
     });
 
     await gameData.save();
@@ -80,7 +87,7 @@ const parsedScore = JSON.parse(cleanContent);
     });
   } catch (error) {
     console.error('Error:', error.message);
-    return res.status(500).json({ error: 'Something went wrong' });
+    return res.status(500).json({ error: error.message || 'Something went wrong' });
   }
 };
 

src/routes/api/aiFeedbackActionParent.js

@@ -1,5 +1,5 @@
 const aiFeedbackOnReport = async (req, res) => {
-  const fetch = require('node-fetch');
+  // const fetch = require('node-fetch');
   const url = process.env.AI_API_ENDOINT;
   const api_key = process.env.AI_API_KEY;
   const payload = {

src/routes/api/aiFeedbackOnReport.js

@@ -1,5 +1,5 @@
 const aiFeedbackOnReport = async (req, res) => {
-  const fetch = require('node-fetch');
+  // const fetch = require('node-fetch');
   const url = process.env.AI_API_ENDOINT;
   const api_key = process.env.OPENAI_KEY;
   const payload = {

src/routes/api/aiFeedbackOnReportWithFollowup.js

@@ -1,7 +1,7 @@
 const aiFollowupQuestion = async (req, res) => {
 
   const { MongoClient } = require('mongodb');
-  const fetch = require('node-fetch');
+  // const fetch = require('node-fetch');
   const { v4: uuidv4 } = require('uuid');
   const url = process.env.MONGODB_URL;
   const dbName = process.env.MONGO_DB_NAME;

src/routes/api/aiFollowupQuestion.js

@@ -1,7 +1,7 @@
 const aiFollowupQuestion = async (req, res) => {
 
   const { MongoClient } = require('mongodb');
-  const fetch = require('node-fetch');
+  // const fetch = require('node-fetch');
   const { v4: uuidv4 } = require('uuid');
   const url = process.env.MONGODB_URL;
   const dbName = process.env.MONGO_DB_NAME;
@@ -30,8 +30,8 @@ const aiFollowupQuestion = async (req, res) => {
     });
   
     const data = await response.json();
-    console.log(process.env.OPENAI_KEY)
-    console.log(data)
+    // console.log(process.env.OPENAI_KEY)
+    // console.log(data)
     return data;
   }
   

src/routes/api/aiMarkDrawing.js

@@ -2,7 +2,7 @@ const aiMarkDrawing = async (req, res) => {
 
   
   const express = require('express');
-const fetch = require('node-fetch'); // For making HTTP requests
+// const fetch = require('node-fetch'); // For making HTTP requests
 const path = require('path');
 const fs = require('fs');
 

src/routes/api/aiTest.js

@@ -0,0 +1,166 @@
+const aiFollowupQuestion = async (req, res) => {
+  const { MongoClient } = require('mongodb');
+  // const fetch = require('node-fetch');
+  const { v4: uuidv4 } = require('uuid');
+  const url = process.env.MONGODB_URL;
+  const dbName = process.env.MONGO_DB_NAME;
+  const client = new MongoClient(url);
+
+  await client.connect();
+  const database = client.db(dbName);
+  const conversationsCollection = database.collection('conversations');
+
+  const MAX_TOKENS = 200;
+  const PROVIDER_KEYS = JSON.parse(process.env.PROVIDER_KEY || '[]');
+
+  const PROVIDER_MODELS = {
+    openai: [ "gpt-4o", "gpt-4o-mini", "o1", "o1-mini", "gpt-3.5-turbo", "gpt-3.5-turbo-mini", "gpt-3.5-mini", "gpt-3.5-turbo-2", "gpt-3.5-2", "gpt-3.5-turbo-2-mini", "gpt-3.5-2-mini" ],
+    deepseek: [ "deepseek-chat", "deepseek-reasoner", "deepseek-qa", "deepseek-qa-mini" ],
+    // Add more providers and models as needed
+  };
+
+  async function fetchOpenAICompletion(messages, model, max_tokens = MAX_TOKENS) {
+    // console.log(messages)
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${process.env.OPENAI_KEY}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: model,
+        messages: messages,
+        max_tokens: max_tokens,
+      }),
+    });
+    return response.json();
+  }
+
+  async function fetchDeepSeekCompletion(messages, model) {
+    const response = await fetch('https://api.deepseek.com/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${process.env.DEEPSEEK_KEY}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: model,
+        messages: messages,
+        stream: false,
+      }),
+    });
+    return response.json();
+  }
+
+  // Similar function for Gemini can be added here...
+
+  try {
+
+    const { prompt, sessionId, provider, model = "gpt-4o-mini", key, system } = req.body;
+
+    if (!key || !PROVIDER_KEYS.includes(key)) {
+      return res.status(403).json({
+        success: false,
+        error: 'Unauthorized: Invalid or missing key.',
+      });
+    }
+    
+    if (provider && req.body['list-models']) {
+      if (PROVIDER_MODELS[provider]) {
+        return res.json({
+          success: true,
+          models: PROVIDER_MODELS[provider],
+        });
+      } else {
+        return res.status(400).json({
+          success: false,
+          error: 'Invalid provider specified.',
+        });
+      }
+    }
+
+    // Check if the request is for listing AI providers
+    if (req.body['list-ais']) {
+      return res.json({
+        success: true,
+        providers: ['openai', 'deepseek', 'gemini', 'manual'],
+      });
+    }
+
+    if (!conversationsCollection) {
+      return res.status(500).json({
+        success: false,
+        error: 'MongoDB is not connected yet. Please try again later.',
+      });
+    }
+
+    let conversation;
+
+    if (!sessionId) {
+      const newSessionId = uuidv4();
+      conversation = {
+        sessionId: newSessionId,
+        conversationHistory: [
+          { role: 'system', content: system },
+          { role: 'user', content: prompt },
+        ],
+      };
+      await conversationsCollection.insertOne(conversation);
+    } else {
+      conversation = await conversationsCollection.findOne({ sessionId: sessionId });
+      if (!conversation) {
+        return res.status(400).json({
+          success: false,
+          error: 'Invalid session ID.',
+        });
+      }
+      conversation.conversationHistory.push({ role: 'user', content: prompt });
+    }
+
+    let aiResponse;
+
+    if(prompt.length > 3) {
+      switch (provider) {
+        case 'openai':
+          aiResponse = await fetchOpenAICompletion([{ role: 'user', content: prompt }], model);
+          // console.log(aiResponse)
+          break;
+        case 'deepseek':
+          aiResponse = await fetchDeepSeekCompletion([{ role: 'user', content: prompt }], model);
+          break;
+        // case 'gemini':
+        //   aiResponse = await fetchGeminiCompletion(conversation.conversationHistory, model);
+        //   break;
+        // Add more cases for other providers as needed
+        default:
+          return res.status(400).json({
+            success: false,
+            error: 'Invalid provider specified.',
+          });
+      }
+    }
+      
+
+    conversation.conversationHistory.push({ role: 'assistant', content: aiResponse.choices ? aiResponse.choices[0].message.content : aiResponse.response });
+
+    await conversationsCollection.updateOne(
+      { sessionId: conversation.sessionId },
+      { $set: { conversationHistory: conversation.conversationHistory } }
+    );
+
+    res.json({
+      success: true,
+      data: aiResponse.choices ? aiResponse.choices[0].message.content : aiResponse.response,
+      total_tokens: aiResponse.usage ? aiResponse.usage.total_tokens : undefined,
+      sessionId: conversation.sessionId,
+    });
+  } catch (error) {
+    console.error('Error generating response:', error.message);
+    res.status(500).json({
+      success: false,
+      error: 'Something went wrong. Please try again later.',
+    });
+  }
+};
+
+module.exports = aiFollowupQuestion;

src/routes/api/getGalleryImage.js

@@ -3,7 +3,7 @@ const GalleryImage = require('../../models/getGalleyImage');
 const getGalleryImage = async (req, res) => {
     try {
         // Extract query parameters for filtering (if provided)
-        const { gameName, userId, gameID} = req.query;
+        const { gameName, childId, gameID} = req.query;
 
         // Build a filter object based on the query parameters
         const filter = {};
@@ -12,15 +12,15 @@ const getGalleryImage = async (req, res) => {
             filter.gameName = gameName;
         }
 
-        if (userId) {
-            filter.userId = userId;
+        if (childId) {
+            filter.childId = childId;
         }
         if (gameID) {
             filter.gameID = gameID;
         }
 
         // Fetch gallery images with filters and selected fields
-        const galleryImages = await GalleryImage.find(filter).select('gameName userId gameID screenshotUrl');   // Select only these fields
+        const galleryImages = await GalleryImage.find(filter).select('gameName childId gameID screenshotUrl');   // Select only these fields
 
         if (!galleryImages.length) {
             return res.status(404).json({ message: 'No images found' });

src/routes/api/getGameData.js

@@ -0,0 +1,147 @@
+require("dotenv").config();
+const express = require("express");
+const mariadb = require("mariadb");
+
+const router = express.Router();
+
+// Create MariaDB connection pool
+const pool = mariadb.createPool({
+    host: process.env.MARIA_HOST,
+    user: process.env.MARIA_USER,
+    password: process.env.MARIA_PASS,
+    database: process.env.MARIA_DBNM,
+    connectionLimit: 5
+});
+ 
+const getGameData = async (req, res) => {
+    let conn;
+    let items = 'ws2gamelink';
+    try {
+        const { wsname } = req.query;
+        if (!items || !wsname) {
+            return res.status(400).json({ error: "Missing items or wsname parameter" });
+        }
+
+        console.log("Fetching game data from table:", items);
+
+        conn = await pool.getConnection();
+
+        // Fetching the first dataset
+        const ws2gamelinkQuery = `SELECT * FROM \`${items}\` WHERE wsname = ?`;
+        const rows = await conn.query(ws2gamelinkQuery, [wsname]);
+
+        if (!rows.length) {
+            return res.status(404).json({ error: "No data found" });
+        }
+
+        let gamelinkArray = rows[0].gamelink;
+
+        // Ensure gamelinkArray is an array
+        if (typeof gamelinkArray === "string") {
+            gamelinkArray = [gamelinkArray]; // Convert to array if it's a string
+        }
+        if (!Array.isArray(gamelinkArray)) {
+            return res.status(500).json({ error: "Invalid gamelink data format" });
+        }
+
+        const gameDataResults = [];
+
+        for (const link of gamelinkArray) {
+            const gameLinkParts = link.split('/');
+            let gameNameFromUrl = '';
+            let gameIdData = '';
+            let gameTableName = '';
+            let gameVersion = '';
+
+            if (gameLinkParts.length === 5) {
+                gameNameFromUrl = gameLinkParts[3];
+                gameIdData = gameLinkParts[4].split('=')[1]; // Extracting ID
+            } else if (gameLinkParts.length === 6) {
+                gameNameFromUrl = gameLinkParts[3];
+                gameVersion = gameLinkParts[4];
+                gameIdData = gameLinkParts[5].split('=')[1]; // Extracting ID
+            }
+
+            if (gameNameFromUrl === 'drawing' && gameVersion === 'v2') {
+                gameTableName = 'game_drawing_v2';
+            } else if (gameNameFromUrl === 'drawing' && gameVersion === 'v3') {
+                gameTableName = 'game_drawing_v3';
+            } else if (gameNameFromUrl === 'drawing' && gameVersion === 'drawing_writo') {
+                gameTableName = 'drawing_writo';
+            } else if (gameNameFromUrl === 'drawing' && gameVersion === 'drawing_phonics') {
+                gameTableName = 'drawing_phonics';
+            } else if (gameNameFromUrl === 'drawing') { 
+                gameTableName = 'game_drawing';  // General case, only if no version is specified
+            } else if (gameNameFromUrl === 'drag' && gameVersion === 'v2') {
+                gameTableName = 'game_drag_v2';
+            } else if (gameNameFromUrl === 'drag' && gameVersion === 'v4') {
+                gameTableName = 'game_drag_v4';
+            } else if (gameNameFromUrl === 'drag' && gameVersion === 'dragdrop_phonics') {
+                gameTableName = 'drag_drop_phonics';
+            } else if (gameNameFromUrl === 'drag' && gameVersion === 'match_phonics') {
+                gameTableName = 'drag_phonics';
+            } else if (gameNameFromUrl === 'drag') {
+                gameTableName = 'game_drag';  // General case for "drag"
+            } else if (gameNameFromUrl === 'tick' && gameVersion === 'tick_phonics_v1') {
+                gameTableName = 'tick_phonics_option_6';
+            } else if (gameNameFromUrl === 'tick' && gameVersion === 'tick_phonics_v2') {
+                gameTableName = 'tick_phonics_option_9';
+            } else if (gameNameFromUrl === 'tick' && gameVersion === 'tick_phonics_v3') {
+                gameTableName = 'game_tick_v3_phonics';
+            } else if (gameNameFromUrl === 'tick' && gameVersion === 'v1') {
+                gameTableName = 'game_tick_variant1';
+            } else if (gameNameFromUrl === 'tick' && gameVersion === 'v2') {
+                gameTableName = 'game_tick_variant2';
+            } else if (gameNameFromUrl === 'tick' && gameVersion === 'v3') {
+                gameTableName = 'game_tick_varient3';
+            } else if (gameNameFromUrl === 'cross' && gameVersion === 'cross_phonics_v1') {
+                gameTableName = 'cross_phonics_option_6';
+            } else if (gameNameFromUrl === 'cross' && gameVersion === 'cross_phonics_v2') {
+                gameTableName = 'cross_phonics_option_9';
+            } else if (gameNameFromUrl === 'cross' && gameVersion === 'v1') {
+                gameTableName = 'game_cross_varient1';
+            } else if (gameNameFromUrl === 'cross' && gameVersion === 'v2') {
+                gameTableName = 'game_cross_varient2';
+            } else if (gameNameFromUrl === 'cross' && gameVersion === 'v3') {
+                gameTableName = 'game_cross_varient3';
+            }
+
+
+
+
+            // else if (gameNameFromUrl === 'cross' && gameVersion === 'v2') {
+            //     gameTableName = 'game_cross_varient2';
+            // }
+            
+
+
+
+            
+
+            // console.log('Game Info:', { gameTableName, gameVersion, gameIdData });
+
+            if (gameTableName && gameIdData) {
+                let gameConn;
+                try {
+                    gameConn = await pool.getConnection();
+                    const gameDataQuery = `SELECT * FROM \`${gameTableName}\` WHERE id = ?`;
+                    const gameDataRows = await gameConn.query(gameDataQuery, [gameIdData]);
+                    gameDataResults.push({ link, data: gameDataRows });
+                } catch (gameError) {
+                    console.error("Error fetching game data:", gameError);
+                } finally {
+                    if (gameConn) gameConn.release();
+                }
+            }
+        }
+
+        res.json({ wsData: rows, gameData: gameDataResults });
+    } catch (err) {
+        console.error("Database error:", err);
+        res.status(500).json({ error: "Database error" });
+    } finally {
+        if (conn) conn.release();
+    }
+};
+
+module.exports = getGameData;

src/routes/api/getGameScore.js

@@ -15,15 +15,19 @@ async function main() {
         const collection = database.collection('gameData'); // Replace with your collection name
 
         // Find a single document
-        // const user = await collection.findOne({ userId: 'dsfdfgffgfgeg' });
-
-        const { userId, gameName, gameID } = req.body;
-            const gameData = await collection.findOne({
-                userId: userId,
-                gameName: gameName,
-                gameID: gameID
-            });
+        // const user = await collection.findOne({ childId: 'dsfdfgffgfgeg' });
 
+        const { childId, gameName, gameID } = req.body;
+            const gameData = await collection.findOne(
+                {
+                    childId: childId,
+                    gameName: gameName,
+                    gameID: gameID
+                },{
+                    sort: {_id: -1}
+                }
+            );
+            // console.log('gameData', gameData);
             if (gameData) {
                 res.json({gameData});
             } else {

src/routes/api/saveGalleryImage.js

@@ -4,7 +4,7 @@ const FormData = require('form-data'); // Import form-data for Node.js
 
 const saveGalleryImage = async (req, res) => {
     try {
-        const { userId, gameName, gameID, screenShot } = req.body;
+        const { childId, gameName, gameID, screenShot } = req.body;
 
         // Validate base64 format
         const isValidBase64 = validateBase64(screenShot);
@@ -41,12 +41,13 @@ const saveGalleryImage = async (req, res) => {
             throw new Error('Image upload failed: ' + uploadResponse.statusText);
         }
 
+         
         // Extract and store the uploaded image URL from the response
         const screenshotUrl = uploadResponse.data.urls[0];
 
         // Create and save gallery image data
         const galleryImageData = new GalleryImage({
-            userId,
+            childId,
             gameName,
             gameID,
             screenshotUrl,

src/routes/api/saveGameScore.js

@@ -1,69 +0,0 @@
-var MongoClient = require('mongodb').MongoClient;
-const AWS = require('aws-sdk');
-
-const saveGameScore = (req, res) => {
-    const url = process.env.MONGODB_URL;
-    const dbName = process.env.MONGO_DB_NAME;
-    const client = new MongoClient(url, { useUnifiedTopology: true });
-    client.connect((err) => {
-        if (err) {
-            console.error('Failed to connect to the server', err);
-            return;
-        }
-        // console.log('Connected successfully to server');
-        const db = client.db(dbName);
-        const collection = db.collection('gameData');
-        // const data = req.body;
-        const { userId, gameName, gameID, gameTime, score,gameStar, screenShot } = req.body;
-        const data = {
-            userId: userId,
-            gameName: gameName,
-            gameID: gameID,
-            gameTime: gameTime,
-            score: score,
-            gameStar:gameStar
-        };
-
-        collection.insertOne(data, (err, result) => {
-            if (err) {
-                console.error('Failed to insert document', err);
-            } else {
-                // console.log('Document inserted with _id: ', result.insertedId);
-            }
-            client.close((err) => {
-                if (err) {
-                    console.error('Failed to close connection', err);
-                } else {
-                    // console.log('Connection closed');
-                    const s3 = new AWS.S3({
-                        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-                        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-                        region: process.env.AWS_REGION
-                    });
-                    if (screenShot != undefined) {
-                        // Upload image to S3
-                        let base64Image = screenShot.split(";base64,").pop();
-                        const buffer = Buffer.from(base64Image, 'base64');
-                        const s3Params = {
-                          Bucket: process.env.S3_BUCKET_NAME,
-                          Key: `images/${result.insertedId}.png`, // Change the file extension to .png
-                          Body: buffer,
-                          ContentEncoding: 'base64',
-                          ContentType: 'image/jpeg' // Change the content type to image/png
-                        };
-                        try {
-                          const data = s3.upload(s3Params).promise();
-                          console.log(`File uploaded successfully at ${data.Location}`);
-                        } catch (err) {
-                          console.error(err);
-                        }
-                      };
-                    res.send(result.insertedId);
-                }
-            });
-        });
-    });
-  };
-  
-  module.exports = saveGameScore;
-  

src/routes/api/saveGameScore2.js

@@ -1,4 +1,5 @@
 const AWS = require("aws-sdk");
+const mongoose = require("mongoose");
 const Game = require("../../models/gameModel");
 
 const s3 = new AWS.S3({
@@ -7,35 +8,55 @@ const s3 = new AWS.S3({
   region: process.env.AWS_REGION,
 });
 
+// MongoDB Connection
+const mongoURI = process.env.MONGODB_URL;
+const dbName = process.env.MONGO_DB_NAME;
+
+mongoose.connect(mongoURI, {
+    dbName: dbName,
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
+  })
+  .then(() => 
+  console.log("Connected to MongoDB"))
+  .catch((err) => console.error("MongoDB connection error:", err));
+
 const saveGameScore2 = async (req, res) => {
-  const { userId, gameName, gameID, gameTime, score, gameStar, screenShot } = req.body;
+  const { childId, gameName, gameID, gameTime, score, gameStar, screenShot } = req.body;
+
   try {
-    if (!gameName || !userId || !gameID) {
+    if (!gameName || !childId || !gameID) {
       return res.status(400).json({ error: "Missing required fields" });
     }
+
     const newGame = new Game({
       gameName,
-      userId,
+      childId,
       gameID,
       gameTime,
       score,
       gameStar,
     });
+
+    // Save to MongoDB
     const result = await newGame.save();
+    // Upload screenshot to S3 if provided
     if (screenShot) {
-    let base64Image = screenShot.split(";base64,").pop();   
-    const buffer = Buffer.from(base64Image, 'base64');
-    //   const buffer = Buffer.from(screenShot, "base64");
+      let base64Image = screenShot.split(";base64,").pop();
+      const buffer = Buffer.from(base64Image, "base64");
+
       const uploadParams = {
         Bucket: process.env.S3_BUCKET_NAME,
         Key: `images/${result._id}.png`,
         Body: buffer,
         ContentType: "image/png",
       };
+
       const s3Response = await s3.upload(uploadParams).promise();
       newGame.screenshotUrl = s3Response.Location;
       await newGame.save();
     }
+
     res.status(200).json({
       message: "Game data saved successfully",
       data: newGame,

src/routes/api/takeSnap.js

@@ -0,0 +1,92 @@
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const axios = require("axios");
+
+const gameIds = ['128',
+  '129', '130', '131', '132', '133', '134', '135', '136', '137', '138', '139', '140', '141', '142',
+  '143', '144', '145', '146', '147', '148', '149', '150', '151', '152', '153', '154', '155', '156',
+  '157', '158', '159', '160', '161', '162', '163', '164', '165', '166', '167', '168', '169', '170',
+  '171', '172', '173', '174', '175', '176', '177'
+];
+
+const SCREENSHOT_FOLDER = path.join(__dirname, "game-screen/drawing");
+if (!fs.existsSync(SCREENSHOT_FOLDER)) {
+    fs.mkdirSync(SCREENSHOT_FOLDER, { recursive: true });
+}
+
+const DIRECTUS_API_URL = "https://game-du.teachertrainingkolkata.in/files";
+
+async function takeSnap(req, res) {
+    for (const id of gameIds) {
+        try {
+            const url = `https://interaktogames.beanstalkedu.com/drawing/v3?id=${id}`;
+            console.log(`📸 Taking screenshot for Game ID: ${id}`);
+            const command = `url2jpg ${url}`;
+            execSync(command, { stdio: "inherit", shell: true });
+            const files = fs.readdirSync(process.cwd()).filter(f => f.endsWith(".jpg"));
+            if (files.length === 0) throw new Error("No screenshot found!");
+            
+            const latestFile = files.reduce((a, b) => 
+                fs.statSync(b).mtimeMs > fs.statSync(a).mtimeMs ? b : a
+            );
+            const newPath = path.join(SCREENSHOT_FOLDER, `${id}.jpg`);
+            fs.renameSync(latestFile, newPath);
+            console.log(`✅ Screenshot saved: ${newPath}`);
+            const fileId = await uploadToDirectus(newPath);
+            if (fileId) {
+                console.log(`📤 Uploaded to Directus. File ID: ${fileId}`);
+                await updateThumbnail(id, fileId);
+            }
+        } catch (error) {
+            console.error(`❌ Error processing Game ID ${id}:`, error.message);
+        }
+    }
+
+    res.json({ message: "All screenshots processed successfully!" });
+}
+
+async function uploadToDirectus(filePath) {
+    try {
+        const fileData = fs.createReadStream(filePath);
+
+        const response = await axios.post(
+            DIRECTUS_API_URL,
+            { file: fileData },
+            {
+                headers: { "Content-Type": "multipart/form-data" },
+            }
+        );
+        return response.data.data.id;
+    } catch (error) {
+        console.error("❌ Failed to upload screenshot to Directus:", error.message);
+        return null;
+    }
+}
+
+
+async function updateThumbnail(gameId, fileId) {
+    const UPDATE_THUMBNAIL_URL = "https://game-du.teachertrainingkolkata.in/items/game_drawing_v3/";
+    try {
+        const response = await axios.patch(
+            `${UPDATE_THUMBNAIL_URL}${gameId}`,
+            { thumbnail: fileId }, // ✅ No need for "data" wrapper in REST API
+            { headers: { "Content-Type": "application/json" } }
+        );
+        console.log(`✅ Thumbnail updated for Game ID ${gameId}:`, response.data);
+    } catch (error) {
+        console.error(`❌ Failed to update thumbnail for Game ID ${gameId}`);
+        if (error.response) {
+            console.error("Response Data:", error.response.data);
+            console.error("Status Code:", error.response.status);
+        } else {
+            console.error("Error Message:", error.message);
+        }
+    }
+}
+
+
+
+
+
+module.exports = takeSnap;

src/routes/v1/api.route.js

@@ -22,7 +22,7 @@ const saveQuizResponse = require("../api/saveQuizResponse");
 const getGameScore = require("../api/getGameScore");
 const resultAfterQuizSubmit = require("../api/resultAfterQuizSubmit");
 const generateQuestions = require("../api/generateQuestions");
-const saveGameScore = require("../api/saveGameScore");
+// const saveGameScore = require("../api/saveGameScore");
 const saveGameScore2 = require("../api/saveGameScore2");
 const aiFeedbackOnReport = require("../api/aiFeedbackOnReport");
 const aiFeedbackActionParent = require("../api/aiFeedbackActionParent");
@@ -34,6 +34,9 @@ const aiEvaluateImageToStar = require("../api/aiEvaluateImageToStar");
 const getGameInfo = require("../api/getGameInfo");
 const saveGalleryImage = require("../api/saveGalleryImage");
 const getGalleryImage = require("../api/getGalleryImage");
+const getGameData = require("../api/getGameData");
+const takeSnap = require("../api/takeSnap");
+// const aiTest = require("../api/aiTest");
 
 
 const router = express.Router();
@@ -149,9 +152,9 @@ router.get("/ping", (req, res) => {
   });
   
   // For Quiz Result After Submit Quiz
-  router.post("/saveGameScore", (req, res) => {
-    saveGameScore(req, res);
-  });
+  // router.post("/saveGameScore", (req, res) => {
+  //   saveGameScore(req, res);
+  // });
   
   // For Quiz Result After Submit Quiz
   router.post("/saveGameScore2", (req, res) => {
@@ -208,6 +211,19 @@ router.get("/ping", (req, res) => {
     getGalleryImage(req, res);
   });
 
+  router.get("/getGameData", (req, res) => {
+    getGameData(req, res);
+  });
+
+  router.get("/takeSnap", (req, res) => {
+    takeSnap(req, res);
+  });
+  
+  // Get Drawing Game Gallery Image
+  // router.post("/aiTest", (req, res) => {
+  //   aiTest(req, res);
+  // });
+  
 
 module.exports = router;