వినియోగదారు గుర్తింపు

వినియోగదారులను గుర్తించడం వల్ల అనామక చాట్ సెషన్‌లు నిజమైన యూజర్ ప్రొఫైల్‌లతో అనుసంధానమవుతాయి.

ఇది ఎలా పనిచేస్తుంది

మీరు Respondo.identify() కాల్ చేసినప్పుడు, ఇచ్చిన ఫీల్డ్‌లు సంభాషణకు జతచేయబడతాయి. అన్ని ఫీల్డ్‌లూ ఐచ్ఛికం — మీ దగ్గర ఉన్నవి మాత్రమే పంపండి. ఉదాహరణకు, ఈమెయిల్ లేదా పేరు లేకుండా కేవలం userId పంపవచ్చు. ఈ డేటా సపోర్ట్ ఏజెంట్లకు సంభాషణ వివరాల ప్యానెల్‌లో కనిపిస్తుంది.

పారామీటర్‌లు#

ప్రాపర్టీ	టైప్	అవసరమా	వివరణ
email	string	ఐచ్ఛికం	వినియోగదారు ఈమెయిల్ చిరునామా
name	string	ఐచ్ఛికం	ప్రదర్శన పేరు
userId	string	ఐచ్ఛికం	మీ అంతర్గత యూజర్ లేదా డిస్‌ప్లే ID — డ్యాష్‌బోర్డ్‌లో ఉన్నదున్నట్టే కనిపిస్తుంది
userHash	string	ఐచ్ఛికం	గుర్తింపు ధ్రువీకరణ కోసం HMAC-SHA256 సంతకం
metadata	object	ఐచ్ఛికం	కస్టమ్ ఫీల్డ్‌ల key-value జతలు (plan, company మొదలైనవి)
properties	object	ఐచ్ఛికం	Agent Settings లో నిర్వచించిన కస్టమ్ కాంటాక్ట్ ప్రాపర్టీలు. కీలు ప్రాపర్టీ నిర్వచనాలతో సరిపోలాలి. విలువలు `cp_` ప్రిఫిక్స్‌తో నిల్వ అవుతాయి, ఇన్‌బాక్స్‌లో వాటిపై ఫిల్టర్ చేయవచ్చు.

ఉదాహరణ: Single Page Appjavascript

// విజయవంతమైన లాగిన్ తర్వాత
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/name నిశ్శబ్దంగా తీసివేయబడతాయి, సెషన్ అనామకంగానే ఉంటుంది
`identify({ userId })`	userId ఉన్నదున్నట్టే కనిపిస్తుంది	లేదు — గుర్తింపు ధ్రువీకరణ ఆన్ చేసి ఉంటే తప్ప; అప్పుడు చెల్లుబాటయ్యే `userHash` తప్పనిసరి, లేకపోతే గుర్తింపు తీసివేయబడుతుంది
`identify({ userId, userHash })`	ధ్రువీకరించిన వినియోగదారు గుర్తింపు	అవును — క్రిప్టోగ్రాఫిక్‌గా ధ్రువీకరణ

ఛానెల్‌కు గుర్తింపు ధ్రువీకరణ ఆన్ చేసి ఉంటే, చెల్లుబాటయ్యే userHash లేకుండా email లేదా userId తో వచ్చే ప్రతి identify() సర్వర్ వైపు తీసివేయబడుతుంది, సందర్శకుడు అనామకంగానే ఉంటాడు — కింద గుర్తింపు ధ్రువీకరణ (HMAC) చూడండి.

ఒకే బ్రౌజర్‌లో సెషన్‌ల మధ్య visitor ID నిలిచి ఉంటుంది. ధ్రువీకరించిన గుర్తింపుగా అది Respondo కు ఎప్పుడూ వెళ్లదు — అనామక సంభాషణ కొనసాగింపు కోసమే దీన్ని వాడతారు.

userId మాత్రమే ఉపయోగించే గుర్తింపు (ఈమెయిల్, పేరు లేకుండా)#

మీ ప్లాట్‌ఫామ్‌లో వినియోగదారుల ఈమెయిల్‌లు లేదా పేర్లు లేకపోతే — ఉదాహరణకు, మీ దగ్గర అంతర్గత డిస్‌ప్లే ID మాత్రమే ఉంటే — కేవలం userId పంపితే సరిపోతుంది. ఇతర ఫీల్డ్‌లు అవసరం లేదు. డ్యాష్‌బోర్డ్ ఆ userId ను సంభాషణ వివరాల్లో ఉన్నదున్నట్టే చూపిస్తుంది.

userId + metadata (ఈమెయిల్, పేరు లేకుండా)javascript

// మీ ప్లాట్‌ఫామ్‌లో డిస్‌ప్లే ID మాత్రమే ఉంది — అది చాలు
Respondo.identify({
  userId: user.displayId,      // ఉదా. "USR-4821" — డ్యాష్‌బోర్డ్‌లో కనిపిస్తుంది
  metadata: {                  // ఐచ్ఛిక అదనపు సందర్భం
    plan: 'premium',
    region: 'eu-west'
  }
});
// ఈమెయిల్ గానీ పేరు గానీ అవసరం లేదు — 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 మెసేజ్ — ఫలితాన్ని ఫ్రంటెండ్‌కు పంపండి. వినియోగదారులను ఈమెయిల్‌తో మాత్రమే గుర్తిస్తుంటే (userId లేకుండా), ఈమెయిల్‌పైనే సంతకం చేయండి: సంతకం చేసే విలువ userId సెట్ అయి ఉంటే userId, లేకపోతే email. రెండూ పంపితే userId పైనే సంతకం అవుతుంది; దానిదే ప్రాధాన్యత.
ఆ హ్యాష్‌ను userHash గా Respondo.identify() లో పంపండి.
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 / endpoint లో:
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 సంతకం
});