重写add接口

master

2022-04-07 58389be5d3c1bbf4e47976f7ea09977be8bb84c5

重写add接口

 src/app/modules/business/controller/admin/basedeviceinfo.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Basedeviceinfo } from '../../entity/basedeviceinfo';
import { BasedeviceinfoService } from '../../service/basedeviceinfo';
// import { BasedeviceinfoService } from '../../service/basedeviceinfo';
import { DataController } from '../../../base/controller/dataController';
import { BaseDeviceService } from '../../service/deviceinfo';
/**
        * 设备信息
        */
        * 设备信息
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Basedeviceinfo,
  service: BasedeviceinfoService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Basedeviceinfo,
  service: BaseDeviceService,
})
export class BasedeviceinfoController extends DataController {
  @Inject()
  basedeviceinfoService: BasedeviceinfoService;
  


  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/basedeviceparams.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Basedeviceparams } from '../../entity/basedeviceparams';
import { BasedeviceparamsService } from '../../service/basedeviceparams';
// import { BasedeviceparamsService } from '../../service/basedeviceparams';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备参数
        */
        * 设备参数
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Basedeviceparams,
  service: BasedeviceparamsService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Basedeviceparams,
  //   service: BasedeviceparamsService,
})
export class BasedeviceparamsController extends DataController {
  @Inject()
  basedeviceparamsService: BasedeviceparamsService;
  
  //   @Inject()
  //   basedeviceparamsService: BasedeviceparamsService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/basedevicesection.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Basedevicesection } from '../../entity/basedevicesection';
import { BasedevicesectionService } from '../../service/basedevicesection';
// import { BasedevicesectionService } from '../../service/basedevicesection';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备组件
        */
        * 设备组件
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Basedevicesection,
  service: BasedevicesectionService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Basedevicesection,
  //   service: BasedevicesectionService,
})
export class BasedevicesectionController extends DataController {
  @Inject()
  basedevicesectionService: BasedevicesectionService;
  
  //   @Inject()
  //   basedevicesectionService: BasedevicesectionService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/basedevicestatus.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Basedevicestatus } from '../../entity/basedevicestatus';
import { BasedevicestatusService } from '../../service/basedevicestatus';
// import { BasedevicestatusService } from '../../service/basedevicestatus';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备状态
        */
        * 设备状态
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Basedevicestatus,
  service: BasedevicestatusService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Basedevicestatus,
  //   service: BasedevicestatusService,
})
export class BasedevicestatusController extends DataController {
  @Inject()
  basedevicestatusService: BasedevicestatusService;
  
  //   @Inject()
  //   basedevicestatusService: BasedevicestatusService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/colletdata.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Colletdata } from '../../entity/colletdata';
import { ColletdataService } from '../../service/colletdata';
// import { ColletdataService } from '../../service/colletdata';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测元数据
        */
        * 监测元数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Colletdata,
  service: ColletdataService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Colletdata,
  //   service: ColletdataService,
})
export class ColletdataController extends DataController {
  @Inject()
  colletdataService: ColletdataService;
  
  //   @Inject()
  //   colletdataService: ColletdataService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/colletmeta.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Colletmeta } from '../../entity/colletmeta';
import { ColletmetaService } from '../../service/colletmeta';
// import { ColletmetaService } from '../../service/colletmeta';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测元数据
        */
        * 监测元数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Colletmeta,
  service: ColletmetaService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Colletmeta,
  //   service: ColletmetaService,
})
export class ColletmetaController extends DataController {
  @Inject()
  colletmetaService: ColletmetaService;
  
  //   @Inject()
  //   colletmetaService: ColletmetaService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/comconfig.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Comconfig } from '../../entity/comconfig';
import { ComconfigService } from '../../service/comconfig';
// import { ComconfigService } from '../../service/comconfig';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测元数据
        */
        * 监测元数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Comconfig,
  service: ComconfigService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Comconfig,
  //   service: ComconfigService,
})
export class ComconfigController extends DataController {
  @Inject()
  comconfigService: ComconfigService;
  
  //   @Inject()
  //   comconfigService: ComconfigService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/deviceattachment.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Deviceattachment } from '../../entity/deviceattachment';
import { DeviceattachmentService } from '../../service/deviceattachment';
// import { DeviceattachmentService } from '../../service/deviceattachment';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备相关的附件
        */
        * 设备相关的附件
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Deviceattachment,
  service: DeviceattachmentService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Deviceattachment,
  //   service: DeviceattachmentService,
})
export class DeviceattachmentController extends DataController {
  @Inject()
  deviceattachmentService: DeviceattachmentService;
  
  //   @Inject()
  //   deviceattachmentService: DeviceattachmentService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/devicegroup.ts

@@ -1,7 +1,7 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Devicegroup } from '../../entity/devicegroup';
import { DevicegroupService } from '../../service/devicegroup';
// import { DevicegroupService } from '../../service/devicegroup';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备分组
@@ -10,24 +10,24 @@
@CoolController({
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Devicegroup,
  service: DevicegroupService,
  // service: DevicegroupService,
})
export class DevicegroupController extends DataController {
  @Inject()
  devicegroupService: DevicegroupService;
  // @Inject()
  // devicegroupService: DevicegroupService;

  /**
  * 获得数据
  */
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.devicegroupService.getData(params));
  }
  /**
  * 获得数据
  */
  @Post('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.devicegroupService.getData(params));
  }
  // @Get('/getdata', { summary: '数据接口' })
  // async getData(@Query(ALL) params: any) {
  //   return this.ok(await this.devicegroupService.getData(params));
  // }
  // /**
  // * 获得数据
  // */
  // @Post('/postdata', { summary: '数据接口' })
  // async postData(@Query(ALL) params: any) {
  //   return this.ok(await this.devicegroupService.getData(params));
  // }
}

 src/app/modules/business/controller/admin/deviceopreraterecord.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Deviceopreraterecord } from '../../entity/deviceopreraterecord';
import { DeviceopreraterecordService } from '../../service/deviceopreraterecord';
// import { DeviceopreraterecordService } from '../../service/deviceopreraterecord';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备运维记录
        */
        * 设备运维记录
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Deviceopreraterecord,
  service: DeviceopreraterecordService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Deviceopreraterecord,
  //   service: DeviceopreraterecordService,
})
export class DeviceopreraterecordController extends DataController {
  @Inject()
  deviceopreraterecordService: DeviceopreraterecordService;
  
  //   @Inject()
  //   deviceopreraterecordService: DeviceopreraterecordService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/doutrubine.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Doutrubine } from '../../entity/doutrubine';
import { DoutrubineService } from '../../service/doutrubine';
// import { DoutrubineService } from '../../service/doutrubine';
import { DataController } from '../../../base/controller/dataController';
/**
        * 斗轮机信息
        */
        * 斗轮机信息
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Doutrubine,
  service: DoutrubineService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Doutrubine,
  //   service: DoutrubineService,
})
export class DoutrubineController extends DataController {
  @Inject()
  doutrubineService: DoutrubineService;
  
  //   @Inject()
  //   doutrubineService: DoutrubineService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/execrecord.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Execrecord } from '../../entity/execrecord';
import { ExecrecordService } from '../../service/execrecord';
// import { ExecrecordService } from '../../service/execrecord';
import { DataController } from '../../../base/controller/dataController';
/**
        * 任务执行记录
        */
        * 任务执行记录
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Execrecord,
  service: ExecrecordService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Execrecord,
  //   service: ExecrecordService,
})
export class ExecrecordController extends DataController {
  @Inject()
  execrecordService: ExecrecordService;
  
  //   @Inject()
  //   execrecordService: ExecrecordService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/interfacelist.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Interfacelist } from '../../entity/interfacelist';
import { InterfacelistService } from '../../service/interfacelist';
// import { InterfacelistService } from '../../service/interfacelist';
import { DataController } from '../../../base/controller/dataController';
/**
        * 接口清单
        */
        * 接口清单
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Interfacelist,
  service: InterfacelistService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Interfacelist,
  //   service: InterfacelistService,
})
export class InterfacelistController extends DataController {
  @Inject()
  interfacelistService: InterfacelistService;
  
  //   @Inject()
  //   interfacelistService: InterfacelistService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/interfacerecord.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Interfacerecord } from '../../entity/interfacerecord';
import { InterfacerecordService } from '../../service/interfacerecord';
// import { InterfacerecordService } from '../../service/interfacerecord';
import { DataController } from '../../../base/controller/dataController';
/**
        * 组合模型
        */
        * 组合模型
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Interfacerecord,
  service: InterfacerecordService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Interfacerecord,
  //   service: InterfacerecordService,
})
export class InterfacerecordController extends DataController {
  @Inject()
  interfacerecordService: InterfacerecordService;
  
  //   @Inject()
  //   interfacerecordService: InterfacerecordService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/messagerecord.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Messagerecord } from '../../entity/messagerecord';
import { MessagerecordService } from '../../service/messagerecord';
// import { MessagerecordService } from '../../service/messagerecord';
import { DataController } from '../../../base/controller/dataController';
/**
        * 任务消息记录
        */
        * 任务消息记录
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Messagerecord,
  service: MessagerecordService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Messagerecord,
  //   service: MessagerecordService,
})
export class MessagerecordController extends DataController {
  @Inject()
  messagerecordService: MessagerecordService;
  
  //   @Inject()
  //   messagerecordService: MessagerecordService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/metadata.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Metadata } from '../../entity/metadata';
import { MetadataService } from '../../service/metadata';
// import { MetadataService } from '../../service/metadata';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测采集原数据
        */
        * 监测采集原数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Metadata,
  service: MetadataService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Metadata,
  //   service: MetadataService,
})
export class MetadataController extends DataController {
  @Inject()
  metadataService: MetadataService;
  
  //   @Inject()
  //   metadataService: MetadataService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/modelcombination.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Modelcombination } from '../../entity/modelcombination';
import { ModelcombinationService } from '../../service/modelcombination';
// import { ModelcombinationService } from '../../service/modelcombination';
import { DataController } from '../../../base/controller/dataController';
/**
        * 组合模型
        */
        * 组合模型
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Modelcombination,
  service: ModelcombinationService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Modelcombination,
  //   service: ModelcombinationService,
})
export class ModelcombinationController extends DataController {
  @Inject()
  modelcombinationService: ModelcombinationService;
  
  //   @Inject()
  //   modelcombinationService: ModelcombinationService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/modelstatic.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Modelstatic } from '../../entity/modelstatic';
import { ModelstaticService } from '../../service/modelstatic';
// import { ModelstaticService } from '../../service/modelstatic';
import { DataController } from '../../../base/controller/dataController';
/**
        * 静态模型数据
        */
        * 静态模型数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Modelstatic,
  service: ModelstaticService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Modelstatic,
  //   service: ModelstaticService,
})
export class ModelstaticController extends DataController {
  @Inject()
  modelstaticService: ModelstaticService;
  
  //   @Inject()
  //   modelstaticService: ModelstaticService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/periodicsetting.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Periodicsetting } from '../../entity/periodicsetting';
import { PeriodicsettingService } from '../../service/periodicsetting';
// import { PeriodicsettingService } from '../../service/periodicsetting';
import { DataController } from '../../../base/controller/dataController';
/**
        * 分组任务参数设置
        */
        * 分组任务参数设置
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Periodicsetting,
  service: PeriodicsettingService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Periodicsetting,
  //   service: PeriodicsettingService,
})
export class PeriodicsettingController extends DataController {
  @Inject()
  periodicsettingService: PeriodicsettingService;
  
  //   @Inject()
  //   periodicsettingService: PeriodicsettingService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/planinventory.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Planinventory } from '../../entity/planinventory';
import { PlaninventoryService } from '../../service/planinventory';
// import { PlaninventoryService } from '../../service/planinventory';
import { DataController } from '../../../base/controller/dataController';
/**
        * 盘煤计划
        */
        * 盘煤计划
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Planinventory,
  service: PlaninventoryService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Planinventory,
  //   service: PlaninventoryService,
})
export class PlaninventoryController extends DataController {
  @Inject()
  planinventoryService: PlaninventoryService;
  
  //   @Inject()
  //   planinventoryService: PlaninventoryService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/pointcloud.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Pointcloud } from '../../entity/pointcloud';
import { PointcloudService } from '../../service/pointcloud';
// import { PointcloudService } from '../../service/pointcloud';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测元数据
        */
        * 监测元数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Pointcloud,
  service: PointcloudService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Pointcloud,
  //   service: PointcloudService,
})
export class PointcloudController extends DataController {
  @Inject()
  pointcloudService: PointcloudService;
  
  //   @Inject()
  //   pointcloudService: PointcloudService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/pointmodel.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Pointmodel } from '../../entity/pointmodel';
import { PointmodelService } from '../../service/pointmodel';
// import { PointmodelService } from '../../service/pointmodel';
import { DataController } from '../../../base/controller/dataController';
/**
        * 点云模型
        */
        * 点云模型
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Pointmodel,
  service: PointmodelService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Pointmodel,
  //   service: PointmodelService,
})
export class PointmodelController extends DataController {
  @Inject()
  pointmodelService: PointmodelService;
  
  //   @Inject()
  //   pointmodelService: PointmodelService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/statdata.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Statdata } from '../../entity/statdata';
import { StatdataService } from '../../service/statdata';
// import { StatdataService } from '../../service/statdata';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测统计
        */
        * 监测统计
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Statdata,
  service: StatdataService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Statdata,
  //   service: StatdataService,
})
export class StatdataController extends DataController {
  @Inject()
  statdataService: StatdataService;
  
  //   @Inject()
  //   statdataService: StatdataService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/taskimmediately.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Taskimmediately } from '../../entity/taskimmediately';
import { TaskimmediatelyService } from '../../service/taskimmediately';
// import { TaskimmediatelyService } from '../../service/taskimmediately';
import { DataController } from '../../../base/controller/dataController';
/**
        * 即时任务记录
        */
        * 即时任务记录
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Taskimmediately,
  service: TaskimmediatelyService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Taskimmediately,
  //   service: TaskimmediatelyService,
})
export class TaskimmediatelyController extends DataController {
  @Inject()
  taskimmediatelyService: TaskimmediatelyService;
  
  //   @Inject()
  //   taskimmediatelyService: TaskimmediatelyService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/taskmonitor.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Taskmonitor } from '../../entity/taskmonitor';
import { TaskmonitorService } from '../../service/taskmonitor';
// import { TaskmonitorService } from '../../service/taskmonitor';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测任务
        */
        * 监测任务
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Taskmonitor,
  service: TaskmonitorService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Taskmonitor,
  //   service: TaskmonitorService,
})
export class TaskmonitorController extends DataController {
  @Inject()
  taskmonitorService: TaskmonitorService;
  
  //   @Inject()
  //   taskmonitorService: TaskmonitorService;

  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/controller/admin/trubinelocation.ts

@@ -1,7 +1,7 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Trubinelocation } from '../../entity/trubinelocation';
import { TrubinelocationService } from '../../service/trubinelocation';
// import { TrubinelocationService } from '../../service/trubinelocation';
import { DataController } from '../../../base/controller/dataController';
/**
        * 斗轮机信息
@@ -10,11 +10,11 @@
@CoolController({
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Trubinelocation,
  service: TrubinelocationService,
  // service: TrubinelocationService,
})
export class TrubinelocationController extends DataController {
  @Inject()
  trubinelocationService: TrubinelocationService;
  // @Inject()
  // trubinelocationService: TrubinelocationService;

  /**
  * 获得数据

 src/app/modules/business/controller/admin/tuser.ts

@@ -1,33 +1,33 @@
import { ALL, Body, Get, Inject, Post, Provide, Query } from '@midwayjs/decorator';
import { CoolController, BaseController } from '@cool-midway/core';
import { Tuser } from '../../entity/tuser';
import { TuserService } from '../../service/tuser';
// import { TuserService } from '../../service/tuser';
import { DataController } from '../../../base/controller/dataController';
/**
        * 
        */
        * 
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list','page','info'],
  entity: Tuser,
  service: TuserService,
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Tuser,
  //   service: TuserService,
})
export class TuserController extends DataController {
  @Inject()
  tuserService: TuserService;
  
  //   @Inject()
  //   tuserService: TuserService;
  //   
  /**
  * 获得数据
  */
   @Get('/getdata', { summary: '数据接口' })
   async getData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/getdata', { summary: '数据接口' })
  async getData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
  /**
  * 获得数据
  */
   @Get('/postdata', { summary: '数据接口' })
   async postData(@Query(ALL) params: any) {
      return this.ok(await this.dataService.getData(params));
   }
  @Get('/postdata', { summary: '数据接口' })
  async postData(@Query(ALL) params: any) {
    return this.ok(await this.dataService.getData(params));
  }
}

 src/app/modules/business/service/basedeviceinfo.ts

File was deleted

 src/app/modules/business/service/basedeviceparams.ts

File was deleted

 src/app/modules/business/service/basedevicesection.ts

File was deleted

 src/app/modules/business/service/basedevicestatus.ts

File was deleted

 src/app/modules/business/service/colletdata.ts

File was deleted

 src/app/modules/business/service/colletmeta.ts

File was deleted

 src/app/modules/business/service/comconfig.ts

File was deleted

 src/app/modules/business/service/deviceattachment.ts

File was deleted

 src/app/modules/business/service/devicegroup.ts

File was deleted

 src/app/modules/business/service/deviceinfo.ts

New file
@@ -0,0 +1,28 @@
import { Provide } from '@midwayjs/decorator';
import { BaseService } from '@cool-midway/core';
import { InjectEntityModel } from '@midwayjs/orm';
import { Repository } from 'typeorm';
import { Basedeviceinfo } from '../entity/basedeviceinfo';
import { Devicegroup } from '../entity/devicegroup';

/**
 * 描述
 */
@Provide()
export class BaseDeviceService extends BaseService {
  @InjectEntityModel(Basedeviceinfo)
  Basedeviceinfo: Repository<Basedeviceinfo>;
  @InjectEntityModel(Devicegroup)
  Devicegroup: Repository<Devicegroup>;

  /**
   * 描述
   */
  async add(param: any) {
    console.log(param, "dddddddd")
    const { logic_id } = param
    const devicegroup = this.Devicegroup
    await this.Devicegroup.insert(param)
    return await super.add(param)
  }
}

 src/app/modules/business/service/deviceopreraterecord.ts

File was deleted

 src/app/modules/business/service/doutrubine.ts

File was deleted

 src/app/modules/business/service/execrecord.ts

File was deleted

 src/app/modules/business/service/interfacelist.ts

File was deleted

 src/app/modules/business/service/interfacerecord.ts

File was deleted

 src/app/modules/business/service/messagerecord.ts

File was deleted

 src/app/modules/business/service/metadata.ts

File was deleted

 src/app/modules/business/service/modelcombination.ts

File was deleted

 src/app/modules/business/service/modelstatic.ts

File was deleted

 src/app/modules/business/service/periodicsetting.ts

File was deleted

 src/app/modules/business/service/planinventory.ts

File was deleted

 src/app/modules/business/service/pointcloud.ts

File was deleted

 src/app/modules/business/service/pointmodel.ts

File was deleted

 src/app/modules/business/service/statdata.ts

File was deleted

 src/app/modules/business/service/taskimmediately.ts

File was deleted

 src/app/modules/business/service/taskmonitor.ts

File was deleted

 src/app/modules/business/service/trubinelocation.ts

File was deleted

 src/app/modules/business/service/tuser.ts

File was deleted