वापरकर्त्याची ओळख

वापरकर्त्यांची ओळख करून दिल्याने अनामिक चॅट सेशन खऱ्या वापरकर्ता प्रोफाइलशी जोडली जातात.

हे कसे चालते

तुम्ही Respondo.identify() कॉल करता तेव्हा दिलेली फील्ड संभाषणाला जोडली जातात. सर्व फील्ड ऐच्छिक आहेत — तुमच्याकडे असतील तेवढीच पाठवा. उदाहरणार्थ, email किंवा नावाशिवाय फक्त userId पाठवता येतो. सपोर्ट प्रतिनिधींना ही माहिती संभाषणाच्या तपशील पॅनलमध्ये दिसते.

पॅरामीटर्स#

गुणधर्म	प्रकार	आवश्यक	वर्णन
email	string	ऐच्छिक	वापरकर्त्याचा email पत्ता
name	string	ऐच्छिक	दाखवायचे नाव
userId	string	ऐच्छिक	तुमचा अंतर्गत वापरकर्ता किंवा डिस्प्ले ID — डॅशबोर्डमध्ये जसाच्या तसा दिसतो
userHash	string	ऐच्छिक	ओळख पडताळणीसाठी HMAC-SHA256 स्वाक्षरी
metadata	object	ऐच्छिक	कस्टम फील्डच्या की-व्हॅल्यू जोड्या (plan, company वगैरे)
properties	object	ऐच्छिक	Agent Settings मध्ये ठरवलेले कस्टम संपर्क गुणधर्म. की गुणधर्मांच्या व्याख्यांशी जुळल्या पाहिजेत. मूल्ये `cp_` प्रीफिक्ससह साठवली जातात आणि इनबॉक्समध्ये फिल्टर करता येतात.

उदाहरण: सिंगल पेज ॲपjavascript

// यशस्वी लॉगिननंतर
async function onLogin(user) {
  await authenticateUser(user);

  Respondo.identify({
    email: user.email,
    name: user.fullName,
    userId: user.id,
    metadata: {
      plan: user.subscription.plan,
      company: user.company.name,
      role: user.role,
      signedUp: user.createdAt
    },
    properties: {                        // कस्टम संपर्क गुणधर्म
      account_type: user.accountType,    // Agent Settings मधल्या की शी जुळले पाहिजेत
      industry: user.industry,
      contract_tier: user.tier
    }
  });
}

नेहमीच्या इंस्टॉल स्निपेटसोबत identify() कधीही कॉल करता येते — widget.js लोड होण्याआधी केलेले कॉल स्निपेट रांगेत ठेवते आणि विजेट इनिशियलाइझ होताच आपोआप पुन्हा चालवते. ओळखीची माहिती फक्त तेव्हाच (कन्सोल वॉर्निंगसह) टाकून दिली जाते, जेव्हा तुम्ही widget.js स्वतः लोड करता आणि एकदाही init() कॉल न करता identify() कॉल करता — हाताने केलेल्या सेटअपमध्ये नेहमी आधी init() कॉल करा.

अनामिक अभ्यागत#

तुम्ही identify() कॉल केला नाही, तर विजेट आपोआप एक कायमस्वरूपी visitor ID देते आणि तो localStorage मध्ये (respondoai_visitor_id या की खाली) साठवला जातो. डॅशबोर्डमध्ये ते संभाषण Guest · Web widget असे दिसते.

पद्धत	डॅशबोर्डमध्ये दिसणारे	HMAC आवश्यक
`identify()` नाही	Guest · Web widget	नाही
`identify({ email, name })`	नाव + email दिसतात	नाही — पण ओळख पडताळणी चालू असेल तर स्वाक्षरी नसलेले email/नाव गुपचूप काढून टाकले जातात आणि सेशन अनामिकच राहते
`identify({ userId })`	userId जसाच्या तसा दिसतो	नाही — पण ओळख पडताळणी चालू असेल तर वैध `userHash` लागतो, नाहीतर ओळख काढून टाकली जाते
`identify({ userId, userHash })`	पडताळलेली वापरकर्ता ओळख	होय — क्रिप्टोग्राफिक पद्धतीने पडताळलेली

चॅनेलवर ओळख पडताळणी चालू असताना, वैध userHash शिवाय email किंवा userId घेऊन आलेला प्रत्येक identify() सर्व्हरच्या बाजूने साफ केला जातो आणि अभ्यागत अनामिकच राहतो — खाली ओळख पडताळणी (HMAC) पाहा.

एकाच ब्राउझरमध्ये सेशन बदलली तरी visitor ID टिकतो. तो कधीच प्रमाणित ओळख म्हणून Respondo कडे पाठवला जात नाही — त्याचा उपयोग फक्त अनामिक संभाषण पुढे चालू ठेवण्यासाठी होतो.

फक्त userId ने ओळख (email किंवा नावाशिवाय)#

तुमच्या प्लॅटफॉर्मवर वापरकर्त्यांचे email किंवा नाव नसेल — उदाहरणार्थ, तुमच्याकडे फक्त अंतर्गत डिस्प्ले ID असेल — तर फक्त userId पाठवला तरी चालतो. इतर कोणतीही फील्ड लागत नाहीत. डॅशबोर्ड संभाषणाच्या तपशिलात तो userId जसाच्या तसा दाखवेल.

userId + metadata (email किंवा नावाशिवाय)javascript

// तुमच्या प्लॅटफॉर्मवर फक्त डिस्प्ले ID आहे — तेवढे पुरे
Respondo.identify({
  userId: user.displayId,      // उदा. "USR-4821" — डॅशबोर्डमध्ये दिसतो
  metadata: {                  // ऐच्छिक अतिरिक्त संदर्भ
    plan: 'premium',
    region: 'eu-west'
  }
});
// email किंवा नाव लागत नाही — फक्त userId नेही विजेट चालते

userId ची बनावट नक्कल टाळण्यासाठी त्यासोबत userHash वापरा (खाली ओळख पडताळणी पाहा). HMAC नसेल तर कोणीही ब्राउझर कन्सोलमधून कोणताही userId पाठवू शकतो.

Google Tag Manager / विलंबित identify()#

GTM द्वारे एम्बेड करताना पान लोड होताना वापरकर्त्याची माहिती उपलब्ध नसू शकते. दोन पर्याय:

पर्याय A: localStorageKey (JS ची गरज नाही)javascript

// तुमचा प्लॅटफॉर्म आधीच वापरकर्ता ID localStorage मध्ये लिहीत असेल तर:
Respondo.init({
  agentId: 'YOUR_AGENT_ID',
  localStorageKey: 'myapp_user_id'  // localStorage.getItem('myapp_user_id') आपोआप वाचते
});
// identify() कॉल लागत नाही — विजेट स्वतःच userId घेते

पर्याय B: dataLayer द्वारे विलंबित identify()javascript

// 1. विजेट लगेच init करा (GTM टॅग)
Respondo.init({ agentId: 'YOUR_AGENT_ID' });

// 2. नंतर, वापरकर्त्याची माहिती आल्यावर (उदा. dataLayer मधून किंवा तुमच्या ॲपमधून):
var waitForUser = setInterval(function() {
  var uid = localStorage.getItem('myapp_user_id');
  if (uid && window.Respondo && typeof window.Respondo.identify === 'function') {
    clearInterval(waitForUser);
    Respondo.identify({ userId: uid });
  }
}, 500);

identify() ने आधीच userId दिलेला नसेल तरच localStorageKey वापरला जातो. स्पष्टपणे केलेल्या identify() कॉलला नेहमी प्राधान्य असते.

ओळख पडताळणी (HMAC)#

पडताळणी नसेल तर कोणीही बनावट userId किंवा email पाठवून दुसऱ्या वापरकर्त्याचे सोंग घेऊ शकतो. ओळख पडताळणी HMAC-SHA256 वापरते आणि क्रिप्टोग्राफिक पद्धतीने सिद्ध करते की वापरकर्त्याची ओळख तुमच्या सर्व्हरने ठरवली आहे, क्लायंट-साइड कोडने नाही.

हे कसे चालते#

तुमच्या चॅनेल सेटिंग्जमध्ये ओळख पडताळणी सुरू करा — तुम्हाला सीक्रेट की मिळेल.
तुमच्या सर्व्हरवर HMAC-SHA256(secret, userId) काढा — secret ही की आहे, userId हा मेसेज — आणि निकाल फ्रंटएंडकडे पाठवा. तुम्ही वापरकर्त्यांना फक्त email ने ओळखत असाल (userId नसेल), तर त्याऐवजी email वर स्वाक्षरी करा: userId दिलेला असल्यास स्वाक्षरी त्यावर होते, नाहीतर email वर. दोन्ही दिल्यास userId वर स्वाक्षरी होते; त्याला प्राधान्य असते.
तो हॅश Respondo.identify() मध्ये userHash म्हणून द्या.
Respondo तो हॅश सर्व्हरच्या बाजूने तपासते. तो चुकीचा असेल तर ओळख काढून टाकली जाते आणि वापरकर्ता अनामिक मानला जातो.

तुमची सीक्रेट की फ्रंटएंड कोडमध्ये कधीही उघड करू नका. HMAC तुमच्या बॅकएंडवरच काढला पाहिजे.

पडताळणी एकदा चालू केल्यावर, userId किंवा email असलेल्या प्रत्येक identify() मध्ये वैध userHash असावाच लागतो — नाहीतर ओळखीची फील्ड काढून टाकली जातात आणि अभ्यागत अनामिक मानला जातो.

सर्व्हर बाजूची उदाहरणे#

Node.jsjavascript

const crypto = require('crypto');

const SECRET = process.env.RESPONDO_IDENTITY_SECRET;

function generateUserHash(userId) {
  return crypto
    .createHmac('sha256', SECRET)
    .update(userId)
    .digest('hex');
}

// तुमच्या API एंडपॉइंटमध्ये:
app.get('/api/respondo-hash', (req, res) => {
  const hash = generateUserHash(req.user.id);
  res.json({ userHash: hash });
});

Pythonpython

import hmac, hashlib, os

SECRET = os.environ['RESPONDO_IDENTITY_SECRET']

def generate_user_hash(user_id: str) -> str:
    return hmac.new(
        SECRET.encode(),
        user_id.encode(),
        hashlib.sha256
    ).hexdigest()

# तुमच्या view / एंडपॉइंटमध्ये:
user_hash = generate_user_hash(request.user.id)

Gogo

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
)

func GenerateUserHash(userID, secret string) string {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(userID))
    return hex.EncodeToString(mac.Sum(nil))
}

फ्रंटएंडमध्ये वापर#

ओळख पडताळणीसहjavascript

// हॅश तुमच्या सर्व्हरकडून घ्या
const { userHash } = await fetch('/api/respondo-hash').then(r => r.json());

Respondo.identify({
  email: user.email,
  name: user.name,
  userId: user.id,
  userHash: userHash  // HMAC-SHA256 स्वाक्षरी
});