பயனர் அடையாளம் காணல்

பயனர்களை அடையாளம் காண்பது, அநாமதேய அரட்டை அமர்வுகளை உண்மையான பயனர் சுயவிவரங்களுடன் இணைக்கிறது.

இது எப்படி வேலை செய்கிறது

நீங்கள் Respondo.identify()-ஐ அழைக்கும்போது, கொடுக்கப்பட்ட புலங்கள் உரையாடலுடன் இணைக்கப்படுகின்றன. எல்லாப் புலங்களும் விருப்பத்தேர்வானவை — உங்களிடம் உள்ளவற்றை மட்டும் அனுப்பினால் போதும். எடுத்துக்காட்டாக, email அல்லது பெயர் இல்லாமல் userId-ஐ மட்டும் அனுப்பலாம். ஆதரவு அலுவலர்கள் இந்தத் தரவை உரையாடல் விவரப் பலகத்தில் காண்பார்கள்.

அளவுருக்கள்#

பண்பு	வகை	கட்டாயமா	விளக்கம்
email	string	விருப்பத்தேர்வு	பயனரின் மின்னஞ்சல் முகவரி
name	string	விருப்பத்தேர்வு	காட்டப்படும் பெயர்
userId	string	விருப்பத்தேர்வு	உங்கள் உள்ளக பயனர் ID அல்லது காட்சி ID — டாஷ்போர்டில் அப்படியே காட்டப்படும்
userHash	string	விருப்பத்தேர்வு	அடையாளச் சரிபார்ப்புக்கான HMAC-SHA256 கையொப்பம்
metadata	object	விருப்பத்தேர்வு	தனிப்பயன் புலங்களின் விசை-மதிப்பு இணைகள் (plan, company போன்றவை)
properties	object	விருப்பத்தேர்வு	Agent Settings-இல் வரையறுக்கப்பட்ட தனிப்பயன் தொடர்புப் பண்புகள். விசைகள் பண்பு வரையறைகளுடன் பொருந்த வேண்டும். மதிப்புகள் `cp_` முன்னொட்டுடன் சேமிக்கப்படுகின்றன; இன்பாக்ஸில் அவற்றைக் கொண்டு வடிகட்டலாம்.

எடுத்துக்காட்டு: ஒற்றைப் பக்க ஆப் (SPA)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()-ஐ அழைத்தால் மட்டுமே அடையாளத் தரவு (console எச்சரிக்கையுடன்) நிராகரிக்கப்படும் — கைமுறை அமைப்புகளில் எப்போதும் முதலில் 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 இல்லாவிட்டால், யார் வேண்டுமானாலும் உலாவி console-இலிருந்து எந்த 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 tag)
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-ஐ அனுப்பி யார் வேண்டுமானாலும் ஒரு பயனராக நடிக்க முடியும். பயனரின் அடையாளத்தை client-side குறியீடு அல்ல, உங்கள் சேவையகமே அமைத்தது என்பதைக் குறியாக்க முறையில் நிரூபிக்க, அடையாளச் சரிபார்ப்பு HMAC-SHA256-ஐப் பயன்படுத்துகிறது.

இது எப்படி வேலை செய்கிறது#

உங்கள் சேனல் அமைப்புகளில் அடையாளச் சரிபார்ப்பை இயக்கவும் — உங்களுக்கு ஒரு ரகசிய விசை கிடைக்கும்.
உங்கள் சேவையகத்தில் HMAC-SHA256(secret, userId) கணக்கிடுங்கள் — secret-தான் சாவி, userId-தான் செய்தி — முடிவை frontend-க்கு அனுப்பவும். பயனர்களை email மூலம் மட்டுமே (userId இல்லாமல்) அடையாளம் காண்பவரானால், அதற்குப் பதிலாக email-இல் கையொப்பமிடுங்கள்: userId அமைக்கப்பட்டிருந்தால் அதுவே கையொப்பமிடப்படும் payload, இல்லையேல் email. இரண்டையும் அனுப்பினால் userId-இல் கையொப்பமிடுங்கள்; அதற்கே முன்னுரிமை.
அந்த ஹாஷை Respondo.identify()-இல் userHash ஆக அனுப்பவும்.
Respondo அந்த ஹாஷைச் சேவையகப் பக்கத்தில் சரிபார்க்கிறது. தவறாக இருந்தால் அடையாளம் நீக்கப்பட்டு, பயனர் அநாமதேயமாகக் கருதப்படுவார்.

உங்கள் ரகசிய விசையை frontend குறியீட்டில் ஒருபோதும் வெளிப்படுத்த வேண்டாம். HMAC-ஐ உங்கள் backend-இல் மட்டுமே கணக்கிட வேண்டும்.

சரிபார்ப்பு இயக்கப்பட்டதும், 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 endpoint-இல்:
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))
}

Frontend பயன்பாடு#

அடையாளச் சரிபார்ப்புடன்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 கையொப்பம்
});