@constructorfleet/ultimate-govee
Version:
Library for interacting with Govee devices written in Typescript.
146 lines • 7.14 kB
JavaScript
;
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var GoveeDeviceService_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.GoveeDeviceService = void 0;
const common_1 = require("@nestjs/common");
const _ultimate_govee_persist_1 = require("../../../persist");
const govee_device_config_1 = require("./govee-device.config");
const device_list_response_1 = require("./models/device-list.response");
const utils_1 = require("../../utils");
const govee_diy_service_1 = require("../diy/govee-diy.service");
const path_1 = require("path");
let GoveeDeviceService = GoveeDeviceService_1 = class GoveeDeviceService {
constructor(config, deviceListResponse, diyService) {
this.config = config;
this.deviceListResponse = deviceListResponse;
this.diyService = diyService;
this.logger = new common_1.Logger(GoveeDeviceService_1.name);
}
async getDeviceList(oauthData) {
try {
this.logger.log('Retrieving list of devices from Govee REST API');
const response = await this.getApiResult(oauthData);
return GoveeDeviceService_1.parseResponse(response);
}
catch (err) {
this.logger.error('Unable to retrieve device list', err);
return GoveeDeviceService_1.parseResponse(this.deviceListResponse || { message: '', status: 0, devices: [] });
}
}
async getApiResult(oauthData) {
const response = await (0, utils_1.request)(this.config.deviceListUrl, (0, utils_1.goveeAuthenticatedHeaders)(oauthData)).post(device_list_response_1.DeviceListResponse, (0, path_1.join)(_ultimate_govee_persist_1.PersistModule.persistRootDirectory, 'govee.devices.raw.json'));
return response.data;
}
static parseResponse(response) {
return response.devices.map((device) => {
try {
const settings = device.deviceExt.deviceSettings;
const data = device.deviceExt.deviceData;
return {
name: device.deviceName,
model: device.sku,
cmd: 'status',
softwareVersion: settings.softwareVersion,
hardwareVersion: settings.hardwareVersion,
id: device.device,
iotTopic: device.deviceExt.deviceSettings.topic,
bleAddress: device.deviceExt.deviceSettings.bleAddress,
pactCode: device.pactCode,
pactType: device.pactType,
goodsType: device.goodsType,
groupId: device.groupId,
ic: settings.ic,
wifi: GoveeDeviceService_1.getWiFiData(settings),
blueTooth: GoveeDeviceService_1.getBleData(settings),
state: {
online: data.isOnline,
isOn: data.isOn,
lastTime: data.lastReportTimestamp,
waterShortage: settings.waterShortage,
boilWaterCompleteNotification: settings.notifyWaterBoiling,
autoShudown: settings.automaticShutDown,
playState: settings.playState,
filterExpired: settings.filterExpired,
completeNotification: settings.notifyComplete,
battery: settings.batteryLevel,
temperature: settings.minTemperature !== undefined &&
settings.maxTemperature !== undefined
? {
min: settings.minTemperature / 100,
max: settings.maxTemperature / 100,
calibration: settings.temperatureCalibration,
warning: settings.temperatureWarning,
current: data.currentTemperature,
}
: undefined,
humidity: settings.minHumidity !== undefined &&
settings.maxHumidity !== undefined
? {
min: settings.minHumidity / 100,
max: settings.maxHumidity / 100,
calibration: settings.Calibration,
warning: settings.humidityWarning,
current: data.currentHumditity,
}
: undefined,
},
};
}
catch (err) {
throw new Error('Unable to parse device response');
}
});
}
static getWiFiData(settings) {
if (!settings.wifiHardwareVersion ||
!settings.wifiSoftVersion ||
!settings.wifiMacAddress) {
return undefined;
}
return {
name: settings.wifiName,
mac: settings.wifiMacAddress,
hardwareVersion: settings.wifiHardwareVersion,
softwareVersion: settings.wifiSoftVersion,
};
}
static getBleData(settings) {
if (!settings.bleAddress || !settings.bleName) {
return undefined;
}
return {
name: settings.bleName,
mac: settings.bleAddress,
};
}
};
exports.GoveeDeviceService = GoveeDeviceService;
__decorate([
(0, _ultimate_govee_persist_1.PersistResult)({
filename: 'govee.devices.json',
}),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object]),
__metadata("design:returntype", Promise)
], GoveeDeviceService.prototype, "getApiResult", null);
exports.GoveeDeviceService = GoveeDeviceService = GoveeDeviceService_1 = __decorate([
(0, common_1.Injectable)(),
__param(0, (0, common_1.Inject)(govee_device_config_1.GoveeDeviceConfig.KEY)),
__param(1, (0, _ultimate_govee_persist_1.InjectPersisted)({
filename: 'govee.devices.json',
})),
__metadata("design:paramtypes", [void 0, Object, govee_diy_service_1.GoveeDiyService])
], GoveeDeviceService);
//# sourceMappingURL=govee-device.service.js.map