productDev/dmvisit.git

package com.doumee.cloud.admin;
 
import com.doumee.api.BaseController;
import com.doumee.config.annotation.CloudRequiredPermission;
import com.doumee.core.annotation.pr.PreventRepeat;
import com.doumee.core.utils.Constants;
import com.doumee.dao.admin.request.CollectionMediaSyncRequest;
import com.doumee.dao.admin.request.DeliverySnapshotManualRequest;
import com.doumee.dao.business.model.CollectionMedia;
import com.doumee.dao.business.model.CollectionDockDevice;
import com.doumee.dao.business.model.CollectionStation;
import com.doumee.dao.business.model.DeliveryMediaSnapshot;
import com.doumee.service.business.CollectionMediaSyncService;
import com.doumee.service.business.CollectionStationService;
import com.doumee.service.business.DeliverySnapshotService;
import com.doumee.service.business.third.model.ApiResponse;
import com.doumee.service.business.third.model.PageData;
import com.doumee.service.business.third.model.PageWrap;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
import java.util.ArrayList;
import java.util.List;
 
@Api(tags = "海康采集站")
@RestController
@RequestMapping(Constants.CLOUD_SERVICE_URL_INDEX + "/business/collectionStation")
public class CollectionStationCloudController extends BaseController {
 
    @Autowired
    private CollectionStationService collectionStationService;
    @Autowired
    private CollectionMediaSyncService collectionMediaSyncService;
    @Autowired
    private DeliverySnapshotService deliverySnapshotService;
 
    @PreventRepeat
    @ApiOperation("新建采集站")
    @PostMapping("/create")
    @CloudRequiredPermission("business:collectionStation:create")
    public ApiResponse<Integer> create(@RequestBody CollectionStation station,
                                       @RequestHeader(Constants.HEADER_USER_TOKEN) String token) {
        station.setLoginUserInfo(getLoginUser(token));
        return ApiResponse.success(collectionStationService.create(station));
    }
 
    @ApiOperation("根据ID删除采集站")
    @GetMapping("/delete/{id}")
    @CloudRequiredPermission("business:collectionStation:delete")
    public ApiResponse<Void> deleteById(@PathVariable Integer id,
                                        @RequestHeader(Constants.HEADER_USER_TOKEN) String token) {
        collectionStationService.deleteById(id, getLoginUser(token));
        return ApiResponse.success(null);
    }
 
    @ApiOperation("批量删除采集站")
    @GetMapping("/delete/batch")
    @CloudRequiredPermission("business:collectionStation:delete")
    public ApiResponse<Void> deleteByIdInBatch(@RequestParam String ids,
                                               @RequestHeader(Constants.HEADER_USER_TOKEN) String token) {
        String[] idArray = ids.split(",");
        List<Integer> idList = new ArrayList<>();
        for (String id : idArray) {
            idList.add(Integer.valueOf(id));
        }
        collectionStationService.deleteByIdInBatch(idList, getLoginUser(token));
        return ApiResponse.success(null);
    }
 
    @ApiOperation("修改采集站")
    @PostMapping("/updateById")
    @CloudRequiredPermission("business:collectionStation:update")
    public ApiResponse<Void> updateById(@RequestBody CollectionStation station,
                                        @RequestHeader(Constants.HEADER_USER_TOKEN) String token) {
        station.setLoginUserInfo(getLoginUser(token));
        collectionStationService.updateById(station);
        return ApiResponse.success(null);
    }
 
    @ApiOperation("分页查询采集站")
    @PostMapping("/page")
    @CloudRequiredPermission("business:collectionStation:query")
    public ApiResponse<PageData<CollectionStation>> findPage(@RequestBody PageWrap<CollectionStation> pageWrap,
                                                             @RequestHeader(Constants.HEADER_USER_TOKEN) String token) {
        return ApiResponse.success(collectionStationService.findPage(pageWrap));
    }
 
    @ApiOperation("查询全部采集站")
    @PostMapping("/list")
    @CloudRequiredPermission("business:collectionStation:query")
    public ApiResponse<List<CollectionStation>> findList(@RequestBody CollectionStation model,
                                                         @RequestHeader(Constants.HEADER_USER_TOKEN) String token) {
        return ApiResponse.success(collectionStationService.findList(model));
    }
 
    @PreventRepeat
    @ApiOperation("同步所有采集站状态")
    @PostMapping("/syncDevices")
    @CloudRequiredPermission("business:collectionStation:sync")
    public ApiResponse<String> syncDevices() {
        return ApiResponse.success(collectionStationService.syncAllStations());
    }
 
    @PreventRepeat
    @ApiOperation("同步单个采集站状态")
    @PostMapping("/syncDevice/{id}")
    @CloudRequiredPermission("business:collectionStation:sync")
    public ApiResponse<String> syncDevice(@PathVariable Integer id) {
        return ApiResponse.success(collectionStationService.syncStationStatus(id));
    }
 
    @ApiOperation("ISAPI联调探测(返回原始XML/JSON)")
    @GetMapping("/probe/{id}")
    @CloudRequiredPermission("business:collectionStation:sync")
    public ApiResponse<String> probe(@PathVariable Integer id) {
        return ApiResponse.success(collectionStationService.probeIsapi(id));
    }
 
    @ApiOperation("查询采集站执法记录仪列表")
    @GetMapping("/dockDevices/{stationId}")
    @CloudRequiredPermission({"business:collectionDockDevice:query", "business:collectionStation:query"})
    public ApiResponse<List<CollectionDockDevice>> dockDevices(@PathVariable Integer stationId) {
        return ApiResponse.success(collectionStationService.findDockDevices(stationId));
    }
 
    @ApiOperation("分页查询执法记录仪")
    @PostMapping("/dockDevices/page")
    @CloudRequiredPermission({"business:collectionDockDevice:query", "business:collectionStation:query"})
    public ApiResponse<PageData<CollectionDockDevice>> findDockDevicePage(@RequestBody PageWrap<CollectionDockDevice> pageWrap,
                                                                          @RequestHeader(Constants.HEADER_USER_TOKEN) String token) {
        return ApiResponse.success(collectionStationService.findDockDevicePage(pageWrap));
    }
 
    @PreventRepeat
    @ApiOperation("同步媒体文件索引")
    @PostMapping("/syncMedia")
    @CloudRequiredPermission({"business:collectionMedia:sync", "business:collectionStation:sync"})
    public ApiResponse<String> syncMedia(@RequestBody CollectionMediaSyncRequest request) {
        return ApiResponse.success(collectionMediaSyncService.syncMediaList(request));
    }
 
    @PreventRepeat
    @ApiOperation("下载单个媒体文件")
    @PostMapping("/downloadMedia/{id}")
    @CloudRequiredPermission({"business:collectionMedia:download", "business:collectionStation:sync"})
    public ApiResponse<String> downloadMedia(@PathVariable Integer id) {
        return ApiResponse.success(collectionMediaSyncService.downloadMedia(id));
    }
 
    @PreventRepeat
    @ApiOperation("批量下载媒体文件")
    @PostMapping("/batchDownloadMedia")
    @CloudRequiredPermission({"business:collectionMedia:download", "business:collectionStation:sync"})
    public ApiResponse<String> batchDownloadMedia(@RequestBody CollectionMediaSyncRequest request) {
        return ApiResponse.success(collectionMediaSyncService.batchDownload(request));
    }
 
    @ApiOperation("分页查询媒体文件")
    @PostMapping("/media/page")
    @CloudRequiredPermission({"business:collectionMedia:query", "business:collectionStation:query"})
    public ApiResponse<PageData<CollectionMedia>> findMediaPage(@RequestBody PageWrap<CollectionMedia> pageWrap,
                                                               @RequestHeader(Constants.HEADER_USER_TOKEN) String token) {
        return ApiResponse.success(collectionMediaSyncService.findPage(pageWrap));
    }
 
    @ApiOperation("预览已下载媒体文件")
    @GetMapping("/media/preview/{id}")
    @CloudRequiredPermission({"business:collectionMedia:query", "business:collectionStation:query"})
    public void previewMedia(@PathVariable Integer id, javax.servlet.http.HttpServletRequest request,
                             javax.servlet.http.HttpServletResponse response) {
        collectionMediaSyncService.previewMedia(id, request, response);
    }
 
    @ApiOperation("下载已下载媒体文件到本地")
    @GetMapping("/media/download/{id}")
    @CloudRequiredPermission({"business:collectionMedia:query", "business:collectionStation:query"})
    public void downloadMediaFile(@PathVariable Integer id, javax.servlet.http.HttpServletRequest request,
                                  javax.servlet.http.HttpServletResponse response) {
        collectionMediaSyncService.downloadMediaFile(id, request, response);
    }
 
    @PreventRepeat
    @ApiOperation("提交媒体快照分析(门头/交付)")
    @PostMapping("/media/snapshot/analyze/{id}")
    @CloudRequiredPermission({"business:collectionMedia:query", "business:collectionStation:query"})
    public ApiResponse<String> analyzeMediaSnapshot(@PathVariable Integer id) {
        return ApiResponse.success(deliverySnapshotService.submitAnalyze(id));
    }
 
    @ApiOperation("查询媒体快照(门头/交付)")
    @GetMapping("/media/snapshot/{id}")
    @CloudRequiredPermission({"business:collectionMedia:query", "business:collectionStation:query"})
    public ApiResponse<List<DeliveryMediaSnapshot>> listMediaSnapshot(@PathVariable Integer id) {
        return ApiResponse.success(deliverySnapshotService.listByMediaId(id));
    }
 
    @PreventRepeat
    @ApiOperation("手动指定媒体快照时间点")
    @PostMapping("/media/snapshot/manual")
    @CloudRequiredPermission({"business:collectionMedia:query", "business:collectionStation:query"})
    public ApiResponse<String> saveManualMediaSnapshot(@RequestBody DeliverySnapshotManualRequest request) {
        return ApiResponse.success(deliverySnapshotService.saveManual(request));
    }
}