#pragma once

#include "UsbEventLoopWorker.h"
#include "ComplexCommandCreator.h"
#include "ComplexDataCommandCreator.h"
#include "ComplexMultidataCommandCreator.h"
#include "JsonCommandCreator.h"
#include "JsonCommandDescription.h"
#include "JsonCommandFactory.h"

#include "MicroMonWriteExternAccDefaultCalibrationCommand.h"
#include "MicroMonReadCableInfoCommand.h"
#include "MicroMonReadCableExistCommand.h"
#include "MicroMonCheckSpecialFirmwareExistCommand.h"
#include "MicroMonReadCableVersionCommand.h"
#include "MicroMonReadEcgLsbCommand.h"
#include "MicroMonReadExternAccLsbCommand.h"
#include "MicroMonWriteCableInfoCommand.h"
#include "MicroMonWriteCableSetupCounterCommand.h"
#include "MicroMonWriteEcgModeCommand.h"
#include "MicroMonReadEcgModeCommand.h"
#include "MicroMonRestartCommand.h"
#include "MicroMonReadNumberCommand.h"
#include "MicroMonReadGuiVersionCommand.h"
#include "MicroMonGetPowerCommand.h"
#include "MicroMonSetExaminationInfoCommand.h"
#include "MicroMonSetDataToEepromCommand.h"
#include "MicroMonGetDataFromEepromCommand.h"
#include "MicroMonReadInnerChannelsLsbCommand.h"
#include "MicroMonBeginWritingCommand.h"
#include "MicroMonStopWritingCommand.h"
#include "MicroMonSetProgIdCommand.h"
#include "MicroMonGetTimeCommand.h"
#include "MicroMonSetTimeCommand.h"
#include "CardiographReadEcgLsbCommand.h"
#include "CardiographReadExternAccLsbCommand.h"
#include "GetCableLeadTypeCommand.h"
#include "MicroMonGetAddressCommand.h"
#include "MicroMonGetWrittenFlashDataCountCommand.h"
#include "MicroMonStartReceiveFlashDataCommand.h"
#include "MicroMonGetFrequencyCommand.h"
#include "MicroMonGetWritingStateCommand.h"
#include "MicroMonGetPelCommand.h"
#include "MicroMonSetPelCommand.h"
#include "ReadExternAccCalibrationPointsCommand.h"
#include "GetExternAccFrequencyCommand.h"

#include "GetDeviceInfoJsonCommand.h"
#include "GetFlashMemoryInfoJsonCommand.h"
#include "GetCmdListJsonCommand.h"
#include "ReadInnerChannelsCalibrationJsonCommand.h"
#include "ReadExternAccCalibrationJsonCommand.h"
#include "ReadExternAccCalibrationPointsJsonCommand.h""
#include "ReadCableInfoJsonCommand.h"
#include "WriteExternAccDefaultCalibrationJsonCommand.h"
#include "WriteCableInfoJsonCommand.h"
#include "WriteCableSetupCounterJsonCommand.h"
#include "ReadCableVersionJsonCommand.h"
#include "CheckSpecialFirmwareExistJsonCommand.h"
#include "ReadCableExistJsonCommand.h"
#include "WriteEcgModeJsonCommand.h"
#include "ReadEcgModeJsonCommand.h"
#include "RestartJsonCommand.h"
#include "GetPowerJsonCommand.h"
#include "SetExaminationInfoJsonCommand.h"
#include "GetCableLeadTypeJsonCommand.h"
#include "StartWritingJsonCommand.h"
#include "StopWritingJsonCommand.h"
#include "SetProgIdJsonCommand.h"
#include "GetTimeJsonCommand.h"
#include "SetTimeJsonCommand.h"
#include "GetWrittenFlashDataCountJsonCommand.h"
#include "StartReceiveFlashDataJsonCommand.h"
#include "GetExamFileNameJsonCommand.h"
#include "GetFrequencyJsonCommand.h"
#include "GetExternAccFrequencyJsonCommand.h"
#include "GetWritingStateJsonCommand.h"
#include "GetPelJsonCommand.h"
#include "SetPelJsonCommand.h"
#include "TurnVentJsonCommand.h"
#include "TurnPumpJsonCommand.h"

namespace Incart::DeviceWebApi
{

struct DeviceCommandLinker
{
    static void createLink(Usb::UsbEventLoopWorker& eventLoopWorker_, Net::WebApi::JsonCommandFactory& jsonCommandFactory)
    {
        Usb::UsbDeviceManager* deviceManager = eventLoopWorker_.getDeviceManager();
        std::shared_ptr<Usb::AdcChannelsManager> signalManager = eventLoopWorker_.getSignalManager();
        Usb::ByteCommandQueue* commandQueue = deviceManager->getCommandQueue();
        Usb::UsbDeviceCommandSet* deviceCommandSet = deviceManager->getCommandSet();
        Usb::ComplexCommandFactory* complexCommandFactory = deviceCommandSet->getDeviceComplexCommands();
        Usb::UsbDataListener* dataListener = eventLoopWorker_.getDataListener();

        // добавляем обработчики сложных команд
        // CommandCreator'ы служат для генерации объектов команд, чтобы избежать ситуации конфликта обработчиков, при вызове одной и той же команда с разными данными, не дождавшись ответа от предыдущей
        complexCommandFactory->add("MicroMonWriteCableInfo", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonWriteCableInfoCommand, 2, uint32_t, Usb::CableInfo, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonWriteCableSetupCounter", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonWriteCableSetupCounterCommand, 2, uint32_t, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonReadCableInfo", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonReadCableInfoCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonReadCableExist", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonReadCableExistCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonReadCableVersion", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonReadCableVersionCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonCheckSpecialFirmwareExist", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonCheckSpecialFirmwareExistCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonReadEcgLsb", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonReadEcgLsbCommand, uint32_t, Usb::ByteCommandQueue*, int32_t>>(commandQueue, 8));
        complexCommandFactory->add("CardiographReadEcgLsb", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::CardiographReadEcgLsbCommand, uint32_t, int32_t>>(8));
        complexCommandFactory->add("CardiographReadExternAccLsb", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::CardiographReadExternAccLsbCommand, uint32_t>>());
        complexCommandFactory->add("MicroMonReadExternAccLsb", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonReadExternAccLsbCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonWriteExternAccDefaultCalibration", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonWriteExternAccDefaultCalibrationCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("ReadInnerChannelsCalibration", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::ReadInnerChannelsCalibrationCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("ReadExternAccCalibration", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::ReadExternAccCalibrationCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonWriteEcgMode", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonWriteEcgModeCommand, 2, uint32_t, Usb::UsbDevice::EEcgMode, Usb::UsbEventLoopWorker*>>(&eventLoopWorker_));
        complexCommandFactory->add("MicroMonReadEcgMode", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonReadEcgModeCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonRestart", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonRestartCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonReadNumber", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonReadNumberCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonReadGuiVersion", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonReadGuiVersionCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonReadPower", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonGetPowerCommand, uint32_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonSetExaminationInfo", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonSetExaminationInfoCommand, 2, uint32_t, DeviceComplexCommands::ExaminationInfo, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonSetDataToEeprom", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonSetDataToEepromCommand, 2, uint32_t, DeviceComplexCommands::EepromDataRecord, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonGetDataFromEeprom", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonGetDataFromEepromCommand, 3, uint32_t, uint16_t, uint16_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("GetCableLeadType", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::GetCableLeadTypeCommand, uint32_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonReadInnerChannelsLsb", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonReadInnerChannelsLsbCommand, 2, uint32_t, std::unordered_map<DevicesInfo::DeviceChannelTypeInfo, Usb::LsbChannelInfo>, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("MicroMonBeginWriting", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonBeginWritingCommand, uint32_t, DeviceComplexCommands::MicroMonBeginWritingCommand::EStartParams, Usb::UsbDeviceManager*>>(DeviceComplexCommands::MicroMonBeginWritingCommand::EStartParams::Start, deviceManager));
        complexCommandFactory->add("MicroMonStopWriting", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonStopWritingCommand, uint32_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonSetProgId", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonSetProgIdCommand, 2, uint32_t, uint8_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonGetTime", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonGetTimeCommand, uint32_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonSetTime", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonSetTimeCommand, 2, uint32_t, Common::DateTimeObject, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonGetMinAddress", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonGetAddressCommand, uint32_t, std::string, std::string, Usb::UsbDeviceManager*>>("GetMinAddress", "ReadMinAddress", deviceManager));
        complexCommandFactory->add("MicroMonGetMaxAddress", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonGetAddressCommand, uint32_t, std::string, std::string, Usb::UsbDeviceManager*>>("GetMaxAddress", "ReadMaxAddress", deviceManager));
        complexCommandFactory->add("MicroMonGetWrittenMaxAddress", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonGetAddressCommand, uint32_t, std::string, std::string, Usb::UsbDeviceManager*>>("GetWrittenMaxAddress", "ReadWrittenMaxAddress", deviceManager));
        complexCommandFactory->add("MicroMonGetWrittenFlashDataCount", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonGetWrittenFlashDataCountCommand, uint32_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonStartReceiveFlashData", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonStartReceiveFlashDataCommand, uint32_t, Usb::UsbDeviceManager*, Usb::UsbDataListener*>>(deviceManager, dataListener));
        complexCommandFactory->add("MicroMonGetFrequency", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonGetFrequencyCommand, uint32_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonGetWritingState", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonGetWritingStateCommand, uint32_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonGetPel", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::MicroMonGetPelCommand, uint32_t, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("MicroMonSetPel", std::make_shared<Usb::ComplexMultidataCommandCreator<DeviceComplexCommands::MicroMonSetPelCommand, 2, uint32_t, bool, Usb::UsbDeviceManager*>>(deviceManager));
        complexCommandFactory->add("ReadExternAccCalibrationPoints", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::ReadExternAccCalibrationPointsCommand, uint32_t, Usb::ByteCommandQueue*>>(commandQueue));
        complexCommandFactory->add("GetExternAccFrequency", std::make_shared<Usb::ComplexDataCommandCreator<DeviceComplexCommands::GetExternAccFrequencyCommand, uint32_t>>());

        // добавляем конвертеры результата сложных команд в json формат
        std::shared_ptr<Net::WebApi::JsonCommandDescription> commandDescription = GetDeviceInfoJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetDeviceInfoJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetFlashMemoryInfoJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetFlashMemoryInfoJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetCmdListJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetCmdListJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Net::WebApi::JsonCommandFactory*>>(commandDescription, &jsonCommandFactory));
        commandDescription = GetCableLeadTypeJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetCableLeadTypeJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = ReadInnerChannelsCalibrationJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<ReadInnerChannelsCalibrationJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*, Usb::AdcChannelsManager*>>(commandDescription, deviceManager, signalManager.get()));
        commandDescription = ReadExternAccCalibrationJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<ReadExternAccCalibrationJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*, Usb::AdcChannelsManager*>>(commandDescription, deviceManager, signalManager.get()));
        commandDescription = ReadExternAccCalibrationPointsJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<ReadExternAccCalibrationPointsJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = ReadCableInfoJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<ReadCableInfoJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = WriteExternAccDefaultCalibrationJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<WriteExternAccDefaultCalibrationJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = WriteCableInfoJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<WriteCableInfoJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = WriteCableSetupCounterJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<WriteCableSetupCounterJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = CheckSpecialFirmwareExistJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<CheckSpecialFirmwareExistJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = ReadCableVersionJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<ReadCableVersionJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = ReadCableExistJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<ReadCableExistJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = WriteEcgModeJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<WriteEcgModeJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = ReadEcgModeJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<ReadEcgModeJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = RestartJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<RestartJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetPowerJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetPowerJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = SetExaminationInfoJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<SetExaminationInfoJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = StartWritingJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<StartWritingJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = StopWritingJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<StopWritingJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = SetProgIdJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<SetProgIdJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetTimeJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetTimeJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = SetTimeJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<SetTimeJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetWrittenFlashDataCountJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetWrittenFlashDataCountJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = StartReceiveFlashDataJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<StartReceiveFlashDataJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetExamFileNameJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetExamFileNameJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetFrequencyJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetFrequencyJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetExternAccFrequencyJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetExternAccFrequencyJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetWritingStateJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetWritingStateJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = GetPelJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<GetPelJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = SetPelJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<SetPelJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = TurnVentJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<TurnVentJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
        commandDescription = TurnPumpJsonCommand::createCommandDescription();
        jsonCommandFactory.add(commandDescription, std::make_shared<Net::WebApi::JsonCommandCreator<TurnPumpJsonCommand, std::shared_ptr<Net::WebApi::JsonCommandDescription>, Usb::UsbDeviceManager*>>(commandDescription, deviceManager));
    }
};

} // namespace Incart::DeviceWebApi