package com.talentcard.server.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.talentcard.server.business.BusinessIdGenerator;
|
import com.talentcard.server.business.DatabaseRows;
|
import com.talentcard.server.business.PageResult;
|
import com.talentcard.server.common.BusinessException;
|
import com.talentcard.server.common.ErrorCode;
|
import com.talentcard.server.entity.BenefitVerifyRecord;
|
import com.talentcard.server.entity.TransportCarWashCredential;
|
import com.talentcard.server.entity.TransportCarWashService;
|
import com.talentcard.server.mapper.BenefitVerifyRecordMapper;
|
import com.talentcard.server.mapper.TransportCarWashCredentialMapper;
|
import com.talentcard.server.mapper.TransportCarWashServiceMapper;
|
import com.talentcard.server.request.CarWashBenefitRuleRequest;
|
import com.talentcard.server.request.CarWashCredentialAuditRequest;
|
import com.talentcard.server.request.CarWashCredentialRollbackRequest;
|
import com.talentcard.server.request.CarWashCredentialSubmitRequest;
|
import org.springframework.dao.DuplicateKeyException;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import tools.jackson.core.type.TypeReference;
|
import tools.jackson.databind.ObjectMapper;
|
|
import java.time.DayOfWeek;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.temporal.TemporalAdjusters;
|
import java.util.ArrayList;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.Map;
|
|
@Service
|
public class CarWashBenefitManagementService {
|
private final TransportCarWashCredentialMapper credentialMapper;
|
private final TransportCarWashServiceMapper configMapper;
|
private final BenefitVerifyRecordMapper verifyRecordMapper;
|
private final ObjectMapper objectMapper;
|
|
public CarWashBenefitManagementService(TransportCarWashCredentialMapper credentialMapper,
|
TransportCarWashServiceMapper configMapper,
|
BenefitVerifyRecordMapper verifyRecordMapper,
|
ObjectMapper objectMapper) {
|
this.credentialMapper = credentialMapper;
|
this.configMapper = configMapper;
|
this.verifyRecordMapper = verifyRecordMapper;
|
this.objectMapper = objectMapper;
|
}
|
|
@Transactional
|
public Map<String, Object> saveRules(Long merchantId, CarWashBenefitRuleRequest request) {
|
requireMerchant(merchantId);
|
List<Map<String, Object>> rules = new ArrayList<>();
|
for (CarWashBenefitRuleRequest.Rule item : request.rules()) {
|
String cycle = normalizeCycle(item.resetCycle());
|
Map<String, Object> rule = new LinkedHashMap<>();
|
rule.put("cardLevel", item.cardLevel().trim());
|
rule.put("totalCount", item.totalCount());
|
rule.put("resetCycle", cycle);
|
rule.put("familyCardShared", Boolean.TRUE.equals(item.familyCardShared()));
|
rules.add(rule);
|
}
|
String json;
|
try {
|
json = objectMapper.writeValueAsString(rules);
|
} catch (Exception exception) {
|
throw new BusinessException(ErrorCode.INTERNAL_ERROR, "洗车权益次数配置保存失败");
|
}
|
TransportCarWashService config = configMapper.selectOne(new QueryWrapper<TransportCarWashService>()
|
.eq("merchant_id", merchantId).eq("deleted", 0).last("limit 1 for update"));
|
if (config == null) {
|
config = new TransportCarWashService();
|
config.setMerchantId(merchantId);
|
config.setBenefitRules(json);
|
config.setStatus(1);
|
config.setDeleted(0);
|
if (configMapper.insert(config) != 1) throw new BusinessException(ErrorCode.INTERNAL_ERROR, "洗车权益次数配置保存失败");
|
} else if (configMapper.update(null, new UpdateWrapper<TransportCarWashService>()
|
.set("benefit_rules", json).eq("id", config.getId()).eq("deleted", 0)) != 1) {
|
throw new BusinessException(ErrorCode.CONFLICT, "洗车权益配置已变化，请刷新后重试");
|
}
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("merchantId", merchantId);
|
result.put("rules", rules);
|
return result;
|
}
|
|
@Transactional(readOnly = true)
|
public Map<String, Object> rules(Long merchantId) {
|
requireMerchant(merchantId);
|
TransportCarWashService config = configMapper.selectOne(new QueryWrapper<TransportCarWashService>()
|
.eq("merchant_id", merchantId).eq("deleted", 0).last("limit 1"));
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("merchantId", merchantId);
|
result.put("rules", config == null ? List.of() : parseRules(config.getBenefitRules()));
|
return result;
|
}
|
|
@Transactional
|
public Map<String, Object> submit(Long merchantId, CarWashCredentialSubmitRequest request, String headerIdempotencyKey) {
|
requireMerchant(merchantId);
|
String key = first(request.idempotencyKey(), headerIdempotencyKey);
|
if (key.isBlank() || key.length() > 128) throw new BusinessException(ErrorCode.BAD_REQUEST, "提交凭证不能为空且长度不能超过128");
|
TransportCarWashCredential duplicate = credentialMapper.selectOne(new QueryWrapper<TransportCarWashCredential>()
|
.eq("idempotency_key", key).eq("deleted", 0).last("limit 1"));
|
if (duplicate != null) return detail(duplicate.getId());
|
Map<String, Object> source = DatabaseRows.normalize(credentialMapper.selectActiveCard(request.talentId(), request.cardId()));
|
if (source.isEmpty()) throw new BusinessException(ErrorCode.CONFLICT, "人才卡不存在或当前不可用");
|
Long primaryTalentId = request.talentId();
|
Long primaryCardId = request.cardId();
|
String cardLevel = text(source, "cardLevel");
|
String cardType = text(source, "cardType");
|
if (!"PERSONAL".equalsIgnoreCase(cardType)) {
|
Map<String, Object> primary = DatabaseRows.normalize(credentialMapper.selectPrimaryCard(request.cardId()));
|
if (primary.isEmpty()) throw new BusinessException(ErrorCode.CONFLICT, "亲属附属卡未找到有效主卡");
|
primaryTalentId = longValue(primary, "primaryTalentId");
|
primaryCardId = longValue(primary, "primaryCardId");
|
cardLevel = text(primary, "cardLevel");
|
}
|
List<String> files = request.proofFiles() == null ? List.of() : request.proofFiles().stream().map(this::clean).filter(v -> !v.isBlank()).distinct().toList();
|
for (String file : files) {
|
if (!(file.startsWith("/uploads/") || file.startsWith("https://"))) {
|
throw new BusinessException(ErrorCode.BAD_REQUEST, "凭证文件地址不正确");
|
}
|
}
|
TransportCarWashCredential credential = new TransportCarWashCredential();
|
credential.setCredentialNo(BusinessIdGenerator.next("CWC"));
|
credential.setMerchantId(merchantId);
|
credential.setTalentId(request.talentId());
|
credential.setCardId(request.cardId());
|
credential.setPrimaryTalentId(primaryTalentId);
|
credential.setPrimaryCardId(primaryCardId);
|
credential.setCardLevel(cardLevel);
|
credential.setProofFiles(writeJson(files));
|
credential.setDescription(trimToNull(request.description()));
|
credential.setConsumeTime(request.consumeTime());
|
credential.setStatus(0);
|
credential.setDeductedCount(0);
|
credential.setIdempotencyKey(key);
|
credential.setSubmittedAt(LocalDateTime.now());
|
credential.setDeleted(0);
|
try {
|
if (credentialMapper.insert(credential) != 1) throw new BusinessException(ErrorCode.INTERNAL_ERROR, "洗车凭证提交失败");
|
} catch (DuplicateKeyException exception) {
|
TransportCarWashCredential existing = credentialMapper.selectOne(new QueryWrapper<TransportCarWashCredential>()
|
.eq("idempotency_key", key).eq("deleted", 0).last("limit 1"));
|
if (existing != null) return detail(existing.getId());
|
throw exception;
|
}
|
return detail(credential.getId());
|
}
|
|
@Transactional(readOnly = true)
|
public PageResult<Map<String, Object>> page(Long merchantId, Integer status, String keyword,
|
LocalDate startDate, LocalDate endDate, int page, int size) {
|
validateStatus(status);
|
if (startDate != null && endDate != null && startDate.isAfter(endDate)) throw new BusinessException(ErrorCode.BAD_REQUEST, "开始日期不能晚于结束日期");
|
int safePage = Math.max(page, 1);
|
int safeSize = Math.min(Math.max(size, 1), 100);
|
LocalDateTime start = startDate == null ? null : startDate.atStartOfDay();
|
LocalDateTime end = endDate == null ? null : endDate.plusDays(1).atStartOfDay();
|
List<Map<String, Object>> records = DatabaseRows.normalize(credentialMapper.selectPage(
|
merchantId, status, clean(keyword), start, end, safeSize, (safePage - 1) * safeSize)).stream()
|
.map(this::view).toList();
|
Long total = credentialMapper.countPage(merchantId, status, clean(keyword), start, end);
|
return new PageResult<>(records, safePage, safeSize, total == null ? 0 : total);
|
}
|
|
@Transactional(readOnly = true)
|
public Map<String, Object> detail(Long id) {
|
Map<String, Object> row = credentialMapper.selectDetail(id);
|
if (row == null || row.isEmpty()) throw new BusinessException(ErrorCode.NOT_FOUND, "洗车凭证记录不存在");
|
return view(DatabaseRows.normalize(row));
|
}
|
|
@Transactional
|
public Map<String, Object> audit(Long id, CarWashCredentialAuditRequest request, Long operatorId) {
|
if (request.status() == null || (request.status() != 1 && request.status() != 2)) throw new BusinessException(ErrorCode.BAD_REQUEST, "审核状态只能为1通过或2驳回");
|
String remark = trimToNull(request.auditRemark());
|
if (request.status() == 2 && remark == null) throw new BusinessException(ErrorCode.BAD_REQUEST, "驳回时必须填写审核备注");
|
TransportCarWashCredential credential = credentialMapper.selectByIdForUpdate(id);
|
if (credential == null) throw new BusinessException(ErrorCode.NOT_FOUND, "洗车凭证记录不存在");
|
if (!Integer.valueOf(0).equals(credential.getStatus())) throw new BusinessException(ErrorCode.CONFLICT, "该洗车凭证已经审核");
|
int quantity = request.quantity() == null ? 1 : request.quantity();
|
if (quantity < 1 || quantity > 100) throw new BusinessException(ErrorCode.BAD_REQUEST, "扣减次数必须在1到100之间");
|
Long verifyId = null;
|
if (request.status() == 1) {
|
Rule rule = rule(credential.getMerchantId(), credential.getCardLevel(), !credential.getCardId().equals(credential.getPrimaryCardId()));
|
LocalDateTime windowStart = windowStart(rule.resetCycle());
|
long used = number(credentialMapper.countUsedQuota(credential.getPrimaryCardId(), windowStart)).longValue();
|
if (used + quantity > rule.totalCount()) throw new BusinessException(ErrorCode.CONFLICT, "洗车权益剩余次数不足");
|
BenefitVerifyRecord record = new BenefitVerifyRecord();
|
record.setVerifyNo(BusinessIdGenerator.next("CWV"));
|
record.setTalentId(credential.getPrimaryTalentId());
|
record.setCardId(credential.getPrimaryCardId());
|
record.setMerchantId(credential.getMerchantId());
|
record.setStaffId(operatorId);
|
record.setVerifyType("CAR_WASH");
|
record.setVerifyAmount((long) quantity);
|
record.setSubsidyAmount(0L);
|
record.setVerifyTime(LocalDateTime.now());
|
record.setRemark("洗车凭证人工审核通过：" + credential.getCredentialNo());
|
record.setStatus(1);
|
record.setIdempotencyKey("CAR_WASH_CREDENTIAL:" + credential.getId());
|
if (verifyRecordMapper.insert(record) != 1) throw new BusinessException(ErrorCode.INTERNAL_ERROR, "洗车权益扣减流水保存失败");
|
verifyId = record.getId();
|
} else {
|
quantity = 0;
|
}
|
credential.setStatus(request.status());
|
credential.setAuditBy(operatorId);
|
credential.setAuditTime(LocalDateTime.now());
|
credential.setAuditRemark(remark);
|
credential.setVerifyRecordId(verifyId);
|
credential.setDeductedCount(quantity);
|
if (credentialMapper.updateById(credential) != 1) throw new BusinessException(ErrorCode.CONFLICT, "洗车凭证状态已变化，请刷新后重试");
|
return detail(id);
|
}
|
|
@Transactional
|
public Map<String, Object> rollback(Long id, CarWashCredentialRollbackRequest request, Long operatorId) {
|
TransportCarWashCredential credential = credentialMapper.selectByIdForUpdate(id);
|
if (credential == null) throw new BusinessException(ErrorCode.NOT_FOUND, "洗车凭证记录不存在");
|
if (!Integer.valueOf(1).equals(credential.getStatus()) || credential.getVerifyRecordId() == null) throw new BusinessException(ErrorCode.CONFLICT, "仅审核通过且已扣减的凭证可以回滚");
|
int updated = verifyRecordMapper.update(null, new UpdateWrapper<BenefitVerifyRecord>()
|
.set("status", 0).set("revoked_at", LocalDateTime.now()).set("revoked_by", operatorId)
|
.set("revoke_reason", request.reason().trim())
|
.eq("id", credential.getVerifyRecordId()).eq("status", 1));
|
if (updated != 1) throw new BusinessException(ErrorCode.CONFLICT, "洗车权益流水已回滚，请刷新后重试");
|
credential.setStatus(3);
|
credential.setRollbackBy(operatorId);
|
credential.setRollbackTime(LocalDateTime.now());
|
credential.setRollbackReason(request.reason().trim());
|
if (credentialMapper.updateById(credential) != 1) throw new BusinessException(ErrorCode.CONFLICT, "洗车凭证状态已变化，请刷新后重试");
|
return detail(id);
|
}
|
|
private Rule rule(Long merchantId, String cardLevel, boolean familyCard) {
|
TransportCarWashService config = configMapper.selectOne(new QueryWrapper<TransportCarWashService>()
|
.eq("merchant_id", merchantId).eq("deleted", 0).eq("status", 1).last("limit 1"));
|
if (config == null) throw new BusinessException(ErrorCode.CONFLICT, "洗车服务未启用");
|
for (Map<String, Object> item : parseRules(config.getBenefitRules())) {
|
if (levelMatches(text(item, "cardLevel"), cardLevel)) {
|
Rule rule = new Rule(number(item.get("totalCount")).intValue(), normalizeCycle(text(item, "resetCycle")), Boolean.TRUE.equals(item.get("familyCardShared")));
|
if (familyCard && !rule.familyCardShared()) throw new BusinessException(ErrorCode.CONFLICT, "亲属附属卡不可共享该洗车权益");
|
return rule;
|
}
|
}
|
throw new BusinessException(ErrorCode.CONFLICT, "当前人才卡等级未配置洗车权益次数");
|
}
|
|
private List<Map<String, Object>> parseRules(String json) {
|
if (json == null || json.isBlank()) return List.of();
|
try { return objectMapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {}); }
|
catch (Exception exception) { throw new BusinessException(ErrorCode.INTERNAL_ERROR, "洗车权益次数配置格式不正确"); }
|
}
|
|
private String writeJson(Object value) {
|
try { return objectMapper.writeValueAsString(value); }
|
catch (Exception exception) { throw new BusinessException(ErrorCode.INTERNAL_ERROR, "洗车凭证文件保存失败"); }
|
}
|
|
private Map<String, Object> view(Map<String, Object> row) {
|
Map<String, Object> result = new LinkedHashMap<>(row);
|
Object files = row.get("proofFiles");
|
if (files != null) {
|
try { result.put("proofFiles", objectMapper.readValue(String.valueOf(files), new TypeReference<List<String>>() {})); }
|
catch (Exception ignored) { result.put("proofFiles", List.of()); }
|
}
|
int status = number(row.get("status")).intValue();
|
result.put("statusText", switch (status) { case 0 -> "待审核"; case 1 -> "已通过"; case 2 -> "已驳回"; case 3 -> "已回滚"; default -> "未知"; });
|
return result;
|
}
|
|
private LocalDateTime windowStart(String cycle) {
|
LocalDate today = LocalDate.now();
|
return switch (normalizeCycle(cycle)) {
|
case "DAY" -> today.atStartOfDay();
|
case "WEEK" -> today.with(DayOfWeek.MONDAY).atStartOfDay();
|
case "MONTH" -> today.withDayOfMonth(1).atStartOfDay();
|
case "YEAR" -> today.with(TemporalAdjusters.firstDayOfYear()).atStartOfDay();
|
default -> LocalDate.of(1970, 1, 1).atStartOfDay();
|
};
|
}
|
|
private String normalizeCycle(String raw) {
|
String value = clean(raw).toUpperCase(Locale.ROOT);
|
return switch (value) {
|
case "DAY", "DAILY", "每天", "每日" -> "DAY";
|
case "WEEK", "WEEKLY", "每周" -> "WEEK";
|
case "MONTH", "MONTHLY", "每月" -> "MONTH";
|
case "YEAR", "YEARLY", "ANNUAL", "每年" -> "YEAR";
|
case "NONE", "不重置" -> "NONE";
|
default -> throw new BusinessException(ErrorCode.BAD_REQUEST, "洗车权益重置周期不正确");
|
};
|
}
|
|
private boolean levelMatches(String configured, String actual) {
|
String a = clean(configured).replace("人才卡", "");
|
String b = clean(actual).replace("人才卡", "");
|
return !a.isBlank() && (a.equalsIgnoreCase(b) || a.contains(b) || b.contains(a));
|
}
|
|
private void requireMerchant(Long merchantId) {
|
if (merchantId == null || merchantId <= 0 || number(configMapper.countCarWashMerchant(merchantId)).longValue() == 0)
|
throw new BusinessException(ErrorCode.NOT_FOUND, "洗车商家不存在");
|
}
|
private void validateStatus(Integer status) { if (status != null && (status < 0 || status > 3)) throw new BusinessException(ErrorCode.BAD_REQUEST, "洗车凭证状态不正确"); }
|
private Number number(Object value) { return value instanceof Number number ? number : 0L; }
|
private Long longValue(Map<String, Object> row, String key) { Object value = row.get(key); return value instanceof Number n ? n.longValue() : null; }
|
private String text(Map<String, Object> row, String key) { Object value = row.get(key); return value == null ? "" : String.valueOf(value).trim(); }
|
private String first(String... values) { for (String value : values) if (!clean(value).isBlank()) return clean(value); return ""; }
|
private String clean(String value) { return value == null ? "" : value.trim(); }
|
private String trimToNull(String value) { return clean(value).isBlank() ? null : clean(value); }
|
private record Rule(int totalCount, String resetCycle, boolean familyCardShared) {}
|
}
|
