XuqmGroup-Server/tenant-service/src/main/java/com/xuqm/tenant/controller/OpsController.java

package com.xuqm.tenant.controller;

import com.xuqm.common.model.ApiResponse;
import com.xuqm.tenant.entity.AppEntity;
import com.xuqm.tenant.entity.FeatureServiceEntity;
import com.xuqm.tenant.entity.OperationLogEntity;
import com.xuqm.tenant.entity.ServiceActivationRequestEntity;
import com.xuqm.tenant.dto.ServiceRequestView;
import com.xuqm.tenant.entity.TenantEntity;
import com.xuqm.tenant.service.FeatureServiceManager;
import com.xuqm.tenant.entity.RiskConfigEntity;
import com.xuqm.tenant.entity.SensitiveWordEntity;
import com.xuqm.tenant.service.OpsService;
import com.xuqm.tenant.service.OpsPushDiagnosticsClient;
import com.xuqm.tenant.service.LicenseServiceClient;
import com.xuqm.tenant.service.RiskControlService;
import org.springframework.data.domain.Page;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
@RequestMapping
public class OpsController {

    private final OpsService opsService;
    private final FeatureServiceManager featureServiceManager;
    private final RiskControlService riskControlService;
    private final OpsPushDiagnosticsClient pushDiagnosticsClient;
    private final LicenseServiceClient licenseServiceClient;

    public OpsController(OpsService opsService, FeatureServiceManager featureServiceManager,
                         RiskControlService riskControlService,
                         OpsPushDiagnosticsClient pushDiagnosticsClient,
                         LicenseServiceClient licenseServiceClient) {
        this.opsService = opsService;
        this.featureServiceManager = featureServiceManager;
        this.riskControlService = riskControlService;
        this.pushDiagnosticsClient = pushDiagnosticsClient;
        this.licenseServiceClient = licenseServiceClient;
    }

    @PostMapping("/api/auth/ops/login")
    public ResponseEntity<ApiResponse<Map<String, String>>> opsLogin(@RequestBody Map<String, String> body) {
        String token = opsService.login(body.get("username"), body.get("password"));
        return ResponseEntity.ok(ApiResponse.success(Map.of("token", token)));
    }

    @GetMapping("/api/ops/tenants")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> listTenants(
            @RequestParam(defaultValue = "") String keyword,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        Page<TenantEntity> result = opsService.listTenants(keyword, page, size);
        return ResponseEntity.ok(ApiResponse.success(Map.of(
                "content", result.getContent(),
                "total", result.getTotalElements(),
                "totalPages", result.getTotalPages()
        )));
    }

    @PostMapping("/api/ops/tenants/{id}/toggle-status")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Void>> toggleStatus(@PathVariable String id) {
        opsService.toggleStatus(id);
        return ResponseEntity.ok(ApiResponse.ok());
    }

    @GetMapping("/api/ops/tenants/{id}")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> getTenantDetail(@PathVariable String id) {
        return ResponseEntity.ok(ApiResponse.success(opsService.getTenantDetail(id)));
    }

    @GetMapping("/api/ops/tenants/{id}/apps")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<java.util.List<AppEntity>>> listTenantApps(@PathVariable String id) {
        return ResponseEntity.ok(ApiResponse.success(opsService.listTenantApps(id)));
    }

    @GetMapping("/api/ops/statistics")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> statistics() {
        return ResponseEntity.ok(ApiResponse.success(opsService.statistics()));
    }

    @GetMapping("/api/ops/service-requests")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> listServiceRequests(
            @RequestParam(required = false) String status,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        Page<ServiceRequestView> result = opsService.listServiceRequests(status, page, size);
        return ResponseEntity.ok(ApiResponse.success(Map.of(
                "content", result.getContent(),
                "total", result.getTotalElements(),
                "totalPages", result.getTotalPages()
        )));
    }

    @PostMapping("/api/ops/service-requests/{requestId}/approve")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<ServiceActivationRequestEntity>> approveRequest(
            @PathVariable String requestId,
            @RequestBody(required = false) Map<String, String> body) {
        String reviewNote = body != null ? body.getOrDefault("reviewNote", "") : "";
        String expiresAt = body != null ? body.get("expiresAt") : null;
        return ResponseEntity.ok(ApiResponse.success(
                featureServiceManager.approveRequest(requestId, reviewNote, expiresAt)));
    }

    @PostMapping("/api/ops/service-requests/{requestId}/reject")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<ServiceActivationRequestEntity>> rejectRequest(
            @PathVariable String requestId,
            @RequestBody(required = false) Map<String, String> body) {
        String reviewNote = body != null ? body.getOrDefault("reviewNote", "") : "";
        return ResponseEntity.ok(ApiResponse.success(
                featureServiceManager.rejectRequest(requestId, reviewNote)));
    }

    @GetMapping("/api/ops/apps")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> listApps(
            @RequestParam(defaultValue = "") String keyword,
            @RequestParam(required = false) String tenantId,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        Page<Map<String, Object>> result = opsService.listApps(keyword, tenantId, page, size);
        return ResponseEntity.ok(ApiResponse.success(Map.of(
                "content", result.getContent(),
                "total", result.getTotalElements(),
                "totalPages", result.getTotalPages()
        )));
    }

    @GetMapping("/api/ops/apps/{appKey}")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> getAppDetail(@PathVariable String appKey) {
        return ResponseEntity.ok(ApiResponse.success(opsService.getAppDetail(appKey)));
    }

    @GetMapping("/api/ops/apps/{appKey}/services")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<java.util.List<FeatureServiceEntity>>> listAppServices(@PathVariable String appKey) {
        return ResponseEntity.ok(ApiResponse.success(opsService.listAppServices(appKey)));
    }

    @PostMapping("/api/ops/apps/{appKey}/transfer")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Void>> transferApp(
            @PathVariable String appKey,
            @RequestBody Map<String, String> body) {
        String targetTenantId = body.get("targetTenantId");
        if (targetTenantId == null || targetTenantId.isBlank()) {
            return ResponseEntity.badRequest().body(ApiResponse.badRequest("targetTenantId is required"));
        }
        opsService.transferApp(appKey, targetTenantId);
        return ResponseEntity.ok(ApiResponse.ok());
    }

    @GetMapping("/api/ops/operation-logs")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> listOperationLogs(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        Page<OperationLogEntity> result = opsService.listOperationLogs(page, size);
        return ResponseEntity.ok(ApiResponse.success(Map.of(
                "content", result.getContent(),
                "total", result.getTotalElements(),
                "totalPages", result.getTotalPages()
        )));
    }

    @GetMapping("/api/ops/push/search")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> searchPushByToken(
            @RequestParam String token,
            @RequestParam(required = false) String appKey) {
        return ResponseEntity.ok(ApiResponse.success(pushDiagnosticsClient.searchByToken(token, appKey)));
    }

    @GetMapping("/api/ops/push/device-logs")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> pushDeviceLogs(
            @RequestParam String appKey,
            @RequestParam String userId,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        return ResponseEntity.ok(ApiResponse.success(pushDiagnosticsClient.deviceLogs(appKey, userId, page, size)));
    }

    @PostMapping("/api/ops/push/test-offline")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> sendPushTestOffline(@RequestBody Map<String, String> body) {
        return ResponseEntity.ok(ApiResponse.success(pushDiagnosticsClient.sendTestOffline(
                body.get("appKey"),
                body.get("userId"),
                body.getOrDefault("title", "XuqmGroup Push 测试"),
                body.getOrDefault("body", "这是一条离线推送测试消息"),
                body.getOrDefault("payload", "{}"))));
    }

    /* ---------- License 管理 ---------- */
    @GetMapping("/api/ops/apps/{appKey}/license")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> getAppLicense(@PathVariable String appKey) {
        return ResponseEntity.ok(ApiResponse.success(licenseServiceClient.getAppLicenseStatus(appKey)));
    }

    @PutMapping("/api/ops/apps/{appKey}/license/max-devices")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Void>> updateMaxDevices(
            @PathVariable String appKey,
            @RequestBody Map<String, Object> body) {
        Object maxDevicesObj = body.get("maxDevices");
        if (maxDevicesObj == null) {
            throw new com.xuqm.common.exception.BusinessException(400, "最大设备数不能为空");
        }
        int maxDevices;
        if (maxDevicesObj instanceof Number n) {
            maxDevices = n.intValue();
        } else {
            maxDevices = Integer.parseInt(maxDevicesObj.toString());
        }
        if (maxDevices < 1) {
            throw new com.xuqm.common.exception.BusinessException(400, "最大设备数必须大于0");
        }
        licenseServiceClient.updateMaxDevices(appKey, maxDevices);
        return ResponseEntity.ok(ApiResponse.ok());
    }

    /* ---------- 风控配置 ---------- */
    @GetMapping("/api/ops/risk/rules")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<RiskConfigEntity>> getRiskConfig() {
        return ResponseEntity.ok(ApiResponse.success(riskControlService.getConfig()));
    }

    @PostMapping("/api/ops/risk/rules")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<RiskConfigEntity>> saveRiskConfig(@RequestBody RiskConfigEntity req) {
        return ResponseEntity.ok(ApiResponse.success(riskControlService.saveConfig(req)));
    }

    /* ---------- 敏感词 ---------- */
    @GetMapping("/api/ops/risk/sensitive-words")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Map<String, Object>>> listSensitiveWords(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        Page<SensitiveWordEntity> result = riskControlService.listWords(page, size);
        return ResponseEntity.ok(ApiResponse.success(Map.of(
                "content", result.getContent(),
                "total", result.getTotalElements(),
                "totalPages", result.getTotalPages()
        )));
    }

    @PostMapping("/api/ops/risk/sensitive-words")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<SensitiveWordEntity>> createSensitiveWord(@RequestBody SensitiveWordEntity req) {
        return ResponseEntity.ok(ApiResponse.success(riskControlService.createWord(req)));
    }

    @PutMapping("/api/ops/risk/sensitive-words/{id}")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<SensitiveWordEntity>> updateSensitiveWord(
            @PathVariable String id, @RequestBody SensitiveWordEntity req) {
        return ResponseEntity.ok(ApiResponse.success(riskControlService.updateWord(id, req)));
    }

    @PatchMapping("/api/ops/risk/sensitive-words/{id}/toggle")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Void>> toggleSensitiveWord(
            @PathVariable String id, @RequestParam boolean enabled) {
        riskControlService.toggleWord(id, enabled);
        return ResponseEntity.ok(ApiResponse.ok());
    }

    @DeleteMapping("/api/ops/risk/sensitive-words/{id}")
    @PreAuthorize("hasAuthority('ROLE_OPS')")
    public ResponseEntity<ApiResponse<Void>> deleteSensitiveWord(@PathVariable String id) {
        riskControlService.deleteWord(id);
        return ResponseEntity.ok(ApiResponse.ok());
    }
}