418 lines
13 KiB
TypeScript
418 lines
13 KiB
TypeScript
import { Device } from '../../domain/device/device.js'
|
|
import { DeviceParameter } from '../../domain/device/device_parameter.js'
|
|
import { ParameterType } from '../../domain/shared/types.js'
|
|
import { CWMPTaskQueue, ResultStatus, TaskResult } from './task_queue.js'
|
|
import DeviceModel from '../../models/device.js'
|
|
import logger from '@adonisjs/core/services/logger'
|
|
|
|
// Parameter types (simplified from legacy provisioning domain)
|
|
interface SetParameterValue {
|
|
parameterName: string
|
|
value: string | number | boolean
|
|
type?: string
|
|
}
|
|
|
|
interface SetParameterAttribute {
|
|
name: string
|
|
notificationChange: boolean
|
|
notification: number
|
|
accessListChange: boolean
|
|
accessList: string[]
|
|
}
|
|
|
|
interface SetScheduleInform {
|
|
delayInSeconds: number
|
|
commandKey?: string
|
|
}
|
|
|
|
interface DownloadParameter {
|
|
commandKey: string
|
|
fileType: string
|
|
url: string
|
|
username?: string
|
|
password?: string
|
|
fileSize?: number
|
|
targetFileName?: string
|
|
delaySeconds?: number
|
|
successUrl?: string
|
|
failureUrl?: string
|
|
}
|
|
|
|
interface UploadParameter {
|
|
commandKey: string
|
|
fileType: string
|
|
url: string
|
|
username?: string
|
|
password?: string
|
|
delayInSeconds?: number
|
|
}
|
|
|
|
interface FactoryResetParameter {
|
|
commandKey?: string
|
|
}
|
|
|
|
interface RebootParameter {
|
|
commandKey?: string
|
|
}
|
|
|
|
/**
|
|
* Executes CWMP actions on devices via the TaskQueue
|
|
* Each action wraps a callback that persists state on success
|
|
*/
|
|
export class DeviceActionExecutor {
|
|
private taskQueue: CWMPTaskQueue
|
|
|
|
constructor(taskQueue: CWMPTaskQueue) {
|
|
this.taskQueue = taskQueue
|
|
}
|
|
|
|
private async persistDevice(device: Device): Promise<void> {
|
|
try {
|
|
const snapshot = device.toSnapshot()
|
|
await DeviceModel.createOrUpdate({
|
|
identifier: snapshot.identifier,
|
|
deviceId: snapshot.deviceId,
|
|
properties: snapshot.properties,
|
|
parameters: snapshot.parameters,
|
|
gpnStatus: snapshot.gpnStatus,
|
|
dataModel: snapshot.dataModel,
|
|
updatedAt: new Date(),
|
|
})
|
|
} catch (e) {
|
|
logger.error(`Failed to persist device: ${e}`)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get parameter values from device.
|
|
*/
|
|
async getParameterValues(
|
|
device: Device,
|
|
parameterPaths: string[],
|
|
callback: (result: TaskResult) => Promise<string>
|
|
): Promise<string> {
|
|
const wrappedCallback = async (result: TaskResult) => {
|
|
if (result.status === ResultStatus.Success) {
|
|
try {
|
|
const resp: any = result.data
|
|
const list = resp?.ParameterList?.ParameterValueStruct
|
|
if (Array.isArray(list) && list.length > 0) {
|
|
device.updateFromValues(list)
|
|
await this.persistDevice(device)
|
|
}
|
|
} catch (e) {
|
|
logger.error(`Error updating device from parameter values: ${e}`)
|
|
}
|
|
}
|
|
return await callback(result)
|
|
}
|
|
|
|
return this.taskQueue.addTask(device.deviceId, 'get_parameter_values', parameterPaths, wrappedCallback).xml
|
|
}
|
|
|
|
async getParameterAttributes(
|
|
device: Device,
|
|
parameterList: string[],
|
|
callback: (result: TaskResult) => Promise<string>
|
|
): Promise<string> {
|
|
const wrappedCallback = async (result: TaskResult) => {
|
|
if (result.status === ResultStatus.Success) {
|
|
try {
|
|
const resp: any = result.data
|
|
const list = resp?.ParameterList?.ParameterAttributeStruct
|
|
if (Array.isArray(list) && list.length > 0) {
|
|
for (const attr of list) {
|
|
const name: string | undefined = attr?.Name
|
|
if (!name) continue
|
|
const notification: number | undefined = typeof attr?.Notification === 'number' ? attr.Notification : undefined
|
|
const accessList: string[] | undefined = attr?.AccessList?.string
|
|
|
|
const param = device.getParameter(name)
|
|
if (param) {
|
|
param.updateAttributes?.(notification, accessList)
|
|
continue
|
|
}
|
|
const prop = device.getProperty(name)
|
|
if (prop) {
|
|
prop.updateAttributes?.(notification, accessList)
|
|
}
|
|
}
|
|
await this.persistDevice(device)
|
|
}
|
|
} catch (e) {
|
|
logger.error(`Error updating device from parameter attributes: ${e}`)
|
|
}
|
|
}
|
|
return await callback(result)
|
|
}
|
|
|
|
return this.taskQueue.addTask(device.deviceId, 'get_parameter_attributes', parameterList, wrappedCallback).xml
|
|
}
|
|
|
|
async getParameterNames(
|
|
device: Device,
|
|
parameterName: string,
|
|
callback: (result: TaskResult) => Promise<string>
|
|
): Promise<string> {
|
|
const wrappedCallback = async (result: TaskResult) => {
|
|
if (result.status === ResultStatus.Success) {
|
|
try {
|
|
device.organizeParameters(result.data as any, new Date())
|
|
device.setGpnStatus('supported')
|
|
device.recordGpnSuccess()
|
|
device.lastGpnSentDate = new Date()
|
|
await this.persistDevice(device)
|
|
} catch (e) {
|
|
logger.error(`Error organizing parameters: ${e}`)
|
|
}
|
|
} else {
|
|
// Inspect fault code to distinguish "unsupported" from "transient error"
|
|
const faultCode =
|
|
result.data?.FaultCode ??
|
|
result.data?.faultCode ??
|
|
result.data?.Detail?.Fault?.FaultCode ??
|
|
result.data?.detail?.Fault?.FaultCode
|
|
const code = typeof faultCode === 'string' ? parseInt(faultCode, 10) : faultCode
|
|
const GPN_UNSUPPORTED_CODES = [9000, 9001, 9003, 9004, 9005]
|
|
const GPN_TRANSIENT_CODES = [9002]
|
|
|
|
if (GPN_UNSUPPORTED_CODES.includes(code)) {
|
|
device.setGpnStatus('unsupported')
|
|
device.recordGpnFailure()
|
|
await this.persistDevice(device)
|
|
} else if (GPN_TRANSIENT_CODES.includes(code)) {
|
|
// Transient error: log warning, do not mark unsupported, allow retry this session
|
|
logger.warn({ code, deviceId: device.deviceId?.serialNumber }, 'GPN transient error (9002) — will not mark unsupported')
|
|
}
|
|
// Network timeout or other codes: do not mark unsupported, skip GPN for this session only
|
|
}
|
|
return await callback(result)
|
|
}
|
|
|
|
return this.taskQueue.addTask(device.deviceId, 'get_parameter_names', parameterName, wrappedCallback).xml
|
|
}
|
|
|
|
async applySetParameterValues(
|
|
device: Device,
|
|
parameters: SetParameterValue[],
|
|
callback: (result: boolean) => Promise<string>
|
|
): Promise<string> {
|
|
const existingParameters = device.getParameters()
|
|
|
|
const inferType = (val: any): string => {
|
|
const t = typeof val
|
|
switch (t) {
|
|
case 'boolean': return 'xsd:boolean'
|
|
case 'number': return Number.isInteger(val) ? 'xsd:int' : 'xsd:string'
|
|
default: return 'xsd:string'
|
|
}
|
|
}
|
|
|
|
const cwmpTypeMap: Record<string, string> = {
|
|
string: 'xsd:string',
|
|
unsignedInt: 'xsd:unsignedInt',
|
|
int: 'xsd:int',
|
|
boolean: 'xsd:boolean',
|
|
dateTime: 'xsd:dateTime',
|
|
}
|
|
|
|
const pvStructs = parameters.map((p) => {
|
|
const existing = existingParameters.find((ep) => ep.name === p.parameterName)
|
|
// Priority: 1) explicit type from config, 2) known device type, 3) inferred from JS value
|
|
let xsdType: string
|
|
if (p.type && cwmpTypeMap[p.type]) {
|
|
xsdType = cwmpTypeMap[p.type]
|
|
} else if (existing?.type && existing.type !== ParameterType.UNKNOWN) {
|
|
xsdType = existing.type // already in xsd: format (e.g. 'xsd:string')
|
|
} else {
|
|
xsdType = inferType(p.value)
|
|
}
|
|
return {
|
|
Name: p.parameterName,
|
|
Value: { _: p.value, $: { Type: xsdType } },
|
|
}
|
|
})
|
|
|
|
const parameterKey = `SetPValues_${device.deviceId.serialNumber}_${Date.now()}`
|
|
|
|
return this.taskQueue.addTask(
|
|
device.deviceId,
|
|
'set_parameter_values',
|
|
{ parameterValueList: pvStructs, parameterKey },
|
|
async (result: TaskResult) => {
|
|
if (result.status === ResultStatus.Success) {
|
|
device.updateFromValues(pvStructs as any)
|
|
await this.persistDevice(device)
|
|
return await callback(true)
|
|
}
|
|
return await callback(false)
|
|
}
|
|
).xml
|
|
}
|
|
|
|
async applySetParameterAttributes(
|
|
device: Device,
|
|
parameters: SetParameterAttribute[],
|
|
callback: (result: boolean) => Promise<string>
|
|
): Promise<string> {
|
|
const attrs = parameters.map((p) => ({
|
|
name: p.name,
|
|
notificationChange: p.notificationChange ?? false,
|
|
notification: p.notification ?? 0,
|
|
accessListChange: p.accessListChange ?? false,
|
|
accessList: (p.accessList as any)?.string || [],
|
|
}))
|
|
|
|
return this.taskQueue.addTask(
|
|
device.deviceId,
|
|
'set_parameter_attributes',
|
|
attrs,
|
|
async (result: TaskResult) => {
|
|
if (result.status === ResultStatus.Success) {
|
|
return await callback(true)
|
|
}
|
|
return await callback(false)
|
|
}
|
|
).xml
|
|
}
|
|
|
|
async applyScheduleInform(
|
|
device: Device,
|
|
parameter: SetScheduleInform,
|
|
callback: (result: boolean) => Promise<string>
|
|
): Promise<string> {
|
|
const commandKey = parameter.commandKey || `ScheduleInform_${device.deviceId.serialNumber}_${Date.now()}`
|
|
return this.taskQueue.addTask(
|
|
device.deviceId,
|
|
'schedule_inform',
|
|
{ delayInSeconds: parameter.delayInSeconds, commandKey },
|
|
async (result: TaskResult) => {
|
|
return await callback(result.status === ResultStatus.Success)
|
|
}
|
|
).xml
|
|
}
|
|
|
|
async applyFactoryReset(
|
|
_device: Device,
|
|
_parameter: FactoryResetParameter,
|
|
callback: (result: boolean) => Promise<string>
|
|
): Promise<string> {
|
|
return this.taskQueue.addTask(
|
|
_device.deviceId,
|
|
'factory_reset',
|
|
{},
|
|
async (result: TaskResult) => {
|
|
return await callback(result.status === ResultStatus.Success)
|
|
}
|
|
).xml
|
|
}
|
|
|
|
async applyReboot(
|
|
device: Device,
|
|
parameter: RebootParameter,
|
|
callback: (result: boolean) => Promise<string>
|
|
): Promise<string> {
|
|
return this.taskQueue.addTask(
|
|
device.deviceId,
|
|
'reboot',
|
|
{ commandKey: parameter.commandKey || '' },
|
|
async (result: TaskResult) => {
|
|
return await callback(result.status === ResultStatus.Success)
|
|
}
|
|
).xml
|
|
}
|
|
|
|
async applyDownload(
|
|
device: Device,
|
|
parameter: DownloadParameter,
|
|
callback: (result: boolean) => Promise<string>
|
|
): Promise<string> {
|
|
return this.taskQueue.addTask(
|
|
device.deviceId,
|
|
'download',
|
|
{
|
|
commandKey: parameter.commandKey,
|
|
fileType: parameter.fileType,
|
|
url: parameter.url,
|
|
username: parameter.username,
|
|
password: parameter.password,
|
|
fileSize: parameter.fileSize,
|
|
targetFileName: parameter.targetFileName,
|
|
delaySeconds: parameter.delaySeconds,
|
|
successUrl: parameter.successUrl,
|
|
failureUrl: parameter.failureUrl,
|
|
},
|
|
async (result: TaskResult) => {
|
|
return await callback(result.status === ResultStatus.Success)
|
|
}
|
|
).xml
|
|
}
|
|
|
|
async applyUpload(
|
|
device: Device,
|
|
parameter: UploadParameter,
|
|
callback: (result: boolean) => Promise<string>
|
|
): Promise<string> {
|
|
return this.taskQueue.addTask(
|
|
device.deviceId,
|
|
'upload',
|
|
{
|
|
commandKey: parameter.commandKey,
|
|
fileType: parameter.fileType,
|
|
url: parameter.url,
|
|
username: parameter.username,
|
|
password: parameter.password,
|
|
delaySeconds: parameter.delayInSeconds,
|
|
},
|
|
async (result: TaskResult) => {
|
|
return await callback(result.status === ResultStatus.Success)
|
|
}
|
|
).xml
|
|
}
|
|
|
|
async insertProvisioningCode(
|
|
device: Device,
|
|
callback: (result: boolean) => Promise<string>
|
|
): Promise<string> {
|
|
const allParams = device.getParameters()
|
|
const allProps = device.getProperties()
|
|
|
|
const knownPC = [...allParams, ...allProps].find((p: any) => /(^|\.)ProvisioningCode$/.test(p?.name))
|
|
|
|
// Use the detected data model stored on the device; fall back to scanning known params
|
|
let provisioningPath: string
|
|
if (knownPC) {
|
|
provisioningPath = knownPC.name
|
|
} else if (device.dataModel === 'tr-181') {
|
|
provisioningPath = 'Device.DeviceInfo.ProvisioningCode'
|
|
} else if (device.dataModel === 'tr-098') {
|
|
provisioningPath = 'InternetGatewayDevice.DeviceInfo.ProvisioningCode'
|
|
} else {
|
|
// Legacy fallback: scan stored params
|
|
const hasDeviceTree = [...allParams, ...allProps].some((p: any) => typeof p?.name === 'string' && p.name.startsWith('Device.'))
|
|
provisioningPath = hasDeviceTree ? 'Device.DeviceInfo.ProvisioningCode' : 'InternetGatewayDevice.DeviceInfo.ProvisioningCode'
|
|
}
|
|
|
|
const parameterKey = `SetPValues_${device.deviceId.serialNumber}_${Date.now()}`
|
|
const pvStructs = [{ Name: provisioningPath, Value: { _: device.tmpPC, $: { Type: 'xsd:string' } } }]
|
|
|
|
return this.taskQueue.addTask(
|
|
device.deviceId,
|
|
'set_parameter_values',
|
|
{ parameterValueList: pvStructs, parameterKey },
|
|
async (result: TaskResult) => {
|
|
if (result.status === ResultStatus.Success) {
|
|
// ProvisioningCode must always be stored as a writable parameter.
|
|
// If it was previously classified as a read-only property (wrong), remove it first.
|
|
device.removeProperty(provisioningPath)
|
|
device.setParameter(new DeviceParameter(provisioningPath, device.tmpPC, ParameterType.STRING))
|
|
await this.persistDevice(device)
|
|
device.tmpPC = ''
|
|
return await callback(true)
|
|
}
|
|
return await callback(false)
|
|
}
|
|
).xml
|
|
}
|
|
}
|