add page info API

master

2022-03-23 6623f5db84d0b21e673cb51e6add066c71183b42

add page info API

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

@@ -4,30 +4,30 @@
import { BasedeviceinfoService } from '../../service/basedeviceinfo';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备信息
        */
        * 设备信息
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Basedeviceinfo,
  service: BasedeviceinfoService,
@CoolController({
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Basedeviceinfo,
  service: BasedeviceinfoService,
})
export class BasedeviceinfoController extends DataController {
  @Inject()
  basedeviceinfoService: BasedeviceinfoService;
  
  @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

@@ -4,30 +4,30 @@
import { BasedeviceparamsService } from '../../service/basedeviceparams';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备参数
        */
        * 设备参数
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Basedeviceparams,
  service: BasedeviceparamsService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { BasedevicesectionService } from '../../service/basedevicesection';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备组件
        */
        * 设备组件
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Basedevicesection,
  service: BasedevicesectionService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { BasedevicestatusService } from '../../service/basedevicestatus';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备状态
        */
        * 设备状态
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Basedevicestatus,
  service: BasedevicestatusService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { ColletdataService } from '../../service/colletdata';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测元数据
        */
        * 监测元数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Colletdata,
  service: ColletdataService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { ColletmetaService } from '../../service/colletmeta';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测元数据
        */
        * 监测元数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Colletmeta,
  service: ColletmetaService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { ComconfigService } from '../../service/comconfig';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测元数据
        */
        * 监测元数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Comconfig,
  service: ComconfigService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { DeviceattachmentService } from '../../service/deviceattachment';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备相关的附件
        */
        * 设备相关的附件
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Deviceattachment,
  service: DeviceattachmentService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { DevicegroupService } from '../../service/devicegroup';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备分组
        */
        * 设备分组
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Devicegroup,
  service: DevicegroupService,
@CoolController({
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Devicegroup,
  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.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/deviceopreraterecord.ts

@@ -4,30 +4,30 @@
import { DeviceopreraterecordService } from '../../service/deviceopreraterecord';
import { DataController } from '../../../base/controller/dataController';
/**
        * 设备运维记录
        */
        * 设备运维记录
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Deviceopreraterecord,
  service: DeviceopreraterecordService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { DoutrubineService } from '../../service/doutrubine';
import { DataController } from '../../../base/controller/dataController';
/**
        * 斗轮机信息
        */
        * 斗轮机信息
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Doutrubine,
  service: DoutrubineService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { ExecrecordService } from '../../service/execrecord';
import { DataController } from '../../../base/controller/dataController';
/**
        * 任务执行记录
        */
        * 任务执行记录
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Execrecord,
  service: ExecrecordService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { InterfacelistService } from '../../service/interfacelist';
import { DataController } from '../../../base/controller/dataController';
/**
        * 接口清单
        */
        * 接口清单
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Interfacelist,
  service: InterfacelistService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { InterfacerecordService } from '../../service/interfacerecord';
import { DataController } from '../../../base/controller/dataController';
/**
        * 组合模型
        */
        * 组合模型
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Interfacerecord,
  service: InterfacerecordService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { MessagerecordService } from '../../service/messagerecord';
import { DataController } from '../../../base/controller/dataController';
/**
        * 任务消息记录
        */
        * 任务消息记录
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Messagerecord,
  service: MessagerecordService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { MetadataService } from '../../service/metadata';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测采集原数据
        */
        * 监测采集原数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Metadata,
  service: MetadataService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { ModelcombinationService } from '../../service/modelcombination';
import { DataController } from '../../../base/controller/dataController';
/**
        * 组合模型
        */
        * 组合模型
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Modelcombination,
  service: ModelcombinationService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { ModelstaticService } from '../../service/modelstatic';
import { DataController } from '../../../base/controller/dataController';
/**
        * 静态模型数据
        */
        * 静态模型数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Modelstatic,
  service: ModelstaticService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { PeriodicsettingService } from '../../service/periodicsetting';
import { DataController } from '../../../base/controller/dataController';
/**
        * 分组任务参数设置
        */
        * 分组任务参数设置
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Periodicsetting,
  service: PeriodicsettingService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { PlaninventoryService } from '../../service/planinventory';
import { DataController } from '../../../base/controller/dataController';
/**
        * 盘煤计划
        */
        * 盘煤计划
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Planinventory,
  service: PlaninventoryService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { PointcloudService } from '../../service/pointcloud';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测元数据
        */
        * 监测元数据
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Pointcloud,
  service: PointcloudService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { PointmodelService } from '../../service/pointmodel';
import { DataController } from '../../../base/controller/dataController';
/**
        * 点云模型
        */
        * 点云模型
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Pointmodel,
  service: PointmodelService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { StatdataService } from '../../service/statdata';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测统计
        */
        * 监测统计
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Statdata,
  service: StatdataService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { TaskimmediatelyService } from '../../service/taskimmediately';
import { DataController } from '../../../base/controller/dataController';
/**
        * 即时任务记录
        */
        * 即时任务记录
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Taskimmediately,
  service: TaskimmediatelyService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { TaskmonitorService } from '../../service/taskmonitor';
import { DataController } from '../../../base/controller/dataController';
/**
        * 监测任务
        */
        * 监测任务
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Taskmonitor,
  service: TaskmonitorService,
@CoolController({
  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

@@ -4,30 +4,30 @@
import { TrubinelocationService } from '../../service/trubinelocation';
import { DataController } from '../../../base/controller/dataController';
/**
        * 斗轮机信息
        */
        * 斗轮机信息
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Trubinelocation,
  service: TrubinelocationService,
@CoolController({
  api: ['add', 'delete', 'update', 'list', 'page', 'info'],
  entity: Trubinelocation,
  service: TrubinelocationService,
})
export class TrubinelocationController extends DataController {
  @Inject()
  trubinelocationService: TrubinelocationService;
  
  @Inject()
  trubinelocationService: TrubinelocationService;

  /**
  * 获得数据
  */
   @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/tuser.ts

@@ -4,30 +4,30 @@
import { TuserService } from '../../service/tuser';
import { DataController } from '../../../base/controller/dataController';
/**
        * 
        */
        * 
        */
@Provide()
@CoolController({ 
  api: ['add', 'delete', 'update', 'list'],
  entity: Tuser,
  service: TuserService,
@CoolController({
  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));
  }
}