Force Device Quit

curl -X POST "http://localhost:5001/user/device_quit" \
  -H "Content-Type: application/json" \
  -d '{
    "uid": "user123",
    "device_flag": 1
  }'

const response = await fetch('http://localhost:5001/user/device_quit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    uid: 'user123',
    device_flag: 1
  })
});

const data = await response.json();
console.log(data);

import requests

data = {
    "uid": "user123",
    "device_flag": 1
}

response = requests.post('http://localhost:5001/user/device_quit', json=data)
result = response.json()
print(result)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    data := map[string]interface{}{
        "uid":         "user123",
        "device_flag": 1,
    }
    
    jsonData, _ := json.Marshal(data)
    
    resp, err := http.Post(
        "http://localhost:5001/user/device_quit",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
}

{
  "status": "ok"
}

POST

user

device_quit

curl -X POST "http://localhost:5001/user/device_quit" \
  -H "Content-Type: application/json" \
  -d '{
    "uid": "user123",
    "device_flag": 1
  }'

const response = await fetch('http://localhost:5001/user/device_quit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    uid: 'user123',
    device_flag: 1
  })
});

const data = await response.json();
console.log(data);

import requests

data = {
    "uid": "user123",
    "device_flag": 1
}

response = requests.post('http://localhost:5001/user/device_quit', json=data)
result = response.json()
print(result)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    data := map[string]interface{}{
        "uid":         "user123",
        "device_flag": 1,
    }
    
    jsonData, _ := json.Marshal(data)
    
    resp, err := http.Post(
        "http://localhost:5001/user/device_quit",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
}

{
  "status": "ok"
}

Overview

Force a specified user’s device to quit/disconnect, used for administrators to kick out users or handle abnormal connections.

Request Body

Required Parameters

string

required

User ID

Optional Parameters

integer

Device identifier, used to specify a particular device type

0 - App (Android, iPhone, iPad devices)
1 - Web (Browser, Web applications)
2 - Desktop (Desktop applications)

If not specified, all devices for the user will be disconnected.

curl -X POST "http://localhost:5001/user/device_quit" \
  -H "Content-Type: application/json" \
  -d '{
    "uid": "user123",
    "device_flag": 1
  }'

const response = await fetch('http://localhost:5001/user/device_quit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    uid: 'user123',
    device_flag: 1
  })
});

const data = await response.json();
console.log(data);

import requests

data = {
    "uid": "user123",
    "device_flag": 1
}

response = requests.post('http://localhost:5001/user/device_quit', json=data)
result = response.json()
print(result)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    data := map[string]interface{}{
        "uid":         "user123",
        "device_flag": 1,
    }
    
    jsonData, _ := json.Marshal(data)
    
    resp, err := http.Post(
        "http://localhost:5001/user/device_quit",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
}

{
  "status": "ok"
}

Response Fields

string

required

Operation status, returns "ok" on success

Status Codes

Status Code	Description
200	Device quit successfully
400	Request parameter error
404	User does not exist or device not connected
500	Internal server error

Use Cases

Administrative Control

Kick Violating Users:

// Kick user from all devices
await forceDeviceQuit("violating_user");

// Kick user from specific device type
await forceDeviceQuit("violating_user", 1); // Web only

Session Management:

// Force logout from web sessions for security
await forceDeviceQuit("user123", 1);

Security Management

Suspicious Activity:

// Disconnect suspicious connections
const suspiciousUsers = ["user1", "user2"];
for (const uid of suspiciousUsers) {
    await forceDeviceQuit(uid);
}

Account Compromise:

// Emergency disconnect all devices
await forceDeviceQuit("compromised_user");

Multi-Device Management

Device Limit Enforcement:

// Enforce single device policy
async function enforceSingleDevice(uid, allowedDeviceFlag) {
    // Get current online devices
    const status = await getUserOnlineStatus([uid]);
    
    if (status[0]?.online && status[0].device_flag !== allowedDeviceFlag) {
        // Disconnect other devices
        await forceDeviceQuit(uid, status[0].device_flag);
    }
}

Platform Migration:

// Force users to migrate to new platform
async function migrateFromOldPlatform(userIds) {
    for (const uid of userIds) {
        // Disconnect old platform (device_flag: 0)
        await forceDeviceQuit(uid, 0);
    }
}

Best Practices

Logging: Always log device quit operations for audit purposes
Notification: Notify users when their devices are forcibly disconnected
Reason Codes: Include reason codes for different disconnect scenarios
Rate Limiting: Implement rate limiting to prevent abuse
Permission Check: Verify administrator permissions before allowing device quit
Graceful Handling: Allow users to reconnect after resolving issues

Security Considerations

Admin Only: This API should only be accessible to system administrators
Audit Trail: Maintain detailed logs of all forced disconnections
User Notification: Consider notifying users about forced disconnections
Reason Documentation: Document reasons for forced disconnections
Appeal Process: Provide a process for users to appeal disconnections

Update User Token Get User Online Status

Route Management

Message Management

Channel Management

User Management

Conversation Management

Connection Management

Event Management

Monitoring

System

Integration APIs

Administrator

Force Device Quit

Overview

Request Body

Required Parameters

Optional Parameters

Response Fields

Status Codes

Use Cases

Administrative Control

Security Management

Multi-Device Management

Best Practices

Security Considerations

​Overview

​Request Body

​Required Parameters

​Optional Parameters

​Response Fields

​Status Codes

​Use Cases

​Administrative Control

​Security Management

​Multi-Device Management

​Best Practices

​Security Considerations

Overview

Request Body

Required Parameters

Optional Parameters

Response Fields

Status Codes

Use Cases

Administrative Control

Security Management

Multi-Device Management

Best Practices

Security Considerations