微信小程序接入美团、抖音团购核销实战：从门店授权到核销与撤销

String createStore(String localStoreId, String shopName, String masterShopId)
        throws IOException, InterruptedException {
    business.requireStoreAdmin(localStoreId);
    boolean firstStore = masterShopId == null || masterShopId.isBlank();
    ObjectNode request = json.createObjectNode().put("shopName", shopName);
    if (!firstStore) {
        request.put("masterShopId", masterShopId);
    }
    JsonNode data = postJson("store/create", request.toString()).requireData();
    String shopId = data.path("shopId").asText();
    String parentId = firstStore ? data.path("parentShopId").asText() : masterShopId;
    if (shopId.isBlank() || parentId.isBlank()) {
        throw new IllegalStateException("Missing store identifiers");
    }
    business.saveStoreMapping(localStoreId, shopId, parentId);
    return shopId;
}

String authorizationUrl(String localStoreId, int platform)
        throws IOException, InterruptedException {
    business.requireStoreAdmin(localStoreId);
    String shopId = business.shopId(localStoreId);
    ObjectNode request = json.createObjectNode()
            .put("shopId", shopId).put("platform", platform);
    JsonNode data = postJson("get/auth/url", request.toString()).requireData();
    if (!data.isTextual() || data.textValue().isBlank()) {
        throw new IllegalStateException("Missing authorization URL");
    }
    return data.textValue(); // 展示给商家；授权完成后另行核对门店和状态
}

private final ObjectMapper json = new ObjectMapper();
private final HttpClient http = HttpClient.newHttpClient();
private String apiKey; // 从自己的服务端配置注入，不放进小程序

static final class ApiResponse {
    final int httpStatus;
    final JsonNode body;
    ApiResponse(int httpStatus, JsonNode body) {
        this.httpStatus = httpStatus;
        this.body = body;
    }
    boolean isSuccess() {
        return body.path("success").isBoolean() && body.path("success").booleanValue();
    }
    JsonNode requireData() {
        if (!isSuccess()) throw new IllegalStateException("API result requires handling");
        return body.path("data");
    }
}

ApiResponse postJson(String path, String requestJson)
        throws IOException, InterruptedException {
    HttpRequest request = HttpRequest.newBuilder(URI.create(
            "https://newopen.elys.cn/api/hexiao/v2/" + path))
            .timeout(Duration.ofSeconds(10)) // 本例的客户端超时设置
            .header("Authorization", "Bearer " + apiKey)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(requestJson)).build();
    HttpResponse<String> response = http.send(request, HttpResponse.BodyHandlers.ofString());
    JsonNode body;
    try {
        body = json.readTree(response.body());
    } catch (JsonProcessingException e) {
        body = NullNode.getInstance(); // 保留 HTTP 状态，由调用处分类
    }
    return new ApiResponse(response.statusCode(), body == null ? NullNode.getInstance() : body);
}

void configureProduct(String localStoreId, int platform, int page, int pageSize,
                      String selectedDealId, String benefitId)
        throws IOException, InterruptedException {
    business.requireStoreAdmin(localStoreId);
    String shopId = business.shopId(localStoreId);
    ObjectNode request = json.createObjectNode().put("shopId", shopId)
            .put("platform", platform).put("offset", page).put("limit", pageSize);
    JsonNode deals = postJson("ddzh-tuangou-deal-queryshopdeal", request.toString()).requireData();
    for (JsonNode deal : deals) {
        if (selectedDealId.equals(deal.path("dealId").asText())) {
            business.saveProductMapping(platform, shopId, selectedDealId, benefitId);
            return;
        }
    }
    throw new IllegalArgumentException("Selected product is not in this page");
}

ObjectNode prepare(String localStoreId, int platform, String code, int num)
        throws IOException, InterruptedException {
    String userId = business.requireUserAccess(localStoreId);
    String shopId = business.shopId(localStoreId);
    if (num <= 0) throw new IllegalArgumentException("Invalid quantity");
    ObjectNode request = json.createObjectNode().put("shopId", shopId)
            .put("platform", platform).put("code", code);
    JsonNode data = postJson("ddzh-tuangou-receipt-prepare", request.toString()).requireData();
    String productId = adapter.productId(platform, data.deepCopy());
    if (productId == null || productId.isBlank()) {
        throw new IllegalStateException("Product needs review");
    }
    String benefitId = business.findBenefit(platform, shopId, productId);
    if (benefitId == null) throw new IllegalStateException("Configure product mapping first");
    String ticketInfo = data.path("ticketInfo").textValue();
    if (ticketInfo == null || ticketInfo.isEmpty() || !data.path("payAmount").isNumber()) {
        throw new IllegalStateException("Incomplete prepare response");
    }
    ObjectNode consumeRequest = request.deepCopy().put("num", num).put("ticketInfo", ticketInfo);
    String contextId = business.savePending(userId, consumeRequest.toString(), benefitId);
    return json.createObjectNode().put("contextId", contextId)
            .put("ticketName", data.path("ticketName").asText()).put("benefitId", benefitId)
            .put("payAmountYuan", data.path("payAmount").decimalValue().movePointLeft(2));
}

enum FailureKind { REJECTED, CONFIG_ERROR, RETRYABLE, UNKNOWN, REVIEW }

void consume(String contextId) throws InterruptedException {
    PreparedRedemption context = business.loadOwnedPending(contextId);
    if (business.hasSuccess(context.id())) return;
    final String requestJson = context.requestJson(); // 循环前固定，逐字复用
    ApiResponse last = null;
    for (int attempt = 0; attempt < 3; attempt++) {
        if (attempt > 0) Thread.sleep(500L * attempt); // 本例的有限串行退避
        ApiResponse reply;
        try {
            reply = postJson("ddzh-tuangou-receipt-consume", requestJson);
        } catch (IOException e) { // 包含 HttpTimeoutException；不捕获本地履约异常
            continue;
        }
        last = reply;
        if (reply.isSuccess()) {
            saveFirstSuccess(context, reply.body); // 在网络重试的 catch 之外
            return;
        }
        if (reply.body.path("code").asInt() == 10500) {
            business.markPending(context.id(), reply.body.deepCopy());
            return; // 缺少首次成功记录时，不凭已核销提示发权益
        }
        switch (errors.classify(reply)) {
            case REJECTED:
            case CONFIG_ERROR:
                business.stopAttempt(context.id(), reply.body.deepCopy());
                return;
            case RETRYABLE:
            case UNKNOWN:
                break;
            default:
                business.markPending(context.id(), reply.body.deepCopy());
                return;
        }
    }
    business.markPending(context.id(), last == null ? NullNode.getInstance() : last.body.deepCopy());
}

void saveFirstSuccess(PreparedRedemption context, JsonNode response) {
    // 保存完整首次响应：data、consumeCredential、关联号，以及上下文中的原请求
    Receipt receipt = business.saveFirstSuccess(context, response.deepCopy());
    try {
        business.grantOnce(receipt.id(), context.benefitId());
        business.markFulfilled(receipt.id());
    } catch (RuntimeException e) {
        business.enqueueFulfillment(receipt.id()); // 只补处理自己的权益
    }
}

void cancel(String receiptId) throws InterruptedException {
    Receipt receipt = business.loadCancellableOwned(receiptId); // 校验归属及权益可撤回
    List<String> credentials = business.selectedOriginalCredentials(receipt);
    if (credentials.isEmpty()) throw new IllegalStateException("No original credentials");
    ObjectNode request = json.createObjectNode().put("shopId", receipt.shopId())
            .put("platform", receipt.platform());
    ArrayNode values = request.putArray("consumeCredential");
    credentials.forEach(values::add);
    ApiResponse reply;
    try {
        reply = postJson("ddzh-tuangou-receipt-cancel", request.toString());
    } catch (IOException e) {
        for (String credential : credentials) business.markCancellationPending(receiptId, credential);
        return;
    }
    Map<String, JsonNode> items = new HashMap<>();
    if (reply.body.path("data").isArray()) {
        for (JsonNode item : reply.body.path("data")) {
            items.put(item.path("consumeCredential").asText(), item);
        }
    }
    for (String credential : credentials) {
        JsonNode item = items.get(credential);
        String status = item == null ? "unknown" : item.path("status").asText("unknown");
        switch (status) {
            case "succeeded":
                business.saveCancellationSucceeded(receiptId, credential);
                try {
                    business.revokeOnce(receiptId, credential);
                } catch (RuntimeException e) {
                    business.enqueueRevocation(receiptId, credential);
                }
                break;
            case "rejected":
                business.recordCancellationRejected(receiptId, credential, item.path("message").asText());
                break;
            case "unknown":
            default:
                business.markCancellationPending(receiptId, credential);
        }
    }
}