adam-acs/app/models/device.ts

import { BaseModel } from '#database/base_model'
import { DeviceRecord } from '../domain/device/device_record.js'
import { DeviceId } from '../domain/device/device_id.js'
import { DeviceComplianceInfo } from '../domain/configuration/compliance.js'
import { Filter, Sort } from 'mongodb'

export default class DeviceModel extends BaseModel {
  static collectionName = 'devices'

  static async findByIdentifier(identifier: string): Promise<DeviceRecord | null> {
    return this.findOne({ identifier })
  }

  static async findByDeviceId(deviceId: DeviceId): Promise<DeviceRecord | null> {
    return this.findOne({
      'deviceId.manufacturer': deviceId.manufacturer,
      'deviceId.oui': deviceId.oui,
      'deviceId.productClass': deviceId.productClass,
      'deviceId.serialNumber': deviceId.serialNumber,
    })
  }

  static async paginateDevices(
    offset: number,
    limit: number,
    filter: Filter<any> = {}
  ): Promise<{ data: DeviceRecord[]; total: number }> {
    const collection = this.getCollection()
    const total = await collection.countDocuments(filter)
    const data = (await collection
      .find(filter, { projection: { _id: 0 } })
      .skip(offset)
      .limit(limit)
      .sort({ updatedAt: -1 } as Sort)
      .toArray()) as unknown as DeviceRecord[]
    return { data, total }
  }

  static async createOrUpdate(device: Partial<DeviceRecord>): Promise<DeviceRecord> {
    const collection = this.getCollection()
    let filter: Filter<any> = {}

    if (device.deviceId) {
      filter = { deviceId: device.deviceId }
    } else if (device.identifier) {
      filter = { identifier: device.identifier }
    } else {
      throw new Error('Either identifier or deviceId must be provided')
    }

    const result = await collection.findOneAndUpdate(
      filter,
      {
        $set: { ...device, updatedAt: new Date() },
        $setOnInsert: { createdAt: new Date() },
      },
      { upsert: true, returnDocument: 'after', projection: { _id: 0 } }
    )

    return result as unknown as DeviceRecord
  }

  static async updateCompliance(
    identifier: string,
    compliance: DeviceComplianceInfo
  ): Promise<void> {
    await this.updateOne({ identifier }, { compliance })
  }

  static async updateProvisioningCode(
    identifier: string,
    provisioningCode: string
  ): Promise<void> {
    await this.updateOne({ identifier }, { provisioningCode })
  }

  static async findByComplianceStatus(status: string): Promise<DeviceRecord[]> {
    const collection = this.getCollection()
    return collection
      .find({ 'compliance.status': status })
      .toArray() as unknown as Promise<DeviceRecord[]>
  }

  static async findByConfigurationIdentifier(configurationIdentifier: string): Promise<DeviceRecord[]> {
    const collection = this.getCollection()
    return collection
      .find({ 'compliance.configurationIdentifier': configurationIdentifier })
      .toArray() as unknown as Promise<DeviceRecord[]>
  }

  static async distinctCriteriaValues(): Promise<{
    manufacturer: string[]
    oui: string[]
    productClass: string[]
    serialNumber: string[]
  }> {
    const collection = this.getCollection()
    const [manufacturer, oui, productClass, serialNumber] = await Promise.all([
      collection.distinct('deviceId.manufacturer'),
      collection.distinct('deviceId.oui'),
      collection.distinct('deviceId.productClass'),
      collection.distinct('deviceId.serialNumber'),
    ])
    return {
      manufacturer: (manufacturer as string[]).filter(Boolean).sort(),
      oui: (oui as string[]).filter(Boolean).sort(),
      productClass: (productClass as string[]).filter(Boolean).sort(),
      serialNumber: (serialNumber as string[]).filter(Boolean).sort(),
    }
  }

  static async countByComplianceStatus(
    configurationIdentifier: string
  ): Promise<{ compliant: number; in_progress: number; failed: number }> {
    const collection = this.getCollection()
    const results = await collection
      .aggregate([
        { $match: { 'compliance.configurationIdentifier': configurationIdentifier } },
        { $group: { _id: '$compliance.status', count: { $sum: 1 } } },
      ])
      .toArray()

    const counts = { compliant: 0, in_progress: 0, failed: 0 }
    for (const r of results) {
      if (r._id === 'compliant') counts.compliant = r.count
      else if (r._id === 'in_progress') counts.in_progress = r.count
      else if (r._id === 'failed') counts.failed = r.count
    }
    return counts
  }
}