Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/var/www/html/instagram/src/openAi/   drwxr-xr-x
Free 7.93 GB of 57.97 GB (13.68%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     openai.js (14.36 KB)      -rw-r--r--

const OpenAI =require("openai");
const path = require("path");
const orders = require(path.resolve(process.cwd(), "src/dcore", "orders.js"));
const account = require(path.resolve(process.cwd(), "src/dcore", "account_info.js"));
const {sendMessage} = require("../services/instagramSend.service");

const {searchItem} = require("./searchProduct");
const { OpenAiUsage } = require("../models/OpenAiUsage");
const { StoreSetting } = require("../models/StoreSettings");

const { randomUUID } = require("crypto");
const { send } = require("process");

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

async function logAiUsage(user_id, vendor_id, intent, message_type, tokens, senderId,shop_id=0) {
    await StoreSetting.updateOne(
        { vendor_id: String(vendor_id) },
        { $inc: { token: -tokens } }  // Use $inc with negative value to decrease
    ).exec();
    return await OpenAiUsage.create({
        _id: randomUUID(),
        sm_id: user_id,
        vendor_id: vendor_id || null,
        intent: intent ? intent.toString().trim() : "unknown",
        message_type: message_type || null,
        tokens: tokens || 0,
        model: "gpt-4.1-mini",
        sm_user_id: senderId,
        shop_id: shop_id
    });
}
async function productText(userMessage) {
    try {
        const messages = [
            {
                role: "system",
                content: `Extract essential product search terms from user messages.
                Rules:
                - Include ONLY: product names, brands, categories, key attributes
                - Remove: emotions, connectors, filler words, context
                - Output: Short keywords or phrases separated by spaces
                - Examples:
                - Input: "Do you have any red Nike shoes in size 10?"
                - Output: "red Nike shoes size 10"
                `.trim()
            },
            { role: "user", content: userMessage },
        ];
        const response = await client.chat.completions.create({
            model: "gpt-4.1-mini",
            messages,
        });    
        return [response.choices[0].message.content, response.usage?.total_tokens || 0];
    } catch (error) {
        throw new Error("Failed to generate reply");
    }
}
async function generalReply(userMessage) {
    try {
        const messages = [
            {
            role: "system",
            content:`
                You are Jiff's friendly shop assistant. Answer basic shop queries concisely.
                Shop Information:
                - Payment methods: Cash on delivery or online payment
                - Product catalog: Available on page timeline/posts
                Rules:
                - Be polite and helpful
                - Keep responses short (1-2 sentences)
                - Answer ONLY what was asked
                - Don't add unnecessary context
                - Use appropriate language based on user's message
                Example:
                - User: "What payment options do you have?"
                - Response: "We accept cash on delivery and online payment."
                Respond only to the user message below:`.trim()
            },
            { role: "user", content: userMessage },
        ];
        const response = await client.chat.completions.create({
            model: "gpt-4.1-mini",
            messages,
        });
        return [response.choices[0].message.content, response.usage?.total_tokens || 0];
    } catch (error) {
        throw new Error("Failed to generate reply");
    }
}
async function deliveryInfo(userMessage) {
    try {
        const messages = [
            {
                role: "system",
                content: `
                You are Jiff's delivery information specialist. Provide clear, accurate delivery details.
                Standard Information:
                - Delivery time: 3-5 working days
                - Delivery fee: Starts at 70tk (varies by location and package size)
                - Delivery coverage: Most areas within Bangladesh (some remote areas may have exceptions)
                Rules:
                - Answer ONLY what the user asked (location coverage, timing, fees)
                - Mention fees only if specifically requested
                - Keep responses 1-2 short sentences
                - Be friendly and polite
                - Use Bangla-English mix if user asks in Bangla
                Example:
                - User: "Delivery কত দিনে হবে?"
                - Response: "Delivery usually takes 3-5 working days."`.trim()
            },
            { role: "user", content: userMessage },
        ];
        const response = await client.chat.completions.create({
            model: "gpt-4.1-mini",
            messages,
        });
        return [response.choices[0].message.content, response.usage?.total_tokens || 0];
    } catch (error) {
        throw new Error("Failed to generate reply");
    }
}
async function complaintReply(userMessage) {
    try {
        const messages = [
            {
                role: "system",
                content: `
                You are Jiff's complaint resolution assistant. Respond with empathy and professionalism.
                Response Structure:
                1. Apologize sincerely
                2. Reassure the customer
                3. Escalate: "We'll escalate this to our support team and an agent will contact you soon."
                Rules:
                - Keep response 1-3 short, polite sentences
                - Use simple Bangla-English mix if user writes in Bangla
                - Never invent phone numbers, emails, or contact methods
                - Maintain empathetic tone
                Example:
                - User: "আমার product টা নষ্ট এসেছে!"
                - Response: "আমরা দুঃখিত যে আপনার product নষ্ট এসেছে। We'll escalate this to our support team and an agent will contact you soon."`.trim()
            },
            { role: "user", content: userMessage },
        ];
        const response = await client.chat.completions.create({
            model: "gpt-4.1-mini",
            messages,
        });
        return [response.choices[0].message.content.trim(), response.usage?.total_tokens || 0];
    } catch (error) {
        throw new Error("Failed to generate complaint reply");
    }
}
async function returnPolicyReply(userMessage) {
    try {
        const messages = [
            {
                role: "system",
                content: `
                You are Jiff's returns policy specialist. Provide clear return procedures.
                Return Policy:
                - Returns accepted only at delivery receipt (during delivery handoff)
                - For post-delivery issues: Contact agent or page admin with order ID/photos
                Rules:
                - Keep responses 1-2 short, polite sentences
                - If asked about return process: Instruct to refuse item at delivery OR contact agent with details
                - Use Bangla-English mix if user writes in Bangla
                - Never invent contact details
                Example:
                - User: "How can I return this?"
                - Response: "You can refuse the item at delivery time, or contact an agent with your order ID and photos for assistance."`.trim()
                    },
            { role: "user", content: userMessage },
        ];
        const response = await client.chat.completions.create({
            model: "gpt-4.1-mini",
            messages,
        });
        return [response.choices[0].message.content.trim(), response.usage?.total_tokens || 0];
    } catch (error) {
        throw new Error("Failed to generate return policy reply");
    }
}
async function classifyIntent(userMessage) {
    try {
        const messages = [
            {
            role: "system",
            content: `You are a chatbot intent classifier. Analyze the user's message and classify it into exactly one of these intents:
            Available Intents:
            'product' | 'talk_to_agent' | 'help_line' | 'delivery_info' | 'order_process' | 'previous_order' | 'track_order' | 'general' | 'complain' | 'return_policy'
            Classification Rules:
            - complain: User expresses dissatisfaction, frustration, or negative experience (even if mentioning a product)
            - talk_to_agent: User explicitly requests human support, admin, or agent contact
            - help_line: User needs assistance with a specific issue or problem
            - product: User inquires about or searches for products (without complaints)
            - Context matters: Prioritize sentiment and user need over keywords
            Output: Return ONLY the intent name. No explanation, punctuation, or additional text.
            `.trim()
            },
            { role: "user", content: userMessage },
        ];
        const response = await client.chat.completions.create({
            model: "gpt-4.1-mini",
            messages,
        });
        
        return [response.choices[0].message.content, response.usage?.total_tokens || 0];
    } catch (error) {
        throw new Error("Failed to generate reply");
    }
}
async function identifyIntent( user_id, senderId, userMessage ) {    
    try {        
        const  [intent, intent_tokens]= await classifyIntent(userMessage);
        var account_data=await account.get_accessToken(user_id);
        if (account_data) {
            var PAGE_ACCESS_TOKEN=account_data.token;
            var shop_id=account_data.shop_id;
        } else {    
            return "done";
        }
        await logAiUsage(user_id, account_data.vendor_id, intent, "classify_intent", intent_tokens, senderId,shop_id);
        // await usageLog({
        //   _id: randomUUID(),
        //   user_id: user_id,
        //   vendor_id: account_data.vendor_id || null,
        //   intent: intent ? intent.toString().trim() : "unknown",
        //   message_type: "classify_intent",
        //   tokens: intent_tokens || 0,
        //   model: "gpt-4.1-mini",
        //   senderId: senderId 
        // });
        var response = {};
        
        switch(intent.trim().toLowerCase()){
            case "product":
                var [modifiedMessage, modify_tokens] = await productText(userMessage);
                await logAiUsage(user_id, account_data.vendor_id, intent, "product_text_modify", modify_tokens, senderId,shop_id);
                response = await searchItem(shop_id, account_data.vendor_id, modifiedMessage);  
                var Message={
                    "text": "Thanks for your interest! Here are some products. You can send us the product code or send details about what you're looking for."
                }
                await sendMessage(PAGE_ACCESS_TOKEN,senderId, Message);    
                break;
            case "talk_to_agent":
                response={
                    "text":"Thank you for contacting us. Your message has been forwarded to our support team. One of our representatives will reach out to you shortly."
                }
                break;
            case "help_line":       
                response={
                    "text":"We’re sorry to hear you’re facing an issue. Please share more details, and our help desk will assist you as soon as possible."
                }
                break;
            case "order_process": 
                response={
                    "text":`✨ Step 1: You can start by commenting your product code on our post or live video (make sure the product is shared or shown in that post 👀) , or just send it here in Messenger.\r\n
                    ✨ Step 2: Click the “Add to Cart” button to add your item.
                    (If it’s available, I’ll confirm it right away ✅)\r\n
                    ✨ Step 3: Don’t have an account yet? No worries!
                    Just create your profile using your phone number before adding items to your cart.
                    ✨ Step 4: When you’re ready, click “Checkout” from Messenger or type “Checkout#” — I’ll send you the button instantly.
                    ✨ Step 5: Fill in your delivery info and hit “Place Order” — and you’re done! 🎉`
                }
                break;
            case "previous_order":
                orders.orders_info("order_done", user_id, PAGE_ACCESS_TOKEN, senderId, shop_id);
                break;
            case "track_order":
                orders.orders_info("order_track", user_id, PAGE_ACCESS_TOKEN, senderId, shop_id);
                break;
            case "return_policy": 
                var [return_policy_reply, return_policy_tokens] = await returnPolicyReply(userMessage);
                await logAiUsage(user_id, account_data.vendor_id, intent, "return_policy", return_policy_tokens, senderId,shop_id);
                response = { text: return_policy_reply };
                break;
            case "complain":
                var [complaint_reply, complaint_tokens] = await complaintReply(userMessage);
                await logAiUsage(user_id, account_data.vendor_id, intent, "complaint", complaint_tokens, senderId,shop_id);
                response = { text: complaint_reply };
                break;
            case "delivery_info":
                var [delivery_reply, delivery_tokens] = await deliveryInfo(userMessage);
                await logAiUsage(user_id, account_data.vendor_id, intent, "delivery_info", delivery_tokens, senderId,shop_id);
                response = { text: delivery_reply };
                break;
            default:
                var [reply, reply_tokens] = await generalReply(userMessage);
                await logAiUsage(user_id, account_data.vendor_id, intent, "general_reply", reply_tokens, senderId,shop_id);
                response = { text: reply };
                break;
        }
        if (Object.keys(response).length>0) {
            await sendMessage(PAGE_ACCESS_TOKEN,senderId, response); 
        }
        // console.log(intent);
        return true;
    } catch (error) {
        console.error("Error generating reply:", error);
        throw new Error("Failed to generate reply");
    }
}
module.exports = { identifyIntent };