డాక్యుమెంటేషన్

గుర్తింపు ధ్రువీకరణ

మీ బ్యాకెండ్ నియంత్రించే సంతకంతో సైన్ ఇన్ అయిన వ్యక్తిని గుర్తించండి, పరికరాలన్నింటిలోనూ వారి సంభాషణ చరిత్రను తిరిగి తెప్పించండి.

ధ్రువీకరణ ఎందుకు

డిఫాల్ట్‌గా SDK అనామకంగా పనిచేస్తుంది: అది స్థిరమైన visitor_idని తయారుచేసి ప్లాట్‌ఫామ్ కీస్టోర్‌లో ఉంచుతుంది. ఒక పరికరంలో ఒక సంభాషణకు అది సరిపోతుంది. అయితే నిర్దిష్ట వినియోగదారుని గుర్తించాలంటే, మళ్లీ లాగిన్ అయినప్పుడో వేరే పరికరంలోనో చరిత్రను తిరిగి తేవాలంటే, సంభాషణను కాంటాక్ట్ ప్రొఫైల్‌తో నమ్మకంగా ముడిపెట్టాలంటే — క్లయింట్ తాను చెప్పుకుంటున్న వ్యక్తే అనడానికి బ్యాకెండ్‌కు రుజువు కావాలి. SDK కేవలం "నేను user 42" అని పంపితే, ఎవరైనా వేరే idని నటించి ఇతరుల చాట్‌ను చదవగలరు — అందుకే మీ బ్యాకెండ్ మాత్రమే తయారుచేయగల క్రిప్టోగ్రాఫిక్ సంతకాన్ని, అంటే userHashను, Respondo తప్పనిసరి చేస్తుంది.

identity secret ఎలా పొందాలి

identity_secret అనేది మీ ఏజెంట్‌కు (మీ యాప్ ఛానెల్ అనుసంధానమై ఉన్న AI కార్మికుడికి) ముడిపడిన రహస్య స్ట్రింగ్. దాన్ని డ్యాష్‌బోర్డ్‌లో Settings › Channels › Mobile SDK › Identity verification కింద తయారుచేసుకోండి. సీక్రెట్ ఏజెంట్‌పైనే ఉంటుంది కాబట్టి, ఆ ఏజెంట్ నడిపే ప్రతి ఛానెల్ — వెబ్ విడ్జెట్ అయినా, మొబైల్ SDK అయినా — అదే సీక్రెట్‌ను పంచుకుంటుంది. గుర్తింపులపై సంతకం చేసే హక్కును అది ఇస్తుంది కాబట్టి, అది మీ బ్యాకెండ్‌లో మాత్రమే ఉండాలి, యాప్‌తో పాటు ఎప్పుడూ పంపకూడదు.

userHash సూత్రం

userHash అంటే సంతకం చేసిన ఒకే ఒక గుర్తింపు స్ట్రింగ్‌పై HMAC-SHA256, చిన్న అక్షరాల hex రూపంలో:

సూత్రంtext
userHash = HMAC_SHA256( identity_secret, payload )

payload = userId          // userId ఇచ్చినట్లయితే
        = email           // లేదంటే, email ఇచ్చినట్లయితే
        = (invalid)       // రెండూ ఖాళీ అయితే సంతకం చేయడానికి ఏమీ లేదు
  • సీక్రెట్ అనేది HMAC కీ; గుర్తింపు స్ట్రింగ్ అనేది మెసేజ్ — తారుమారు కాదు.
  • సరిగ్గా ఒకే ఒక స్ట్రింగ్‌పై సంతకం చేయండి — ముడి userId (లేదా ఈమెయిల్), ఎలాంటి సాల్ట్ కానీ JSON ర్యాపర్ కానీ లేకుండా.
  • userIdనూ ఈమెయిల్‌నూ రెండింటినీ పంపితే, userIdపై సంతకం చేయండి (దానికే ప్రాధాన్యం).
  • కనెక్ట్ చేసిన యాప్‌లు (Stripe, Shopify మరియు ఇతరాలు) సంతకం చేసిన userId తో పాటు మీరు పంపే ఈమెయిల్ ద్వారా వ్యక్తిని వెతుకుతాయి.
  • ఫలితం hex రూపంలో ఉంటుంది (SHA-256కు 64 అక్షరాలు), base64 కాదు.

బ్యాకెండ్ ఉదాహరణలు

సంతకాన్ని మీ బ్యాకెండ్‌లో లెక్కించి, సిద్ధమైన userHashను యాప్‌కు అందించండి.

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

// HMAC_SHA256(identity_secret, userId) — చిన్న అక్షరాల hex రూపంలో.
func ComputeUserHash(identitySecret, userID string) string {
    mac := hmac.New(sha256.New, []byte(identitySecret))
    mac.Write([]byte(userID))
    return hex.EncodeToString(mac.Sum(nil))
}
Node.jsjavascript
const crypto = require("crypto");

// మొబైల్ క్లయింట్‌లో Respondo.identifyకు పంపాల్సిన userHashను తిరిగి ఇస్తుంది.
function computeUserHash(identitySecret, userId) {
  return crypto
    .createHmac("sha256", identitySecret)
    .update(userId, "utf8")
    .digest("hex");
}
Python
import hmac
import hashlib

# మొబైల్ క్లయింట్‌లో Respondo.identifyకు పంపాల్సిన userHashను తిరిగి ఇస్తుంది.
def compute_user_hash(identity_secret: str, user_id: str) -> str:
    return hmac.new(
        identity_secret.encode(),
        user_id.encode(),
        hashlib.sha256,
    ).hexdigest()
PHP
<?php
// మొబైల్ క్లయింట్‌లో Respondo.identifyకు పంపాల్సిన userHashను తిరిగి ఇస్తుంది.
function computeUserHash(string $identitySecret, string $userId): string {
    return hash_hmac('sha256', $userId, $identitySecret);
}

హాష్ Respondoకు ఎలా చేరుతుంది

Respondo ఎలాంటి identity ఎండ్‌పాయింట్‌నూ ఇవ్వదు. కాల్ చేయడానికి /identity రూట్ లేదు, రిజిస్టర్ చేయాల్సిందీ ఏమీ లేదు. userHash అనేది SDK ఇప్పటికే చేసే అభ్యర్థనలతో పాటే ప్రయాణించే ఒక ఫీల్డ్.

రెండు దశలు — వాటిలో మొదటిది మాత్రమే మీరు కట్టాల్సింది:

  1. మీ బ్యాకెండ్ → మీ యాప్. హాష్‌ను మీకు నచ్చిన విధంగా చేరవేయండి. అన్నింటికన్నా చౌకైన మార్గం — మీరు ఇప్పటికే తిరిగి ఇచ్చే login/bootstrap స్పందనలో ఒక అదనపు ఫీల్డ్ జోడించడం; అదనపు రౌండ్ ట్రిప్ అక్కర్లేదు. మీ సొంత బ్యాకెండ్‌లో ప్రత్యేక ఎండ్‌పాయింట్ (ఉదాహరణకు POST /myapp/identity — { userId, userHash } తిరిగి ఇస్తుంది) కూడా అంతే బాగా పనిచేస్తుంది. ఆ ఎండ్‌పాయింట్‌ను Respondo హోస్ట్ చేయదు — దాన్ని మీరే అమలు చేయాలి.
  2. మీ యాప్ → Respondo. ఇది మీ కోసం చేసిపెట్టబడింది. మీరు identifyని ఒకసారి కాల్ చేస్తే చాలు — SDK సంబంధిత ప్రతి అభ్యర్థనకూ హాష్‌ను జతచేస్తుంది, బ్యాకెండ్ ప్రతిసారీ దాన్ని మళ్లీ ధ్రువీకరిస్తుంది.
SDK దాన్ని ఎక్కడ పెడుతుంది (సమాచారం కోసం — వీటిని మీరు చేతితో పంపనక్కర్లేదు)text
POST /api/v1/chat                      body   identity.userHash
GET  /api/v1/chat/resume               query  user_hash
GET  /api/v1/chat/history              query  user_hash
GET  /api/v1/chat/ws                   frames    user_hash (subscribe/identify JSON frames after connect — not in the handshake URL)
GET  /api/v1/widget/tours              query  user_hash
GET  /api/v1/widget/checklists         query  user_hash
POST /api/v1/widget/push/register      body   user_hash

హాష్‌ను ప్రతి అభ్యర్థనకూ మళ్లీ తనిఖీ చేస్తారు; ఒకసారి ఇచ్చి సెషన్‌గా మార్చుకోవడం కాదు — అందుకే దొంగిలించిన userId ఒక్కటే ఎందుకూ పనికిరాదు.

మీ బ్యాకెండ్‌లో డెలివరీ ఎండ్‌పాయింట్ ఇంకా సిద్ధం కాకపోతే, మీ యాప్ చేసే అభ్యర్థనే 404 ఇస్తుంది, identify ఎప్పుడూ కాల్ కాదు, చాట్ అనామకంగా నడుస్తుంది. ఇది ఊహించిన ప్రవర్తనే, Respondo లోపం కాదు — మీ సొంత పాత్‌పై వచ్చిన 404 అంటే మీ వైపు మిగిలిన పని, పాడైన ఇంటిగ్రేషన్ కాదు.

SDKకు గుర్తింపును అందించడం

సంతకం చేసిన గుర్తింపును మీ బ్యాకెండ్ నుంచి తెచ్చుకుని, ఏ ప్లాట్‌ఫామ్‌లోనైనా userHashను identifyకు పంపండి:

Kotlin
Respondo.identify(
    RespondoIdentity(userId = "42", email = "user@example.com", userHash = hash),
)
Swift
Respondo.identify(
    RespondoIdentity(userId: "42", email: "user@example.com", userHash: hash)
)
Dart
Respondo.identify(RespondoIdentity(
  userId: '42', email: 'user@example.com', userHash: hash,
));

చెల్లని userHash ఉన్నప్పుడు ప్రవర్తన

ఏజెంట్‌పై ధ్రువీకరణ ఆన్‌లో ఉండి సంతకం లేకపోయినా, తప్పుగా ఉన్నా — బ్యాకెండ్ నిశ్శబ్దంగా అనామక స్థాయికి దించేస్తుంది: చాట్ పనిచేస్తూనే ఉంటుంది, visitor_id అలాగే ఉంటుంది, సంభాషణ అనామక కాంటాక్ట్‌తో ముడిపడుతుంది — కానీ ప్రొఫైల్‌తో లింక్ ఉండదు, పరికరాల మధ్య చరిత్రా ఉండదు. వినియోగదారుని "గుర్తించడం లేదు" అంటే దాదాపు ఎప్పుడూ కారణం సంతకమే: మీరు userIdపైనే సంతకం చేశారా (ఈమెయిల్ లేదా JSONపై కాదు), సరైన identity_secret వాడారా, ఫలితం చిన్న అక్షరాల hexలో వచ్చిందా — ఇవి సరిచూసుకోండి. ఏజెంట్‌కు identity_secret ఖాళీగా ఉంటే ధ్రువీకరణ ఆఫ్‌లో ఉంటుంది, userId / ఈమెయిల్ ఉన్నదున్నట్టుగానే ఆమోదించబడతాయి.

identity_secretను మార్చడం ఆచరణలో పూర్తి కటోవర్ లాంటిది: పాత సీక్రెట్‌తో తయారైన ప్రతి హాషూ వెంటనే ధ్రువీకరణ కావడం ఆగిపోతుంది; అందువల్ల ఇప్పటికే సైన్ ఇన్ అయిన వినియోగదారులు — మీ బ్యాకెండ్ కొత్త సీక్రెట్‌తో వారి userHashను మళ్లీ లెక్కించి అందించే వరకు — నిశ్శబ్దంగా అనామక స్థాయికి దిగిపోతారు. సంతకం చేసే వైపును అదే సమయంలో అప్‌డేట్ చేయగలిగినప్పుడు మాత్రమే సీక్రెట్‌ను మార్చండి.