package com.tourguide.modules.finance.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.tourguide.common.exception.BusinessException;
|
import com.tourguide.common.huifu.biz.DouGongBasicDataBiz;
|
import com.tourguide.modules.finance.dto.GuideBankBranchResponse;
|
import com.tourguide.modules.finance.dto.GuideBankCardRequest;
|
import com.tourguide.modules.finance.dto.GuideBankCardResponse;
|
import com.tourguide.modules.finance.dto.GuideSettlementOnboardingRequest;
|
import com.tourguide.modules.finance.dto.GuideSettlementStatusResponse;
|
import com.tourguide.modules.finance.entity.GuideWithdrawalAccount;
|
import com.tourguide.modules.finance.entity.GuideBankBranch;
|
import com.tourguide.modules.finance.mapper.GuideBankBranchMapper;
|
import com.tourguide.modules.finance.mapper.GuideWithdrawalAccountMapper;
|
import com.tourguide.modules.user.entity.GuideUser;
|
import com.tourguide.modules.user.service.GuideUserService;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
|
import java.time.LocalDateTime;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.UUID;
|
import java.util.stream.Collectors;
|
|
/** 导游端进件、审核状态和当前结算卡能力。 */
|
@Service
|
public class GuideSettlementService {
|
static final int GUIDE_USER_TYPE = 2;
|
static final int HUIFU_TYPE = 1;
|
static final int ACTIVE_STATUS = 1;
|
private static final int AUDIT_PENDING = 1;
|
private static final int AUDIT_APPROVED = 2;
|
private static final int AUDIT_REJECTED = 3;
|
private static final String SUCCESS_CODE = "00000000";
|
|
private final GuideWithdrawalAccountMapper accountMapper;
|
private final GuideUserService guideUserService;
|
private final DouGongBasicDataBiz douGongBasicDataBiz;
|
private final GuideBankBranchMapper bankBranchMapper;
|
|
public GuideSettlementService(GuideWithdrawalAccountMapper accountMapper,
|
GuideUserService guideUserService,
|
DouGongBasicDataBiz douGongBasicDataBiz,
|
GuideBankBranchMapper bankBranchMapper) {
|
this.accountMapper = accountMapper;
|
this.guideUserService = guideUserService;
|
this.douGongBasicDataBiz = douGongBasicDataBiz;
|
this.bankBranchMapper = bankBranchMapper;
|
}
|
|
public GuideSettlementStatusResponse status(Long guideId) {
|
guideUserService.findEnabledById(guideId);
|
GuideWithdrawalAccount account = findCurrent(guideId);
|
if (account == null) return new GuideSettlementStatusResponse("unsubmitted", null, null, null);
|
refreshAuditState(account);
|
return toStatus(account);
|
}
|
|
@Transactional(noRollbackFor = BusinessException.class)
|
public GuideSettlementStatusResponse submit(Long guideId, GuideSettlementOnboardingRequest request) {
|
GuideUser guide = guideUserService.findEnabledById(guideId);
|
validateOnboarding(request);
|
GuideWithdrawalAccount account = findCurrent(guideId);
|
if (account != null && "approved".equals(statusValue(account))) {
|
throw new BusinessException(409, "当前导游已完成进件");
|
}
|
if (account != null && "pending".equals(statusValue(account))) {
|
throw new BusinessException(409, "进件资料正在审核中，请勿重复提交");
|
}
|
if (account != null && StringUtils.hasText(account.getHuifuId())
|
&& StringUtils.hasText(account.getSubjectType())
|
&& !account.getSubjectType().equals(request.getSubjectType())) {
|
throw new BusinessException(409, "已提交的进件主体类型不可变更，请按原类型重新提交");
|
}
|
if (account == null) account = new GuideWithdrawalAccount();
|
applyOnboarding(account, guideId, request, guide);
|
account.setApplicationStatus("processing");
|
account.setIsAudit(AUDIT_PENDING);
|
account.setFailureMsgsReason(null);
|
account.setOutRequestNo(randomRequestNo());
|
account.setCreateTime(account.getCreateTime() == null ? LocalDateTime.now() : account.getCreateTime());
|
save(account);
|
try {
|
boolean enterprise = "enterprise".equals(account.getSubjectType());
|
Map<String, Object> result = enterprise
|
? submitEnterprise(account)
|
: submitIndividual(account);
|
requireSuccess(result, "斗拱进件提交失败");
|
applyRemoteIds(account, result);
|
if (enterprise) {
|
applyRemoteAuditState(account, result, false);
|
} else {
|
applyIndividualSuccess(account);
|
}
|
save(account);
|
return toStatus(account);
|
} catch (BusinessException exception) {
|
markRejected(account, exception.getMessage());
|
throw exception;
|
} catch (Exception exception) {
|
markRejected(account, exception.getMessage());
|
throw new BusinessException(502, "斗拱进件服务暂不可用，请稍后重试");
|
}
|
}
|
|
public List<GuideBankCardResponse> bankCards(Long guideId) {
|
GuideWithdrawalAccount account = requireApproved(guideId);
|
if (!StringUtils.hasText(account.getBankCardCode())) return Collections.emptyList();
|
refreshBankCardState(account);
|
return Collections.singletonList(new GuideBankCardResponse(account));
|
}
|
|
@Transactional
|
public GuideBankCardResponse bindBankCard(Long guideId, GuideBankCardRequest request) {
|
guideUserService.findEnabledById(guideId);
|
GuideWithdrawalAccount account = accountMapper.selectCurrentForUpdate(toTableUserId(guideId));
|
requireApproved(account);
|
GuideBankBranch branch = findActiveBranch(request.getBranchCode(), request.getCityCode());
|
account.setBankName(branch.getBankName());
|
account.setBankCardCode(trim(request.getCardNumber()));
|
account.setBankBranchName(branch.getBranchName());
|
account.setBankBranchCode(branch.getBranchCode());
|
account.setBankCardProvinceCode(trim(request.getProvinceCode()));
|
account.setBankCardCityCode(branch.getCityCode());
|
account.setOpenAccountName(account.getCertificateName());
|
account.setBankCardStatus("local");
|
account.setBankCardReason(null);
|
account.setTokenNo(null);
|
account.setCusApplicationId(null);
|
save(account);
|
return new GuideBankCardResponse(account);
|
}
|
|
@Transactional(noRollbackFor = BusinessException.class)
|
public GuideBankCardResponse openBankCardBusiness(Long guideId, Integer cardId) {
|
guideUserService.findEnabledById(guideId);
|
GuideWithdrawalAccount account = accountMapper.selectCurrentForUpdate(toTableUserId(guideId));
|
requireApproved(account);
|
requireCurrentBankCard(account, cardId);
|
if (StringUtils.hasText(account.getTokenNo())) {
|
account.setBankCardStatus("approved");
|
account.setBankCardReason(null);
|
save(account);
|
return new GuideBankCardResponse(account);
|
}
|
if ("pending".equals(account.getBankCardStatus())
|
&& StringUtils.hasText(account.getCusApplicationId())) {
|
refreshBankCardState(account);
|
return new GuideBankCardResponse(account);
|
}
|
account.setBankCardStatus("pending");
|
account.setBankCardReason(null);
|
account.setCusApplicationId(null);
|
save(account);
|
try {
|
Map<String, Object> result = douGongBasicDataBiz.userBusinessOpen(account);
|
requireSuccess(result, "银行卡业务入驻失败");
|
account.setTokenNo(first(result, "token_no", "card_token_no"));
|
account.setCusApplicationId(first(result, "apply_no", "application_no", "cus_application_id"));
|
if (!StringUtils.hasText(account.getTokenNo())
|
&& !StringUtils.hasText(account.getCusApplicationId())) {
|
throw new BusinessException(502, "银行卡业务入驻响应缺少取现卡序列号");
|
}
|
account.setBankCardStatus(StringUtils.hasText(account.getTokenNo()) ? "approved" : "pending");
|
save(account);
|
return new GuideBankCardResponse(account);
|
} catch (BusinessException exception) {
|
account.setBankCardStatus("rejected");
|
account.setBankCardReason(exception.getMessage());
|
save(account);
|
throw exception;
|
} catch (Exception exception) {
|
account.setBankCardStatus("rejected");
|
account.setBankCardReason(exception.getMessage());
|
save(account);
|
throw new BusinessException(502, "银行卡业务入驻服务暂不可用，请稍后重试");
|
}
|
}
|
|
private void requireCurrentBankCard(GuideWithdrawalAccount account, Integer cardId) {
|
if (cardId == null || !cardId.equals(account.getId())
|
|| !StringUtils.hasText(account.getBankCardCode())) {
|
throw new BusinessException(404, "银行卡不存在，请重新选择");
|
}
|
}
|
|
private GuideBankBranch findActiveBranch(String branchCode, String cityCode) {
|
GuideBankBranch branch = bankBranchMapper.selectOne(new LambdaQueryWrapper<GuideBankBranch>()
|
.eq(GuideBankBranch::getBranchCode, trim(branchCode))
|
.eq(GuideBankBranch::getCityCode, trim(cityCode))
|
.eq(GuideBankBranch::getStatus, ACTIVE_STATUS)
|
.last("LIMIT 1"));
|
if (branch == null) {
|
throw new BusinessException(400, "开户行不存在或已停用，请重新选择");
|
}
|
return branch;
|
}
|
|
public List<GuideBankBranchResponse> branches(String cityCode, String keyword) {
|
String query = trim(keyword);
|
LambdaQueryWrapper<GuideBankBranch> wrapper = new LambdaQueryWrapper<GuideBankBranch>()
|
.eq(GuideBankBranch::getStatus, 1)
|
.eq(StringUtils.hasText(cityCode), GuideBankBranch::getCityCode,
|
StringUtils.hasText(cityCode) ? cityCode.trim() : null)
|
.and(StringUtils.hasText(query), item -> item.like(GuideBankBranch::getBankName, query)
|
.or().like(GuideBankBranch::getBranchName, query))
|
.orderByAsc(GuideBankBranch::getBankName)
|
.orderByAsc(GuideBankBranch::getBranchName)
|
.last("LIMIT 100");
|
return bankBranchMapper.selectList(wrapper).stream()
|
.map(GuideBankBranchResponse::new)
|
.collect(Collectors.toList());
|
}
|
|
public GuideWithdrawalAccount requireApproved(Long guideId) {
|
guideUserService.findEnabledById(guideId);
|
return requireApproved(findCurrent(guideId));
|
}
|
|
public GuideWithdrawalAccount requireApprovedCard(Long guideId, Integer cardId) {
|
GuideWithdrawalAccount account = requireApproved(guideId);
|
return requireApprovedCard(account, cardId);
|
}
|
|
/** 提现创建事务内锁定当前进件账户，串行校验余额和结算卡。 */
|
public GuideWithdrawalAccount requireApprovedCardForUpdate(Long guideId, Integer cardId) {
|
guideUserService.findEnabledById(guideId);
|
GuideWithdrawalAccount account = accountMapper.selectCurrentForUpdate(toTableUserId(guideId));
|
requireApproved(account);
|
return requireApprovedCard(account, cardId);
|
}
|
|
private GuideWithdrawalAccount requireApprovedCard(GuideWithdrawalAccount account, Integer cardId) {
|
if (!account.getId().equals(cardId) || !StringUtils.hasText(account.getTokenNo())
|
|| "rejected".equals(account.getBankCardStatus())) {
|
throw new BusinessException(409, "请选择审核通过的银行卡");
|
}
|
return account;
|
}
|
|
public GuideWithdrawalAccount findCurrent(Long guideId) {
|
return accountMapper.selectOne(new LambdaQueryWrapper<GuideWithdrawalAccount>()
|
.eq(GuideWithdrawalAccount::getUserId, toTableUserId(guideId))
|
.eq(GuideWithdrawalAccount::getUserType, GUIDE_USER_TYPE)
|
.eq(GuideWithdrawalAccount::getType, HUIFU_TYPE)
|
.eq(GuideWithdrawalAccount::getStatus, ACTIVE_STATUS)
|
.orderByDesc(GuideWithdrawalAccount::getId)
|
.last("LIMIT 1"));
|
}
|
|
private Map<String, Object> submitEnterprise(GuideWithdrawalAccount account) throws Exception {
|
return StringUtils.hasText(account.getHuifuId())
|
? douGongBasicDataBiz.userBasicDataEntModify(account)
|
: douGongBasicDataBiz.userBasicDataEnt(account);
|
}
|
|
private Map<String, Object> submitIndividual(GuideWithdrawalAccount account) throws Exception {
|
return StringUtils.hasText(account.getHuifuId())
|
? douGongBasicDataBiz.userBasicDataIndvModify(account)
|
: douGongBasicDataBiz.userBasicDataIndv(account);
|
}
|
|
private void refreshAuditState(GuideWithdrawalAccount account) {
|
if (!"pending".equals(statusValue(account)) || !StringUtils.hasText(account.getHuifuId())) return;
|
// 个人基础进件是同步接口：成功响应只有 huifu_id，不会返回申请单号，也无需查询审核状态。
|
if (!"enterprise".equals(account.getSubjectType())) {
|
applyIndividualSuccess(account);
|
save(account);
|
return;
|
}
|
if (!StringUtils.hasText(account.getCusApplicationId())) return;
|
try {
|
Map<String, Object> result = douGongBasicDataBiz.userApplyQuery(account, account.getCusApplicationId());
|
requireSuccess(result, "进件审核状态查询失败");
|
applyRemoteAuditState(account, result, true);
|
save(account);
|
} catch (BusinessException exception) {
|
throw exception;
|
} catch (Exception exception) {
|
throw new BusinessException(502, "进件审核状态查询失败，请稍后重试");
|
}
|
}
|
|
private void refreshBankCardState(GuideWithdrawalAccount account) {
|
if (!"pending".equals(account.getBankCardStatus())
|
|| !StringUtils.hasText(account.getHuifuId())
|
|| !StringUtils.hasText(account.getCusApplicationId())) return;
|
try {
|
Map<String, Object> result = douGongBasicDataBiz.userApplyQuery(account, account.getCusApplicationId());
|
requireSuccess(result, "银行卡审核状态查询失败");
|
String remoteStatus = remoteStatus(result);
|
String tokenNo = first(result, "token_no", "card_token_no");
|
if (StringUtils.hasText(tokenNo)) account.setTokenNo(tokenNo);
|
if (isApproved(remoteStatus) || StringUtils.hasText(account.getTokenNo())) {
|
account.setBankCardStatus("approved");
|
account.setBankCardReason(null);
|
} else if (isRejected(remoteStatus)) {
|
account.setBankCardStatus("rejected");
|
account.setBankCardReason(remoteReason(result));
|
}
|
save(account);
|
} catch (Exception ignored) {
|
// 备注：银行卡列表仍返回本地最后状态，避免第三方短暂不可用导致页面完全不可用。
|
}
|
}
|
|
private void applyRemoteAuditState(GuideWithdrawalAccount account, Map<String, Object> result,
|
boolean keepPendingWhenUnknown) {
|
String remoteStatus = remoteStatus(result);
|
if (isApproved(remoteStatus)) {
|
account.setIsAudit(AUDIT_APPROVED);
|
account.setApplicationStatus("succeeded");
|
account.setSucceededAt(account.getSucceededAt() == null ? LocalDateTime.now() : account.getSucceededAt());
|
account.setFailureMsgsReason(null);
|
} else if (isRejected(remoteStatus)) {
|
account.setIsAudit(AUDIT_REJECTED);
|
account.setApplicationStatus("failed");
|
account.setFailureMsgsReason(remoteReason(result));
|
} else if (keepPendingWhenUnknown || !StringUtils.hasText(remoteStatus)) {
|
account.setIsAudit(AUDIT_PENDING);
|
account.setApplicationStatus("submitted");
|
} else {
|
account.setIsAudit(AUDIT_PENDING);
|
account.setApplicationStatus(remoteStatus);
|
}
|
}
|
|
private void applyIndividualSuccess(GuideWithdrawalAccount account) {
|
if (!StringUtils.hasText(account.getHuifuId())) {
|
throw new BusinessException(502, "斗拱个人进件成功响应缺少汇付ID");
|
}
|
account.setIsAudit(AUDIT_APPROVED);
|
account.setApplicationStatus("succeeded");
|
account.setSucceededAt(account.getSucceededAt() == null ? LocalDateTime.now() : account.getSucceededAt());
|
account.setFailureMsgsReason(null);
|
account.setCusApplicationId(null);
|
}
|
|
private GuideWithdrawalAccount requireApproved(GuideWithdrawalAccount account) {
|
if (account == null) throw new BusinessException(409, "请先完成导游进件");
|
if (!"approved".equals(statusValue(account))) {
|
throw new BusinessException(409, "进件审核通过后才能继续操作");
|
}
|
if (!StringUtils.hasText(account.getHuifuId())) {
|
throw new BusinessException(409, "进件账户信息不完整，请联系平台处理");
|
}
|
return account;
|
}
|
|
private GuideSettlementStatusResponse toStatus(GuideWithdrawalAccount account) {
|
return new GuideSettlementStatusResponse(statusValue(account),
|
StringUtils.hasText(account.getSubjectType()) ? account.getSubjectType() : "individual",
|
account.getFailureMsgsReason(), account.getCreateTime());
|
}
|
|
private String statusValue(GuideWithdrawalAccount account) {
|
if (account == null) return "unsubmitted";
|
if (Integer.valueOf(AUDIT_APPROVED).equals(account.getIsAudit())) return "approved";
|
if (Integer.valueOf(AUDIT_REJECTED).equals(account.getIsAudit())) return "rejected";
|
String value = account.getApplicationStatus();
|
if (isApproved(value) && StringUtils.hasText(account.getHuifuId())) return "approved";
|
if (isRejected(value)) return "rejected";
|
return "pending";
|
}
|
|
private void validateOnboarding(GuideSettlementOnboardingRequest request) {
|
boolean enterprise = "enterprise".equals(request.getSubjectType());
|
if (enterprise) {
|
requireText(request.getEnterpriseName(), "企业名称不能为空");
|
if (!StringUtils.hasText(request.getCreditCode())
|
|| !request.getCreditCode().trim().matches("^[0-9A-Z]{18}$")) {
|
throw new BusinessException(400, "统一社会信用代码格式不正确");
|
}
|
requireValidity(request.getLicenseValidityType(), request.getLicenseBeginDate(),
|
request.getLicenseEndDate(), "营业执照");
|
requireText(request.getRegisteredProvinceCode(), "注册地址省编码不能为空");
|
requireText(request.getRegisteredCityCode(), "注册地址市编码不能为空");
|
requireText(request.getRegisteredDistrictCode(), "注册地址区县编码不能为空");
|
requireText(request.getRegisteredAddress(), "详细注册地址不能为空");
|
}
|
requireValidity(request.getSubjectCertificateValidityType(),
|
request.getSubjectCertificateBeginDate(), request.getSubjectCertificateEndDate(), "证件");
|
}
|
|
private void requireValidity(String type, String begin, String end, String label) {
|
if (!"fixed".equals(type) && !"long_term".equals(type)) {
|
throw new BusinessException(400, label + "有效期类型不支持");
|
}
|
requireText(begin, label + "有效期开始日期不能为空");
|
if ("fixed".equals(type)) requireText(end, label + "有效期结束日期不能为空");
|
}
|
|
private void requireText(String value, String message) {
|
if (!StringUtils.hasText(value)) throw new BusinessException(400, message);
|
}
|
|
private void applyOnboarding(GuideWithdrawalAccount account, Long guideId,
|
GuideSettlementOnboardingRequest request, GuideUser guide) {
|
account.setUserId(toTableUserId(guideId));
|
account.setUserType(GUIDE_USER_TYPE);
|
account.setType(HUIFU_TYPE);
|
account.setStatus(ACTIVE_STATUS);
|
account.setSubjectType(request.getSubjectType());
|
account.setEnterpriseName(trim(request.getEnterpriseName()));
|
account.setCreditCode(trim(request.getCreditCode()));
|
account.setLicenseValidityType(trim(request.getLicenseValidityType()));
|
account.setLicenseBeginDate(trim(request.getLicenseBeginDate()));
|
account.setLicenseEndDate(trim(request.getLicenseEndDate()));
|
account.setRegisteredProvinceCode(trim(request.getRegisteredProvinceCode()));
|
account.setRegisteredCityCode(trim(request.getRegisteredCityCode()));
|
account.setRegisteredDistrictCode(trim(request.getRegisteredDistrictCode()));
|
account.setRegisteredAddress(trim(request.getRegisteredAddress()));
|
account.setContactName(trim(request.getContactName()));
|
account.setCertificateName(trim(request.getSubjectName()));
|
account.setCertificateType(0);
|
account.setCertificateCode(trim(request.getSubjectIdNumber()).toUpperCase());
|
account.setCertificateExpireTime(dateRange(request.getSubjectCertificateValidityType(),
|
request.getSubjectCertificateBeginDate(), request.getSubjectCertificateEndDate()));
|
account.setOpenAccountName(trim(request.getSubjectName()));
|
account.setPhone(StringUtils.hasText(request.getContactMobile())
|
? request.getContactMobile().trim() : guide.getMobile());
|
}
|
|
private String dateRange(String type, String begin, String end) {
|
return trim(begin) + "，" + ("long_term".equals(type) ? "长期" : trim(end));
|
}
|
|
private void applyRemoteIds(GuideWithdrawalAccount account, Map<String, Object> result) {
|
String huifuId = first(result, "huifu_id", "user_huifu_id");
|
String applicationId = first(result, "apply_no", "application_no", "cus_application_id");
|
if (StringUtils.hasText(huifuId)) account.setHuifuId(huifuId);
|
if (StringUtils.hasText(applicationId)) account.setCusApplicationId(applicationId);
|
}
|
|
private void requireSuccess(Map<String, Object> result, String fallback) {
|
String code = first(result, "resp_code", "code");
|
if (SUCCESS_CODE.equals(code)) return;
|
String message = first(result, "resp_desc", "message", "msg");
|
throw new BusinessException(502, StringUtils.hasText(message) ? message : fallback);
|
}
|
|
private String remoteStatus(Map<String, Object> result) {
|
return first(result, "apply_status", "application_status", "audit_status", "status", "trans_stat");
|
}
|
|
private String remoteReason(Map<String, Object> result) {
|
String reason = first(result, "failure_reason", "fail_reason", "audit_remark", "resp_desc");
|
return StringUtils.hasText(reason) ? reason : "进件审核未通过";
|
}
|
|
private boolean isApproved(String value) {
|
if (!StringUtils.hasText(value)) return false;
|
String normalized = value.trim().toLowerCase();
|
return Arrays.asList("2", "s", "success", "succeeded", "approved", "pass", "passed").contains(normalized);
|
}
|
|
private boolean isRejected(String value) {
|
if (!StringUtils.hasText(value)) return false;
|
String normalized = value.trim().toLowerCase();
|
return Arrays.asList("3", "f", "failed", "failure", "rejected", "reject").contains(normalized);
|
}
|
|
@SuppressWarnings("unchecked")
|
private String first(Map<String, Object> result, String... keys) {
|
if (result == null) return null;
|
for (String key : keys) {
|
Object value = result.get(key);
|
if (value != null && StringUtils.hasText(String.valueOf(value))) return String.valueOf(value);
|
}
|
Object data = result.get("data");
|
if (data instanceof Map) return first((Map<String, Object>) data, keys);
|
if (data instanceof String && StringUtils.hasText((String) data)) {
|
try {
|
Map<String, Object> nested = com.alibaba.fastjson.JSONObject.parseObject(
|
(String) data, LinkedHashMap.class);
|
return first(nested, keys);
|
} catch (Exception ignored) {}
|
}
|
return null;
|
}
|
|
private void markRejected(GuideWithdrawalAccount account, String reason) {
|
account.setIsAudit(AUDIT_REJECTED);
|
account.setApplicationStatus("failed");
|
account.setFailureMsgsReason(StringUtils.hasText(reason) ? reason : "斗拱进件失败");
|
save(account);
|
}
|
|
private void save(GuideWithdrawalAccount account) {
|
if (account.getId() == null) accountMapper.insert(account); else accountMapper.updateById(account);
|
}
|
|
private int toTableUserId(Long guideId) {
|
try {
|
return Math.toIntExact(guideId);
|
} catch (ArithmeticException exception) {
|
throw new BusinessException(400, "导游ID超出进件表支持范围");
|
}
|
}
|
|
private String randomRequestNo() {
|
return UUID.randomUUID().toString().replace("-", "");
|
}
|
|
private String trim(String value) {
|
return StringUtils.hasText(value) ? value.trim() : null;
|
}
|
}
|
