提交 platform

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/pom.xml

@@ -45,12 +45,6 @@
             <artifactId>liquidnet-service-adam-api</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
-        <dependency>
-            <groupId>com.liquidnet</groupId>
-            <artifactId>liquidnet-api-feign-kylin</artifactId>
-            <version>1.0-SNAPSHOT</version>
-            <scope>compile</scope>
-        </dependency>
 
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -65,6 +59,16 @@
             <groupId>com.aliyun</groupId>
             <artifactId>aliyun-java-sdk-dypnsapi</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.liquidnet</groupId>
+            <artifactId>liquidnet-service-kylin-api</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.liquidnet</groupId>
+            <artifactId>liquidnet-service-adam-api</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
     </dependencies>
 
     <build>

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/impl/FieldsPartnerServiceImpl.java

+package com.liquidnet.service.kylin.partner.impl;
+
+import com.liquidnet.common.cache.redis.util.RedisUtil;
+import com.liquidnet.service.kylin.constant.KylinRedisConst;
+import com.liquidnet.service.kylin.dto.vo.KylinFieldsVo;
+import com.liquidnet.service.kylin.mapper.KylinFieldRelationMapper;
+import com.liquidnet.service.kylin.mapper.KylinFieldStatusMapper;
+import com.liquidnet.service.kylin.mapper.KylinFieldsMapper;
+import com.liquidnet.service.kylin.service.partner.KylinFieldsPartnerService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+
+@Service
+public class FieldsPartnerServiceImpl implements KylinFieldsPartnerService {
+
+    @Autowired
+    MongoTemplate mongoTemplate;
+
+    @Autowired
+    private RedisUtil redisUtil;
+
+    @Autowired
+    private KylinFieldsMapper fieldsMapper;
+
+    @Autowired
+    private KylinFieldStatusMapper kylinFieldStatusMapper;
+
+    @Autowired
+    private KylinFieldRelationMapper fieldRelationsMapper;
+
+    /**
+     * 根据名字模糊查询 partner 场地列表
+     * @param page
+     * @param size
+     * @param name
+     * @return
+     */
+    @Override
+    public HashMap<String, Object> fieldList(int page, int size, String name) {
+        HashMap<String,Object> info = new HashMap<>();
+
+        // 排序 分页
+        Pageable pageable = PageRequest.of(0, size, Sort.by(Sort.Direction.DESC, "createdAt"));
+
+        //条件
+        Query query = Query.query(Criteria.where("name").regex(".*?\\" +name));
+
+        // 查询总数
+        long count = mongoTemplate.count(query, KylinFieldsVo.class, KylinFieldsVo.class.getSimpleName());
+
+        query.with(pageable);
+        info.put("total",count);
+        info.put("data", mongoTemplate.find(query, KylinFieldsVo.class, KylinFieldsVo.class.getSimpleName()));
+
+        return info;
+    }
+
+
+    /**
+     * partner 场地详情
+     * @param fieldId
+     * @return
+     */
+    @Override
+    public KylinFieldsVo fieldDetails(String fieldId) {
+        KylinFieldsVo info = null;
+        // 获取 redis数据
+        info = (KylinFieldsVo) redisUtil.hget(KylinRedisConst.FIELDS, fieldId + "");
+        //不存在 获取 mongo数据
+        if (null == info) {
+            info = mongoTemplate.findOne(Query.query(Criteria.where("fieldsId").is(fieldId)), KylinFieldsVo.class, KylinFieldsVo.class.getSimpleName());
+            redisUtil.hset(KylinRedisConst.FIELDS, fieldId + "",info);
+        }
+        return info;
+    }
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/impl/KylinBuyNoticePartnerServiceImpl.java

+package com.liquidnet.service.kylin.partner.impl;
+
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.liquidnet.service.kylin.dto.vo.middle.KylinBuyNoticeVo;
+import com.liquidnet.service.kylin.entity.KylinBuyNotice;
+import com.liquidnet.service.kylin.mapper.KylinBuyNoticeMapper;
+import com.liquidnet.service.kylin.service.partner.IKylinBuyNoticePartnerService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <p>
+ * 购票须知表 服务实现类
+ * </p>
+ *
+ * @author liquidnet
+ * @since 2021-05-18
+ */
+@Service
+public class KylinBuyNoticePartnerServiceImpl extends ServiceImpl<KylinBuyNoticeMapper, KylinBuyNotice> implements IKylinBuyNoticePartnerService {
+
+    @Autowired
+    private KylinBuyNoticeMapper kylinBuyNoticeMapper;
+
+    @Override
+    public PageInfo<KylinBuyNoticeVo> getBuyNotice() {
+        PageInfo<KylinBuyNoticeVo> pageInfoTmp = null;
+
+        PageHelper.startPage(1, 20);
+        List<KylinBuyNotice> buyNoticeList = kylinBuyNoticeMapper.selectList(new UpdateWrapper<KylinBuyNotice>().eq("status", 1).orderByDesc("sort").orderByDesc("mid"));
+
+        List<KylinBuyNoticeVo> kylinBuyNoticeVoList = new ArrayList<>();
+        for (KylinBuyNotice item : buyNoticeList) {
+            KylinBuyNoticeVo kylinBuyNoticeVo = new KylinBuyNoticeVo();
+            BeanUtils.copyProperties(item, kylinBuyNoticeVo);
+            kylinBuyNoticeVoList.add(kylinBuyNoticeVo);
+        }
+        pageInfoTmp = new PageInfo(kylinBuyNoticeVoList);
+
+        return pageInfoTmp;
+    }
+
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/impl/KylinCheckUserPartnerServiceImpl.java

+package com.liquidnet.service.kylin.partner.impl;
+
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.liquidnet.commons.lang.util.IDGenerator;
+import com.liquidnet.service.base.ErrorMapping;
+import com.liquidnet.service.base.ResponseDto;
+import com.liquidnet.service.kylin.dao.ChildDetailsDao;
+import com.liquidnet.service.kylin.dao.ChildListDao;
+import com.liquidnet.service.kylin.dto.vo.mongo.KylinCheckUserVo;
+import com.liquidnet.service.kylin.entity.KylinCheckUser;
+import com.liquidnet.service.kylin.mapper.KylinCheckUserMapper;
+import com.liquidnet.service.kylin.partner.utils.DataUtils;
+import com.liquidnet.service.kylin.service.partner.IKylinCheckUserPartnerService;
+import com.mongodb.BasicDBObject;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.stereotype.Service;
+import org.springframework.util.DigestUtils;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * <p>
+ * 验票用户表 服务实现类
+ * </p>
+ *
+ * @author liquidnet
+ * @since 2021-05-21
+ */
+@Service
+public class KylinCheckUserPartnerServiceImpl extends ServiceImpl<KylinCheckUserMapper, KylinCheckUser> implements IKylinCheckUserPartnerService {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+    @Autowired
+    private MongoConverter mongoConverter;
+    @Autowired
+    private DataUtils dataUtils;
+    @Autowired
+    private KylinCheckUserMapper checkUserMapper;
+
+    @Override
+    public PageInfo<ChildListDao> getCheckUserList(String merchantId, String mobile, int page, int size) {
+        PageInfo<ChildListDao> pageInfo = null;
+        try {
+            PageHelper.startPage(page, size);
+            List<ChildListDao> data = checkUserMapper.childSimpleList(merchantId, mobile);
+            pageInfo = new PageInfo(data);
+            return pageInfo;
+        } catch (Exception e) {
+            return pageInfo;
+        }
+    }
+
+    @Override
+    public ResponseDto<String> del(String merchantId, String checkUserId) {
+        try {
+            KylinCheckUser checkUser = new KylinCheckUser();
+            checkUser.setUpdatedAt(LocalDateTime.now());
+            checkUser.setStatus(0);
+            checkUserMapper.update(checkUser, new UpdateWrapper<KylinCheckUser>().eq("check_user_id", checkUserId));
+            dataUtils.delCheckUserRedis(checkUserId);
+
+            HashMap<String, Object> map = new HashMap<>();
+            map.put("status", 0);
+//            BasicDBObject obj = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+//            mongoTemplate.getCollection(CheckUserVo.class.getSimpleName()).updateOne(
+//                    Query.query(Criteria.where("checkUserId").is(checkUserId)).getQueryObject(),
+//                    obj
+            mongoTemplate.remove(Query.query(Criteria.where("checkUserId").is(checkUserId)), KylinCheckUserVo.class, KylinCheckUserVo.class.getSimpleName());
+            return ResponseDto.success("删除成功");
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20102));
+        }
+    }
+
+    @Override
+    public ResponseDto<String> create(String merchantId, String name, String pwd, String mobile) {
+        try {
+            KylinCheckUser checkUser = new KylinCheckUser();
+            checkUser.setName(name);
+            checkUser.setPwd(DigestUtils.md5DigestAsHex(pwd.getBytes()));
+            checkUser.setMobile(mobile);
+            checkUser.setCheckUserId(IDGenerator.nextSnowId().toString());
+            checkUser.setCreatedAt(LocalDateTime.now());
+            checkUser.setMerchantId(merchantId);
+            checkUser.setStatus(1);
+            checkUserMapper.insert(checkUser);
+
+            KylinCheckUserVo kylinCheckUserVo = new KylinCheckUserVo();
+            BeanUtils.copyProperties(checkUser, kylinCheckUserVo);
+            mongoTemplate.insert(kylinCheckUserVo, KylinCheckUserVo.class.getSimpleName());
+
+            return ResponseDto.success("添加成功");
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20101));
+        }
+    }
+
+    @Override
+    public ResponseDto<String> change(String merchantId, String checkUserId, String name, String pwd, String mobile) {
+        try {
+            KylinCheckUser checkUser = new KylinCheckUser();
+            checkUser.setName(name);
+            if(null!=pwd) {
+                checkUser.setPwd(DigestUtils.md5DigestAsHex(pwd.getBytes()));
+            }
+            checkUser.setMobile(mobile);
+            checkUser.setUpdatedAt(LocalDateTime.now());
+            checkUserMapper.update(checkUser, new UpdateWrapper<KylinCheckUser>().eq("check_user_id", checkUserId).eq("merchant_id", merchantId));
+            BasicDBObject obj = new BasicDBObject("$set", mongoConverter.convertToMongoType(checkUser));
+            mongoTemplate.getCollection(KylinCheckUserVo.class.getSimpleName()).updateOne(
+                    Query.query(Criteria.where("checkUserId").is(checkUserId)).getQueryObject(),
+                    obj
+            );
+            dataUtils.delCheckUserRedis(checkUserId);
+            return ResponseDto.success("修改成功");
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20103));
+        }
+    }
+
+    @Override
+    public ResponseDto<ChildDetailsDao> details(String merchantId, String checkUserId) {
+        try {
+            ChildDetailsDao data = checkUserMapper.childDetails(merchantId, checkUserId);
+            return ResponseDto.success(data);
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20104));
+        }
+    }
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/impl/KylinCheckUserPerformancesPartnerServiceImpl.java

+package com.liquidnet.service.kylin.partner.impl;
+
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.liquidnet.commons.lang.util.DateUtil;
+import com.liquidnet.commons.lang.util.IDGenerator;
+import com.liquidnet.service.base.ErrorMapping;
+import com.liquidnet.service.base.ResponseDto;
+import com.liquidnet.service.kylin.dao.ChildPerformanceDao;
+import com.liquidnet.service.kylin.dto.param.CheckPerformanceRelationParam;
+import com.liquidnet.service.kylin.dto.param.CheckUserParam;
+import com.liquidnet.service.kylin.dto.vo.mongo.KylinCheckUserPerformanceVo;
+import com.liquidnet.service.kylin.entity.KylinCheckUserPerformances;
+import com.liquidnet.service.kylin.mapper.KylinCheckUserPerformancesMapper;
+import com.liquidnet.service.kylin.partner.utils.DataUtils;
+import com.liquidnet.service.kylin.service.partner.IKylinCheckUserPerformancesPartnerService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <p>
+ * 验票用户可看演出表 服务实现类
+ * </p>
+ *
+ * @author liquidnet
+ * @since 2021-05-21
+ */
+@Service
+public class KylinCheckUserPerformancesPartnerServiceImpl extends ServiceImpl<KylinCheckUserPerformancesMapper, KylinCheckUserPerformances> implements IKylinCheckUserPerformancesPartnerService {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+    @Autowired
+    private MongoConverter mongoConverter;
+    @Autowired
+    private DataUtils dataUtils;
+    @Autowired
+    private KylinCheckUserPerformancesMapper checkUserPerformancesMapper;
+
+    @Override
+    public ResponseDto<PageInfo<ChildPerformanceDao>> childPerformanceList(String merchantId, String checkUserId, int page, int size, String name) {
+        PageInfo<ChildPerformanceDao> pageInfo = null;
+        try {
+            PageHelper.startPage(page, size);
+            List<ChildPerformanceDao> data = checkUserPerformancesMapper.childPerformanceList(merchantId, checkUserId, name);
+            pageInfo = new PageInfo(data);
+            return ResponseDto.success(pageInfo);
+        } catch (Exception e) {
+            return ResponseDto.success(pageInfo);
+        }
+    }
+
+    @Override
+    public ResponseDto<PageInfo<ChildPerformanceDao>> unChildPerformanceList(String merchantId, String checkUserId, int page, int size, String name) {
+        PageInfo<ChildPerformanceDao> pageInfo = null;
+        try {
+            PageHelper.startPage(page, size);
+            List<ChildPerformanceDao> data = checkUserPerformancesMapper.unChildPerformanceList(merchantId, checkUserId, name);
+            pageInfo = new PageInfo(data);
+            return ResponseDto.success(pageInfo);
+        } catch (Exception e) {
+            return ResponseDto.success(pageInfo);
+        }
+    }
+
+    @Override
+    public ResponseDto<String> setPerformance(CheckUserParam param) {
+        try {
+            for (CheckPerformanceRelationParam item : param.getCheckPerformanceRelationParamList()) {
+                if (null == item.getCanDownTime()) {
+                    return ResponseDto.failure(ErrorMapping.get(20101));
+                }
+                KylinCheckUserPerformances checkUserPerformances = new KylinCheckUserPerformances();
+                checkUserPerformances.setCheckUserId(param.getCheckUserId());
+                checkUserPerformances.setCanDownTime(DateUtil.Formatter.yyyyMMddHHmmss.parse(item.getCanDownTime()));
+                checkUserPerformances.setPerformanceId(item.getPerformanceId());
+                checkUserPerformances.setCheckUserPerformanceId(IDGenerator.nextSnowId());
+                checkUserPerformances.setCreatedAt(LocalDateTime.now());
+                checkUserPerformances.setStatus(1);
+                checkUserPerformancesMapper.insert(checkUserPerformances);
+            }
+            mongoTemplate.remove(Query.query(Criteria.where("checkUserId").is(param.getCheckUserId())), KylinCheckUserPerformanceVo.class, KylinCheckUserPerformanceVo.class.getSimpleName());
+
+            KylinCheckUserPerformanceVo userPerformanceVo = new KylinCheckUserPerformanceVo();
+            List<CheckPerformanceRelationParam> performanceRelationParamsList = new ArrayList<>();
+            List<KylinCheckUserPerformances> data = checkUserPerformancesMapper.selectList(new UpdateWrapper<KylinCheckUserPerformances>().eq("check_user_id", param.getCheckUserId()));
+            for (KylinCheckUserPerformances item : data) {
+                CheckPerformanceRelationParam performanceRelationParam = new CheckPerformanceRelationParam();
+                performanceRelationParam.setCanDownTime(item.getCanDownTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+                performanceRelationParam.setPerformanceId(item.getPerformanceId());
+                performanceRelationParamsList.add(performanceRelationParam);
+            }
+            userPerformanceVo.setCheckUserId(param.getCheckUserId());
+            userPerformanceVo.setRelationParams(performanceRelationParamsList);
+
+            mongoTemplate.insert(userPerformanceVo, KylinCheckUserPerformanceVo.class.getSimpleName());
+            dataUtils.delCheckUserRelationRedis(param.getCheckUserId());
+            return ResponseDto.success("添加成功");
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseDto.failure(ErrorMapping.get(20101));
+        }
+    }
+
+    @Override
+    public ResponseDto<String> delPerformance(List<String> performanceIds, String checkUserId) {
+        try {
+            for (String performanceId : performanceIds) {
+                checkUserPerformancesMapper.delete(new UpdateWrapper<KylinCheckUserPerformances>().eq("check_user_id", checkUserId).eq("performance_id", performanceId));
+            }
+            mongoTemplate.remove(Query.query(Criteria.where("checkUserId").is(checkUserId)), KylinCheckUserPerformanceVo.class, KylinCheckUserPerformanceVo.class.getSimpleName());
+
+            KylinCheckUserPerformanceVo userPerformanceVo = new KylinCheckUserPerformanceVo();
+            List<CheckPerformanceRelationParam> performanceRelationParamsList = new ArrayList<>();
+            List<KylinCheckUserPerformances> data = checkUserPerformancesMapper.selectList(new UpdateWrapper<KylinCheckUserPerformances>().eq("check_user_id", checkUserId));
+            for (KylinCheckUserPerformances item : data) {
+                CheckPerformanceRelationParam performanceRelationParam = new CheckPerformanceRelationParam();
+                performanceRelationParam.setCanDownTime(item.getCanDownTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+                performanceRelationParam.setPerformanceId(item.getPerformanceId());
+                performanceRelationParamsList.add(performanceRelationParam);
+            }
+            userPerformanceVo.setCheckUserId(checkUserId);
+            userPerformanceVo.setRelationParams(performanceRelationParamsList);
+            mongoTemplate.insert(userPerformanceVo, KylinCheckUserPerformanceVo.class.getSimpleName());
+            dataUtils.delCheckUserRelationRedis(checkUserId);
+            return ResponseDto.success("删除成功");
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20102));
+        }
+    }
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/impl/KylinPerformancesPartnerServiceImpl.java

+package com.liquidnet.service.kylin.partner.impl;
+
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.liquidnet.common.cache.redis.util.RedisUtil;
+import com.liquidnet.commons.lang.util.BeanUtil;
+import com.liquidnet.commons.lang.util.DateUtil;
+import com.liquidnet.commons.lang.util.IDGenerator;
+import com.liquidnet.service.base.ErrorMapping;
+import com.liquidnet.service.base.ResponseDto;
+import com.liquidnet.service.kylin.constant.KylinRedisConst;
+import com.liquidnet.service.kylin.dao.PerformanceOrderStatisticalDao;
+import com.liquidnet.service.kylin.dao.PerformancePartnerListDao;
+import com.liquidnet.service.kylin.dto.param.PerformancePartnerListParam;
+import com.liquidnet.service.kylin.dto.param.PerformancePartnerVo;
+import com.liquidnet.service.kylin.dto.param.PerformanceStep1Param;
+import com.liquidnet.service.kylin.dto.param.PerformanceStep2Param;
+import com.liquidnet.service.kylin.dto.vo.PerformanceOrderStatisticalVo;
+import com.liquidnet.service.kylin.dto.vo.partner.*;
+import com.liquidnet.service.kylin.entity.*;
+import com.liquidnet.service.kylin.mapper.*;
+import com.liquidnet.service.kylin.partner.utils.DataUtils;
+import com.liquidnet.service.kylin.partner.utils.PerformanceVoTask;
+import com.liquidnet.service.kylin.service.partner.IKylinPerformancesPartnerService;
+import com.mongodb.BasicDBObject;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * <p>
+ * 演出 服务实现类
+ * </p>
+ *
+ * @author liquidnet
+ * @since 2021-05-05
+ */
+@Service
+@Slf4j
+public class KylinPerformancesPartnerServiceImpl extends ServiceImpl<KylinPerformancesMapper, KylinPerformances> implements IKylinPerformancesPartnerService {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private MongoConverter mongoConverter;
+
+    @Autowired
+    private RedisUtil redisUtil;
+
+    @Autowired
+    private DataUtils dataUtils;
+
+    @Autowired
+    private PerformanceVoTask performanceVoTask;
+
+    @Autowired
+    private KylinPerformancesMapper performancesMapper;
+
+    @Autowired
+    private KylinPerformanceStatusMapper performanceStatusMapper;
+
+    @Autowired
+    private KylinPerformanceRelationsMapper performanceRelationsMapper;
+
+    @Autowired
+    private KylinTicketTimesMapper ticketTimesMapper;
+
+    @Autowired
+    private KylinTicketTimeRelationMapper ticketTimeRelationMapper;
+
+    @Autowired
+    private KylinTicketsMapper ticketsMapper;
+
+    @Autowired
+    private KylinTicketStatusMapper ticketStatusMapper;
+
+    @Autowired
+    private KylinTicketRelationsMapper ticketRelationsMapper;
+
+    @Autowired
+    private KylinTicketsPartnerServiceImpl ticketsPartnerService;
+
+    @Autowired
+    private KylinTicketTimesPartnerServiceImpl ticketTimesPartnerService;
+
+    @Override
+    public String step1(PerformanceStep1Param step1Param) {
+        String result = null;
+        // 无 performancesId 则 创建
+        if (null == step1Param.getPerformancesId()) {
+            result = createStep1(step1Param);
+        } else { // 获取 create 数据 status = 0 或 无数据 创建
+            PerformancePartnerVo createParam = mongoTemplate.findOne(Query.query(Criteria.where("performancesId").is(step1Param.getPerformancesId())), PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName());
+            if (createParam == null) {
+                result = createStep1(step1Param);
+            } else {// 修改
+                result = updateStep1(step1Param);
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public String createStep1(PerformanceStep1Param step1Param) {
+        // 获取 主键id
+        String performanceId = IDGenerator.nextSnowId().toString();
+        // 获取 当前时间 -> 创建时间
+        LocalDateTime createdAt = LocalDateTime.now();
+
+        try {
+            step1Param.setPerformancesId(performanceId);
+            PerformancePartnerVo performancePartnerVo = new PerformancePartnerVo();
+            BeanUtils.copyProperties(step1Param, performancePartnerVo);
+            performancePartnerVo.setIsTrueName(0);
+            performancePartnerVo.setLimitCount(0);
+            performancePartnerVo.setCreatedAt(createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            performancePartnerVo.setIsSubmit(0);
+            performancePartnerVo.setStatus(0);
+            performancePartnerVo.setStatusSell(1);
+            performancePartnerVo.setAuditStatus(-1);
+            performancePartnerVo.setRoadShowId("0");
+            performancePartnerVo.setProjectId("0");
+            performancePartnerVo.setIsShow(1);
+            performancePartnerVo.setFieldName((String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + performancePartnerVo.getFieldId(), "name"));
+            performancePartnerVo.setNoticeImage(dataUtils.getBuyNoticeJsonString(step1Param.getNoticeIds()));
+
+            mongoTemplate.insert(
+                    performancePartnerVo, PerformancePartnerVo.class.getSimpleName()
+            );
+            return performanceId;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @Override
+    public String updateStep1(PerformanceStep1Param step1Param) {
+        // 获取 当前时间 -> 创建时间
+        LocalDateTime timeNow = LocalDateTime.now();
+        String performanceId = step1Param.getPerformancesId();
+        try {
+            PerformancePartnerVo data = mongoTemplate.findOne(Query.query(Criteria.where("performancesId").is(performanceId)),
+                    PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName());
+            if (data == null || data.getAuditStatus() == null || data.getAuditStatus() == 0) {
+                return "不可修改";
+            }
+
+            step1Param.setPerformancesId(performanceId);
+            PerformancePartnerVo performancePartnerVo = new PerformancePartnerVo();
+            BeanUtils.copyProperties(step1Param, performancePartnerVo);
+            performancePartnerVo.setCreatedAt(timeNow.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            performancePartnerVo.setUpdatedAt(timeNow.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            performancePartnerVo.setIsSubmit(0);
+            performancePartnerVo.setStatus(0);
+            performancePartnerVo.setNoticeImage(dataUtils.getBuyNoticeJsonString(step1Param.getNoticeIds()));
+            performancePartnerVo.setFieldName((String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + performancePartnerVo.getFieldId(), "name"));
+            performancePartnerVo.setNoticeImage(dataUtils.getBuyNoticeJsonString(step1Param.getNoticeIds()));
+            if (data != null) { // 有修改记录
+                performancePartnerVo.setIsTrueName(data.getIsTrueName());
+                performancePartnerVo.setLimitCount(data.getLimitCount());
+                performancePartnerVo.setStatusSell(data.getStatusSell());
+                performancePartnerVo.setRoadShowId(data.getRoadShowId());
+                performancePartnerVo.setProjectId(data.getProjectId());
+                BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(performancePartnerVo));
+                mongoTemplate.getCollection(PerformancePartnerVo.class.getSimpleName()).updateOne(
+                        Query.query(Criteria.where("performancesId").is(performanceId)).getQueryObject(),
+                        object
+                );
+            } else { // 无修改记录
+                KylinPerformanceStatus statusData = performanceStatusMapper.selectOne(new UpdateWrapper<KylinPerformanceStatus>().eq("performanceId", performanceId));
+                KylinPerformanceRelations relationsData = performanceRelationsMapper.selectOne(new UpdateWrapper<KylinPerformanceRelations>().eq("performancesId", performanceId));
+                performancePartnerVo.setIsTrueName(statusData.getIsTrueName());
+                performancePartnerVo.setLimitCount(statusData.getLimitCount());
+                performancePartnerVo.setStatusSell(statusData.getStatusSell());
+                performancePartnerVo.setRoadShowId(relationsData.getRoadShowId());
+                performancePartnerVo.setProjectId(relationsData.getProjectId());
+                mongoTemplate.insert(
+                        performancePartnerVo, PerformancePartnerVo.class.getSimpleName()
+                );
+            }
+            return performanceId;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @Override
+    public ResponseDto<PerformancePartnerVo> getStep1(String performancesId) {
+        PerformancePartnerVo data = mongoTemplate.findOne(
+                Query.query(Criteria.where("performancesId").is(performancesId)), PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName()
+        );
+        KylinPerformanceStatus performanceStatus = performanceStatusMapper.selectOne(new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+        if (data == null) {
+            return ResponseDto.failure(ErrorMapping.get(20104));
+        }
+        if(null!=performanceStatus) {
+            data.setStatus(performanceStatus.getStatus());
+        }
+        return ResponseDto.success(data);
+    }
+
+    @Override
+    public ResponseDto<String> step2(PerformanceStep2Param step2Param) {
+        ResponseDto<String> result = null;
+        // 无 performancesId 则 创建
+        if (step2Param.getPerformancesId().isEmpty()) {
+        } else { // 获取 create 数据 status = 0 或 无数据 创建
+            KylinPerformanceStatus performanceStatus = performanceStatusMapper.selectOne(new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", step2Param.getPerformancesId()));
+            if (performanceStatus == null || performanceStatus.getStatus() == 0 || performanceStatus.getStatus() == 4) {
+                result = createStep2(step2Param);
+            } else if (performanceStatus.getStatus() == 1 || performanceStatus.getStatus() == 3 || performanceStatus.getStatus() == 6 || performanceStatus.getStatus() == 7 || performanceStatus.getStatus() == 8 || performanceStatus.getStatus() == 9 ) {// 修改
+                result = updateStep2(step2Param);
+            }else if(performanceStatus.getStatus() == 10){
+                result = ResponseDto.failure("演出已结束不可修改");
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public ResponseDto<String> createStep2(PerformanceStep2Param step2Param) {
+        try {
+            // 获取 主键id
+            String performanceId = step2Param.getPerformancesId();
+            // 获取 当前时间 -> 创建时间
+            LocalDateTime createdAt = LocalDateTime.now();
+
+            boolean isExistsSubmit = mongoTemplate.exists(Query.query(Criteria.where("performancesId").is(performanceId).and("auditStatus").is(0)),
+                    PerformancePartnerVo.class,
+                    PerformancePartnerVo.class.getSimpleName());
+
+            if (isExistsSubmit) {
+                return ResponseDto.failure(ErrorMapping.get(20112));
+            }
+
+            //演出修改数据
+            HashMap<String, Object> map = new HashMap<>();
+            map.put("isTrueName", step2Param.getIsTrueName());
+            map.put("limitCount", step2Param.getLimitCount());
+            map.put("createdAt", createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            map.put("isSubmit", step2Param.getIsSubmit());
+            map.put("statusSell", 1);
+
+            // 获取第一步数据
+            if (step2Param.getIsSubmit() == 1) { // 提交
+                map.put("status", 1);
+                map.put("isCreateSave", 0);
+                map.put("auditStatus", 0);
+                BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                mongoTemplate.getCollection(PerformancePartnerVo.class.getSimpleName()).updateOne(
+                        Query.query(Criteria.where("performancesId").is(performanceId)).getQueryObject(),
+                        object
+                );
+                //提交 票
+                List<KylinTicketTimesPartnerVo> kylinTicketTimesPartnerVoList = ticketTimesPartnerService.getTimesMongoList(performanceId);
+                for (KylinTicketTimesPartnerVo ticketTimes : kylinTicketTimesPartnerVoList) {
+                    boolean boolResult = ticketsPartnerService.submitTicketByTimes(ticketTimes.getTicketTimesId(), null);
+                    if (boolResult) {
+                        return ResponseDto.failure(ErrorMapping.get(20114));
+                    }
+                }
+                if (kylinTicketTimesPartnerVoList.size() <= 0) {
+                    return ResponseDto.failure(ErrorMapping.get(20113));
+                } else {
+                    KylinPerformanceMisVo kylinPerformanceMisVo = performanceVoTask.getPerformanceMisVo(performanceId);
+
+                    HashMap<String, Object> mapSql = new HashMap<>();
+                    mapSql.put("isCreateSave", 0);
+                    mapSql.put("rejectTxt", "");
+                    mapSql.put("status", 1);
+                    mapSql.put("updatedAt", createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+                    performanceVoTask.createPerformanceMySql(performanceId, mapSql, kylinPerformanceMisVo, createdAt);
+                    KylinPerformances performances = new KylinPerformances();
+                    performances.setAuditTime(LocalDateTime.now());
+                    performancesMapper.update(performances, new UpdateWrapper<KylinPerformances>().eq("performances_id", performanceId));
+                }
+                return ResponseDto.success("操作成功");
+            } else { //保存
+                map.put("status", 0);
+                map.put("isCreateSave", 1);
+                map.put("auditStatus", -1);
+                BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                mongoTemplate.getCollection(PerformancePartnerVo.class.getSimpleName()).updateMany(
+                        Query.query(Criteria.where("performancesId").is(performanceId)).getQueryObject(),
+                        object
+                );
+                return ResponseDto.success("保存成功");
+            }
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20115));
+        }
+    }
+
+    @Override
+    public ResponseDto<String> updateStep2(PerformanceStep2Param step2Param) {
+        try {
+            // 获取 主键id
+            String performanceId = step2Param.getPerformancesId();
+            // 获取 当前时间 -> 创建时间
+            LocalDateTime createdAt = LocalDateTime.now();
+
+            boolean isExistsSubmit = mongoTemplate.exists(Query.query(Criteria.where("performancesId").is(performanceId).and("auditStatus").is(0)),
+                    PerformancePartnerVo.class,
+                    PerformancePartnerVo.class.getSimpleName());
+
+            if (isExistsSubmit) {
+                return ResponseDto.failure(ErrorMapping.get(20112));
+            }
+
+            //演出修改数据
+            HashMap<String, Object> map = new HashMap<>();
+            map.put("isTrueName", step2Param.getIsTrueName());
+            map.put("limitCount", step2Param.getLimitCount());
+            map.put("createdAt", createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            map.put("updatedAt", createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            map.put("isSubmit", step2Param.getIsSubmit());
+
+            // 获取第一步数据
+            if (step2Param.getIsSubmit() == 1) { // 提交
+                if (performanceVoTask.judgeIsAudit(performanceId)) {
+                    map.put("auditStatus", 0);
+                    map.put("status", 1);
+                } else {
+                    map.put("auditStatus", 1);
+                    map.put("status", 9);
+                }
+                BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                mongoTemplate.getCollection(PerformancePartnerVo.class.getSimpleName()).updateOne(
+                        Query.query(Criteria.where("performancesId").is(performanceId)).getQueryObject(),
+                        object
+                );
+                //提交 票
+                List<KylinTicketTimesPartnerVo> kylinTicketTimesPartnerVoList = ticketTimesPartnerService.getTimesMongoList(performanceId);
+                for (KylinTicketTimesPartnerVo ticketTimes : kylinTicketTimesPartnerVoList) {
+                    boolean boolResult = ticketsPartnerService.submitTicketByTimes(ticketTimes.getTicketTimesId(), (int) (map.get("status")));
+                    if (boolResult) {
+                        return ResponseDto.failure(ErrorMapping.get(20114));
+                    }
+                }
+                if (kylinTicketTimesPartnerVoList.size() <= 0) {
+                    return ResponseDto.failure(ErrorMapping.get(20113));
+                } else {
+                    KylinPerformanceMisVo kylinPerformanceMisVo = performanceVoTask.getPerformanceMisVo(performanceId);
+
+                    HashMap<String, Object> mapSql = new HashMap<>();
+                    mapSql.put("rejectTxt", "");
+                    mapSql.put("status", map.get("status"));
+                    mapSql.put("updatedAt", createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+                    KylinPerformances performances = new KylinPerformances();
+                    performances.setAuditTime(LocalDateTime.now());
+                    performances.setNoticeImage(kylinPerformanceMisVo.getNoticeImage());
+                    performancesMapper.update(performances, new UpdateWrapper<KylinPerformances>().eq("performances_id", performanceId));
+                    KylinPerformanceStatus performanceStatus = new KylinPerformanceStatus();
+                    performanceStatus.setAuditStatus((int) map.get("auditStatus"));
+                    performanceStatus.setIsTrueName(step2Param.getIsTrueName());
+                    performanceStatus.setLimitCount(step2Param.getLimitCount());
+                    performanceStatusMapper.update(performanceStatus, new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performanceId));
+
+                    //提示：票种价格、售票时间、票种购票限制 直接生效 (演出购票限制，购票须知 演出是否实名 票种缺货登记 票种是否电子票 票种是否快递票 票种最低购买张数 票种是否显示二维码)
+                    List<TicketTimesTicketCreatePartnerVo> timeList = kylinPerformanceMisVo.getTicketTimes();
+                    for (TicketTimesTicketCreatePartnerVo timesItem : timeList) {
+                        List<KylinTicketPartnerVo> ticketList = timesItem.getTicket();
+                        for (KylinTicketPartnerVo ticketItem : ticketList) {
+                            //修改 redis库存
+                            if (redisUtil.hasKey(KylinRedisConst.PERFORMANCES_INVENTORY + ticketItem.getTicketsId() + ":" + KylinRedisConst.SURPLUS_GENERAL)) {
+                                KylinTicketStatus ticketStatus = ticketStatusMapper.selectOne(new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", ticketItem.getTicketsId()));
+                                int changeGeneral = ticketItem.getTotalGeneral() - ticketStatus.getTotalGeneral();
+                                int changeExchange = ticketItem.getTotalExchange() - ticketStatus.getTotalExchange();
+                                log.debug("ticketItem.getTotalGeneral() = " + ticketItem.getTotalGeneral());
+                                log.debug("ticketStatus.getTotalGeneral() = " + ticketStatus.getTotalGeneral());
+                                dataUtils.changeSurplusGeneral(ticketItem.getTicketsId(), changeGeneral);
+                                dataUtils.changeSurplusExchange(ticketItem.getTicketsId(), changeExchange);
+                            }
+                            //修改 mysql 库存
+                            KylinTicketStatus inventory = new KylinTicketStatus();
+                            inventory.setTotalExchange(ticketItem.getTotalExchange());
+                            inventory.setTotalGeneral(ticketItem.getTotalGeneral());
+                            inventory.setIsTrueName(kylinPerformanceMisVo.getIsTrueName());
+                            inventory.setLimitCount(ticketItem.getLimitCount());
+                            inventory.setIsLackRegister(ticketItem.getIsLackRegister());
+                            inventory.setIsExpress(ticketItem.getIsExpress());
+                            inventory.setIsElectronic(ticketItem.getIsElectronic());
+                            inventory.setCounts(ticketItem.getCounts());
+                            inventory.setIsShowCode(ticketItem.getIsShowCode());
+                            inventory.setQrCodeShowTime(DateUtil.Formatter.yyyyMMddHHmmss.parse(ticketItem.getQrCodeShowTime()));
+
+                            //修改 mysql 售卖时间
+                            KylinTickets ticketSellTime = new KylinTickets();
+                            ticketSellTime.setTimeEnd(DateUtil.Formatter.yyyyMMddHHmmss.parse(ticketItem.getTimeEnd()));
+                            ticketSellTime.setTimeStart(DateUtil.Formatter.yyyyMMddHHmmss.parse(ticketItem.getTimeStart()));
+                            ticketSellTime.setAdvanceMinuteMember(null);
+                            ticketSellTime.setPayCountdownMinute(kylinPerformanceMisVo.getPayCountdownMinute());
+                            //修改 价格
+                            ticketSellTime.setPrice(ticketItem.getPrice());
+                            ticketSellTime.setPriceDiscountMember(null);
+                            ticketsMapper.update(ticketSellTime, new UpdateWrapper<KylinTickets>().eq("tickets_id", ticketItem.getTicketsId()));
+                            //修改 mysql 购票限购
+                            ticketStatusMapper.update(inventory, new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", ticketItem.getTicketsId()));
+                        }
+                    }
+                    performanceVoTask.performanceVoStatus(performanceId);
+                }
+                return ResponseDto.success("操作完成");
+            } else { //保存
+                map.put("status", 0);
+                map.put("auditStatus", -1);
+                BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                mongoTemplate.getCollection(PerformancePartnerVo.class.getSimpleName()).updateMany(
+                        Query.query(Criteria.where("performancesId").is(performanceId)).getQueryObject(),
+                        object
+                );
+                return ResponseDto.success("保存成功");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseDto.failure(ErrorMapping.get(20115));
+        }
+    }
+
+    @Override
+    public ResponseDto<PerformanceStep2Param> getStep2(String performancesId) {
+        PerformancePartnerVo data = mongoTemplate.findOne(
+                Query.query(Criteria.where("performancesId").is(performancesId)), PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName()
+        );
+        if (data == null) {
+            return ResponseDto.failure(ErrorMapping.get(20104));
+        }
+        List<KylinTicketTimesPartnerVo> kylinTicketTimesPartnerVos = ticketTimesPartnerService.getTimesMongoList(performancesId);
+        List<TicketTimesTicketCreatePartnerVo> ticketTimesTicketCreatePartnerVoList = new ArrayList<TicketTimesTicketCreatePartnerVo>();
+
+        for (KylinTicketTimesPartnerVo ticketTimes : kylinTicketTimesPartnerVos) {
+            TicketTimesTicketCreatePartnerVo ticketTimesTicketCreatePartnerVo = new TicketTimesTicketCreatePartnerVo();
+            BeanUtils.copyProperties(ticketTimes, ticketTimesTicketCreatePartnerVo);
+            List<KylinTicketPartnerVo> kylinTicketPartnerVos = ticketsPartnerService.getTicketMongoList(ticketTimes.getTicketTimesId());
+            ticketTimesTicketCreatePartnerVo.setTicket(kylinTicketPartnerVos);
+            ticketTimesTicketCreatePartnerVoList.add(ticketTimesTicketCreatePartnerVo);
+        }
+
+        PerformanceStep2Param performanceStep2Param = new PerformanceStep2Param();
+        BeanUtils.copyProperties(data, performanceStep2Param);
+        KylinPerformanceStatus performanceStatus = performanceStatusMapper.selectOne(new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+        if(null!=performanceStatus) {
+            performanceStep2Param.setStatus(performanceStatus.getStatus());
+        }else{
+            performanceStep2Param.setStatus(-1);
+        }
+
+        performanceStep2Param.setTicketTimes(ticketTimesTicketCreatePartnerVoList);
+        return ResponseDto.success(performanceStep2Param);
+    }
+
+    @Override
+    public ResponseDto<String> onLinePerformance(String performancesId) {
+        try {
+            KylinPerformanceStatus performanceStatusData = performanceStatusMapper.selectOne(new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+            if (!(performanceStatusData.getStatus() == 3 || performanceStatusData.getStatus() == 7)) {
+                return ResponseDto.failure(ErrorMapping.get(20110));
+            }
+            // mysql
+            LocalDateTime updatedAt = LocalDateTime.now();
+            KylinPerformanceStatus performanceStatusUpdate = new KylinPerformanceStatus();
+            performanceStatusUpdate.setStatus(6);
+            performanceStatusUpdate.setUpdatedAt(updatedAt);
+            performanceStatusMapper.update(performanceStatusUpdate
+                    , new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+
+            //场次
+            List<KylinTicketTimeRelation> ticketTimeRelation = ticketTimeRelationMapper.selectList(
+                    new UpdateWrapper<KylinTicketTimeRelation>().eq("performance_id", performancesId)
+            );
+
+
+            for (KylinTicketTimeRelation ticketTimeRelationItem : ticketTimeRelation) {
+                KylinTicketTimes ticketTimes = ticketTimesMapper.selectOne(new UpdateWrapper<KylinTicketTimes>().eq("ticket_times_id", ticketTimeRelationItem.getTimesId()).eq("status", 1));
+                //票
+                List<KylinTicketRelations> ticketRelations = ticketRelationsMapper.selectList(new UpdateWrapper<KylinTicketRelations>().eq("times_id", ticketTimes.getTicketTimesId()));
+                for (KylinTicketRelations ticketRelationsItem : ticketRelations) {
+                    KylinTicketStatus ticketStatusUpdate = new KylinTicketStatus();
+                    ticketStatusUpdate.setStatus(9);
+                    ticketStatusUpdate.setUpdatedAt(updatedAt);
+                    ticketStatusMapper.update(ticketStatusUpdate
+                            , new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", ticketRelationsItem.getTicketId()).eq("status", 7));
+
+                    HashMap<String, Object> map = new HashMap<>();
+                    map.put("status", 9);
+                    map.put("updatedAt", updatedAt);
+                    mongoTemplate.getCollection(KylinTicketPartnerVo.class.getSimpleName()).updateOne(
+                            Query.query(Criteria.where("ticketsId").is(ticketRelationsItem.getTicketId()).and("status").ne(7)).getQueryObject(),
+                            new BasicDBObject("$set", mongoConverter.convertToMongoType(map))
+                    );
+                }
+            }
+//            判断状态
+            performanceVoTask.performanceVoStatus(performancesId);
+            return ResponseDto.success("上线成功");
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseDto.failure(ErrorMapping.get(20108));
+        }
+    }
+
+    @Override
+    public ResponseDto<String> outLinePerformance(String performancesId) {
+        try {
+
+            KylinPerformanceStatus performanceStatusData = performanceStatusMapper.selectOne(new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+
+            if (performanceStatusData.getStatus() >= 3 && performanceStatusData.getStatus() != 4 && performanceStatusData.getStatus() != 7 && performanceStatusData.getStatus() != 10) {//未提审||被拒绝
+                LocalDateTime updatedAt = LocalDateTime.now();
+                KylinPerformanceStatus performanceStatus = new KylinPerformanceStatus();
+                performanceStatus.setStatus(7);
+                performanceStatus.setUpdatedAt(updatedAt);
+                performanceStatusMapper.update(performanceStatus
+                        , new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+
+                performanceVoTask.performanceVoStatus(performancesId);
+//                dataUtils.updatePerformanceMongo(performancesId);
+                return ResponseDto.success("下线成功");
+            } else {
+                return ResponseDto.failure(ErrorMapping.get(20111));
+            }
+
+
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20109));
+        }
+    }
+
+    @Override
+    public String copyPerformance(String performancesId) {
+        try {
+            PerformancePartnerVo performancePartnerVo = mongoTemplate.findOne(Query.query(Criteria.where("performancesId").is(performancesId)), PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName());
+            //复制演出
+            performancePartnerVo.setPerformancesId(IDGenerator.nextSnowId().toString());
+            performancePartnerVo.setStatus(0);
+            performancePartnerVo.setAuditStatus(-1);
+            performancePartnerVo.setIsCreateSave(1);
+            mongoTemplate.insert(performancePartnerVo, PerformancePartnerVo.class.getSimpleName());
+
+            List<KylinTicketTimesPartnerVo> kylinTicketTimesPartnerVos = mongoTemplate.find(Query.query(Criteria.where("performancesId").is(performancesId)), KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+            for (KylinTicketTimesPartnerVo timeItem : kylinTicketTimesPartnerVos) {
+                //复制场次
+                String timesId = timeItem.getTicketTimesId();
+                timeItem.setTicketTimesId(IDGenerator.nextSnowId().toString());
+                timeItem.setPerformancesId(performancePartnerVo.getPerformancesId());
+                mongoTemplate.insert(timeItem, KylinTicketTimesPartnerVo.class.getSimpleName());
+
+                List<KylinTicketPartnerVo> kylinTicketPartnerVos = mongoTemplate.find(Query.query(Criteria.where("timesId").is(timesId)), KylinTicketPartnerVo.class, KylinTicketPartnerVo.class.getSimpleName());
+                for (KylinTicketPartnerVo ticketItem : kylinTicketPartnerVos) {
+                    //复制票
+                    ticketItem.setStatus(0);
+                    ticketItem.setTimesId(timeItem.getTicketTimesId());
+                    ticketItem.setTicketsId(IDGenerator.nextSnowId().toString());
+                    mongoTemplate.insert(ticketItem, KylinTicketPartnerVo.class.getSimpleName());
+                }
+            }
+            return performancePartnerVo.getPerformancesId();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    @Override
+    public ResponseDto<PageInfo<PerformancePartnerListDao>> getList(PerformancePartnerListParam performancePartnerListParam) {
+        int status = performancePartnerListParam.getStatus();
+        int page = performancePartnerListParam.getPage() - 1;
+        int size = performancePartnerListParam.getSize();
+        PageInfo<PerformancePartnerListDao> pageInfoTmp = null;
+        if (status == 0) {//未发布演出
+            // 排序 分页
+            Pageable pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.DESC, "createdAt"));
+            //条件
+            Criteria criteria = Criteria.where("status").is(status).and("isCreateSave").is(1);
+            if (!performancePartnerListParam.getTitle().isEmpty()) {
+                criteria.and("title").regex(".*?\\" + performancePartnerListParam.getTitle());
+            }
+            Query query = Query.query(criteria);
+            // 查询总数
+            long count = mongoTemplate.count(query, PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName());
+            List<PerformancePartnerVo> performancePartnerVo = mongoTemplate.find(query, PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName());
+            query.with(pageable);
+            //处理Vo
+            List<KylinPerformancePartnerListVo> voList = new ArrayList<>();
+            for (PerformancePartnerVo item : performancePartnerVo) {
+                KylinPerformancePartnerListVo voData = new KylinPerformancePartnerListVo();
+                voData.setStatus0Data(item);
+                voList.add(voData);
+            }
+            pageInfoTmp = new PageInfo(voList);
+            pageInfoTmp.setTotal(count);
+        } else {//演出列表
+            try {
+                PageHelper.startPage(performancePartnerListParam.getPage(), performancePartnerListParam.getSize());
+                List<PerformancePartnerListDao> voList = performancesMapper.partnerPerformanceList(BeanUtil.convertBeanToMap(performancePartnerListParam));
+                for (int i = 0; i < voList.size(); i++) {
+                    PerformancePartnerListDao vo = voList.get(i);
+                    if (vo.getStatus() >= 6 && vo.getStatus() != 7) {
+                        if (DateUtil.compareStrDay(vo.getTimeSell(), DateUtil.getNowTime()) > 0) {//未开始
+                            vo.setStatus(9);
+                        } else if (DateUtil.compareStrDay(vo.getTimeStop(), DateUtil.getNowTime()) < 0) {//已结束
+                            vo.setStatus(10);
+                        } else {
+                            vo.setStatus(6);
+                        }
+                    }
+                }
+                pageInfoTmp = new PageInfo(voList);
+            } catch (Exception e) {
+                e.printStackTrace();
+                return ResponseDto.failure(ErrorMapping.get(20104));
+            }
+        }
+        return ResponseDto.success(pageInfoTmp);
+    }
+
+    @Override
+    public ResponseDto<String> withdraw(String performancesId) {
+        try {
+            //mysql auditStatus
+            KylinPerformanceStatus performanceStatus = performanceStatusMapper.selectOne(new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+            if (performanceStatus != null && performanceStatus.getAuditStatus() == 0) {
+                KylinPerformanceStatus data1 = new KylinPerformanceStatus();
+                HashMap<String, Object> map = new HashMap<>();
+                if (performanceStatus.getStatus() >= 3) {//通过审核
+                    data1.setAuditStatus(1);
+                    data1.setStatus(null);
+                    map.put("auditStatus", 1);
+                } else if (performanceStatus.getStatus() == 4 || performanceStatus.getStatus() == 1) {//未通过审核
+                    data1.setAuditStatus(-1);
+                    data1.setStatus(0);
+                    map.put("auditStatus", -1);
+                    map.put("status", 0);
+                } else {
+                    data1.setAuditStatus(2);
+                    data1.setStatus(null);
+                    map.put("auditStatus", 2);
+                }
+                performanceStatusMapper.update(data1, new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+                BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                mongoTemplate.getCollection(PerformancePartnerVo.class.getSimpleName()).updateOne(
+                        Query.query(Criteria.where("performancesId").is(performancesId)).getQueryObject(),
+                        object
+                );
+                return ResponseDto.success("撤回成功");
+            } else {
+                return ResponseDto.failure(ErrorMapping.get(20116));
+            }
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20117));
+        }
+    }
+
+    @Override
+    public List<PerformanceOrderStatisticalVo> getPerformanceOrderStatisticalList(String performancesId) {
+        PerformanceOrderStatisticalDao countBean = new PerformanceOrderStatisticalDao();
+        countBean.setTitle("总计：");
+
+        List<PerformanceOrderStatisticalVo> voList = new ArrayList<>();
+        List<PerformanceOrderStatisticalDao> dtoList = performancesMapper.getPerformanceOrderStatisticalList(performancesId);
+        dtoList.forEach(dto -> {
+            PerformanceOrderStatisticalVo vo = new PerformanceOrderStatisticalVo();
+            BeanUtil.copy(dto, vo);
+            voList.add(vo);
+
+            countBean.setTotalGeneral(countBean.getTotalGeneral().add(dto.getTotalGeneral()));
+            countBean.setSaleGeneral(countBean.getSaleGeneral().add(dto.getSaleGeneral()));
+            countBean.setSurplusGeneral(countBean.getSurplusGeneral().add(dto.getSurplusGeneral()));
+            countBean.setTotalSalePrice(countBean.getTotalSalePrice().add(dto.getTotalSalePrice()));
+            countBean.setTotalExchange(countBean.getTotalExchange().add(dto.getTotalExchange()));
+            countBean.setTotalRefundGeneral(countBean.getTotalRefundGeneral().add(dto.getTotalRefundGeneral()));
+            countBean.setTotalRefundPrice(countBean.getTotalRefundPrice().add(dto.getTotalRefundPrice()));
+            countBean.setTotalMemberNumber(countBean.getTotalMemberNumber().add(dto.getTotalMemberNumber()));
+            countBean.setTotalPayingNumber(countBean.getTotalPayingNumber().add(dto.getTotalPayingNumber()));
+            countBean.setTotalBuyUsers(dto.getTotalBuyUsers());
+        });
+        PerformanceOrderStatisticalVo vo = new PerformanceOrderStatisticalVo();
+        BeanUtil.copy(countBean, vo);
+        voList.add(vo);
+        return voList;
+    }
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/impl/KylinTicketTimesPartnerServiceImpl.java

+package com.liquidnet.service.kylin.partner.impl;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.liquidnet.commons.lang.util.IDGenerator;
+import com.liquidnet.commons.lang.util.JsonUtils;
+import com.liquidnet.service.base.ErrorMapping;
+import com.liquidnet.service.base.ResponseDto;
+import com.liquidnet.service.kylin.dto.param.CreateTicketTimesParam;
+import com.liquidnet.service.kylin.dto.vo.partner.KylinTicketTimesPartnerVo;
+import com.liquidnet.service.kylin.entity.KylinPerformanceStatus;
+import com.liquidnet.service.kylin.entity.KylinTicketTimeRelation;
+import com.liquidnet.service.kylin.entity.KylinTicketTimes;
+import com.liquidnet.service.kylin.mapper.KylinPerformanceStatusMapper;
+import com.liquidnet.service.kylin.mapper.KylinTicketTimeRelationMapper;
+import com.liquidnet.service.kylin.mapper.KylinTicketTimesMapper;
+import com.liquidnet.service.kylin.service.partner.IKylinTicketTimesPartnerService;
+import com.mongodb.BasicDBObject;
+import com.mongodb.client.model.FindOneAndUpdateOptions;
+import com.mongodb.client.model.ReturnDocument;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.Document;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * <p>
+ * 场次 服务实现类
+ * </p>
+ *
+ * @author liquidnet
+ * @since 2021-05-06
+ */
+@Service
+@Slf4j
+public class KylinTicketTimesPartnerServiceImpl extends ServiceImpl<KylinTicketTimesMapper, KylinTicketTimes> implements IKylinTicketTimesPartnerService {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private MongoConverter mongoConverter;
+
+    @Autowired
+    private KylinTicketTimeRelationMapper ticketTimeRelationMapper;
+
+    @Autowired
+    private KylinPerformanceStatusMapper performanceStatusMapper;
+
+    @Override
+    public ResponseDto<KylinTicketTimesPartnerVo> createTimesSummary(CreateTicketTimesParam createTicketTimesParam) {
+        ResponseDto<KylinTicketTimesPartnerVo> ticketTimesPartnerVo = null;
+        //获取演出状态
+        KylinPerformanceStatus performanceStatus = performanceStatusMapper.selectOne(
+                new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", createTicketTimesParam.getPerformancesId()));
+        if (null == performanceStatus) {
+            ticketTimesPartnerVo = createTimes(createTicketTimesParam);
+        } else if(performanceStatus.getAuditStatus()==0){
+            return ResponseDto.failure(ErrorMapping.get(20101));
+        }else if (performanceStatus.getStatus() >= 3 && performanceStatus.getStatus() != 4) {//未被拒绝 且 通过审核的演出
+            ticketTimesPartnerVo = addNewTimes(createTicketTimesParam);
+        } else {
+            ticketTimesPartnerVo = createTimes(createTicketTimesParam);
+        }
+        return ticketTimesPartnerVo;
+    }
+
+    @Override
+    public ResponseDto<KylinTicketTimesPartnerVo> createTimes(CreateTicketTimesParam createTicketTimesParam) {
+        try {
+            // 获取 主键id
+            String ticketTimesId = IDGenerator.nextSnowId().toString();
+            // 获取 当前时间 -> 创建时间
+            LocalDateTime createdAt = LocalDateTime.now();
+            // 标题
+            String title = "";
+            String useStart;
+            String useEnd;
+            if (createTicketTimesParam.getType() == 1) {
+                useStart = createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
+                useEnd = createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
+                title = useStart;
+            } else {
+                useStart = createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
+                useEnd = createTicketTimesParam.getUseEnd().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
+                title = useStart + "-" + useEnd;
+            }
+            // mongo 操作
+            KylinTicketTimesPartnerVo kylinTicketTimesPartnerVo = new KylinTicketTimesPartnerVo();
+            kylinTicketTimesPartnerVo.setTicketTimesId(ticketTimesId);
+            kylinTicketTimesPartnerVo.setUseStart(createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            if(createTicketTimesParam.getType() == 2) {
+                kylinTicketTimesPartnerVo.setUseEnd(createTicketTimesParam.getUseEnd().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            }else{
+                kylinTicketTimesPartnerVo.setUseEnd(createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            }
+            kylinTicketTimesPartnerVo.setStatus(1);
+            kylinTicketTimesPartnerVo.setTitle(title);
+            kylinTicketTimesPartnerVo.setPerformancesId(createTicketTimesParam.getPerformancesId());
+            kylinTicketTimesPartnerVo.setType(createTicketTimesParam.getType());
+            kylinTicketTimesPartnerVo.setCreatedAt(createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            mongoTemplate.insert(
+                    kylinTicketTimesPartnerVo, KylinTicketTimesPartnerVo.class.getSimpleName()
+            );
+
+            return ResponseDto.success(kylinTicketTimesPartnerVo);
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20105));
+        }
+    }
+
+    @Override
+    public ResponseDto<KylinTicketTimesPartnerVo> addNewTimes(CreateTicketTimesParam createTicketTimesParam) {
+        try {
+            // 获取 主键id
+            String ticketTimesId = IDGenerator.nextSnowId().toString();
+            // 获取 当前时间 -> 创建时间
+            LocalDateTime createdAt = LocalDateTime.now();
+            // 标题
+            String title = "";
+            String useStart = createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
+            String useEnd = createTicketTimesParam.getUseEnd().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
+            if (createTicketTimesParam.getType() == 1) {
+                if(!useStart.split(" ")[0].equals(useEnd.split(" ")[0])){
+                    return ResponseDto.failure(ErrorMapping.get(20118));
+                }
+                title = useStart;
+            } else {
+                title = useStart + "-" + useEnd;
+            }
+
+            // mongo 操作
+            KylinTicketTimesPartnerVo kylinTicketTimesPartnerVo = new KylinTicketTimesPartnerVo();
+            kylinTicketTimesPartnerVo.setTicketTimesId(ticketTimesId);
+            kylinTicketTimesPartnerVo.setUseStart(createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketTimesPartnerVo.setUseEnd(createTicketTimesParam.getUseEnd().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketTimesPartnerVo.setStatus(-1);
+            kylinTicketTimesPartnerVo.setTitle(title);
+            kylinTicketTimesPartnerVo.setPerformancesId(createTicketTimesParam.getPerformancesId());
+            kylinTicketTimesPartnerVo.setType(createTicketTimesParam.getType());
+            kylinTicketTimesPartnerVo.setCreatedAt(createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            mongoTemplate.insert(
+                    kylinTicketTimesPartnerVo, KylinTicketTimesPartnerVo.class.getSimpleName()
+            );
+            return ResponseDto.success(kylinTicketTimesPartnerVo);
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20101));
+        }
+    }
+
+    @Override
+    public ResponseDto<String> deleteTimes(String ticketTimesId) {
+        try {
+            LocalDateTime updatedAt = LocalDateTime.now();
+
+            KylinTicketTimesPartnerVo data = mongoTemplate.findOne(Query.query(Criteria.where("ticketTimesId").is(ticketTimesId)), KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+            if (data.getStatus() == 0) {
+                return ResponseDto.failure(ErrorMapping.get(20106));
+            }
+            KylinTicketTimeRelation ticketTimeRelation = ticketTimeRelationMapper.selectOne(
+                    new UpdateWrapper<KylinTicketTimeRelation>().eq("times_id", ticketTimesId));
+            if (ticketTimeRelation != null) {
+                KylinPerformanceStatus performanceStatus = performanceStatusMapper.selectOne(
+                        new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", ticketTimeRelation.getPerformanceId()));
+                if(performanceStatus.getAuditStatus()==0){
+                    return ResponseDto.failure(ErrorMapping.get(20101));
+                }
+
+                if (performanceStatus.getStatus() == 0 || performanceStatus.getStatus() == 4) {//未提审||被拒绝
+                    HashMap<String, Object> map = new HashMap<>();
+                    map.put("updatedAt", updatedAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+                    map.put("status", 0);
+
+                    BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                    Document doc = mongoTemplate.getCollection(KylinTicketTimesPartnerVo.class.getSimpleName()).findOneAndUpdate(
+                            Query.query(Criteria.where("ticketTimesId").is(ticketTimesId)).getQueryObject(),
+                            object,
+                            new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER)
+                    );
+                    return ResponseDto.success("删除成功");
+                } else {
+                    return ResponseDto.failure(ErrorMapping.get(20106));
+                }
+            } else {
+                mongoTemplate.remove(Query.query(Criteria.where("ticketTimesId").is(ticketTimesId)), KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+                return ResponseDto.success();
+            }
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20102));
+        }
+    }
+
+    @Override
+    public ResponseDto<KylinTicketTimesPartnerVo> changeTimes(CreateTicketTimesParam createTicketTimesParam) {
+        try {
+            LocalDateTime updatedAt = LocalDateTime.now();
+            String title = "";
+            if (createTicketTimesParam.getType() == 1) {
+                title = createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
+            } else {
+                title = createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")) + "-" + createTicketTimesParam.getUseEnd().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
+            }
+            createTicketTimesParam.setTitle(title);
+
+            // mongo 操作
+            KylinTicketTimesPartnerVo kylinTicketTimesPartnerVo = new KylinTicketTimesPartnerVo();
+            BeanUtils.copyProperties(createTicketTimesParam, kylinTicketTimesPartnerVo);
+            kylinTicketTimesPartnerVo.setTicketTimesId(createTicketTimesParam.getTicketTimesId());
+            kylinTicketTimesPartnerVo.setUpdatedAt(updatedAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketTimesPartnerVo.setUseStart(createTicketTimesParam.getUseStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketTimesPartnerVo.setUseEnd(createTicketTimesParam.getUseEnd().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketTimesPartnerVo.setStatus(null);
+
+            BasicDBObject object = new BasicDBObject("$set", JSON.parse(JsonUtils.toJson(kylinTicketTimesPartnerVo)));
+            Document doc = mongoTemplate.getCollection(KylinTicketTimesPartnerVo.class.getSimpleName()).findOneAndUpdate(
+                    Query.query(Criteria.where("ticketTimesId").is(createTicketTimesParam.getTicketTimesId())).getQueryObject(),
+                    object,
+                    new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER)
+            );
+            return ResponseDto.success(JsonUtils.fromJson(doc.toJson(), KylinTicketTimesPartnerVo.class));
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20103));
+        }
+    }
+
+    @Override
+    public List<KylinTicketTimesPartnerVo> getTimesMongoList(String performancesId) {
+        return mongoTemplate.find(Query.query(Criteria.where("performancesId").is(performancesId).and("status").ne(0)), KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+    }
+
+    @Override
+    public KylinTicketTimesPartnerVo getTimesMongo(String timesId) {
+        return mongoTemplate.findOne(Query.query(Criteria.where("ticketTimesId").is(timesId).and("status")), KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+    }
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/impl/KylinTicketsPartnerServiceImpl.java

+package com.liquidnet.service.kylin.partner.impl;
+
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.liquidnet.commons.lang.util.DateUtil;
+import com.liquidnet.commons.lang.util.IDGenerator;
+import com.liquidnet.commons.lang.util.JsonUtils;
+import com.liquidnet.service.base.ErrorMapping;
+import com.liquidnet.service.base.ResponseDto;
+import com.liquidnet.service.kylin.dto.param.PerformancePartnerVo;
+import com.liquidnet.service.kylin.dto.param.TicketCreateParam;
+import com.liquidnet.service.kylin.dto.vo.partner.KylinTicketPartnerVo;
+import com.liquidnet.service.kylin.dto.vo.partner.KylinTicketTimesPartnerVo;
+import com.liquidnet.service.kylin.entity.*;
+import com.liquidnet.service.kylin.mapper.*;
+import com.liquidnet.service.kylin.partner.utils.PerformanceVoTask;
+import com.liquidnet.service.kylin.service.partner.IKylinTicketsPartnerService;
+import com.mongodb.BasicDBObject;
+import com.mongodb.client.model.FindOneAndUpdateOptions;
+import com.mongodb.client.model.ReturnDocument;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.Document;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * <p>
+ * 票 服务实现类
+ * </p>
+ *
+ * @author liquidnet
+ * @since 2021-05-06
+ */
+@Service
+@Slf4j
+public class KylinTicketsPartnerServiceImpl extends ServiceImpl<KylinTicketsMapper, KylinTickets> implements IKylinTicketsPartnerService {
+
+    @Autowired
+    MongoTemplate mongoTemplate;
+
+    @Autowired
+    private MongoConverter mongoConverter;
+
+    @Autowired
+    private KylinPerformanceStatusMapper performanceStatusMapper;
+
+    @Autowired
+    private KylinTicketTimeRelationMapper ticketTimeRelationMapper;
+
+
+    @Autowired
+    private KylinTicketStatusMapper ticketStatusMapper;
+
+    @Autowired
+    private KylinTicketRelationsMapper ticketRelationsMapper;
+    @Autowired
+    private PerformanceVoTask performanceVoTask;
+
+    @Override
+    public ResponseDto<KylinTicketPartnerVo> createTicketSummary(TicketCreateParam ticketCreateParam) {
+        ResponseDto<KylinTicketPartnerVo> ticketPartnerVo = null;
+        //获取演出状态
+        KylinTicketTimesPartnerVo timesPartnerVo = mongoTemplate.findOne(Query.query(Criteria.where("ticketTimesId").is(ticketCreateParam.getTimesId())), KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+
+        if (null != timesPartnerVo) {
+            KylinPerformanceStatus performanceStatus = performanceStatusMapper.selectOne(
+                    new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", timesPartnerVo.getPerformancesId()));
+            if (null == performanceStatus) {
+                ticketPartnerVo = createTicket(ticketCreateParam);
+            } else if (performanceStatus.getStatus() >= 3 && performanceStatus.getStatus() != 4) {//未被拒绝 且 通过审核的演出
+                ticketPartnerVo = addNewTicket(ticketCreateParam);
+            } else {
+                ticketPartnerVo = createTicket(ticketCreateParam);
+            }
+        } else {
+            ticketPartnerVo = createTicket(ticketCreateParam);
+        }
+        return ticketPartnerVo;
+    }
+
+    @Override
+    public ResponseDto<KylinTicketPartnerVo> createTicket(TicketCreateParam ticketCreateParam) {
+        try {
+            // 获取 主键id
+            String ticketsId = IDGenerator.nextSnowId().toString();
+            // 获取 当前时间 -> 创建时间
+            LocalDateTime createdAt = LocalDateTime.now();
+            ticketCreateParam.setTicketsId(ticketsId);
+
+            // mongo 操作
+            KylinTicketPartnerVo kylinTicketPartnerVo = new KylinTicketPartnerVo();
+            BeanUtils.copyProperties(ticketCreateParam, kylinTicketPartnerVo);
+            kylinTicketPartnerVo.setTicketsId(ticketsId);
+            kylinTicketPartnerVo.setCreatedAt(DateUtil.Formatter.yyyyMMddHHmmss.format(createdAt));
+            kylinTicketPartnerVo.setTimeStart(DateUtil.Formatter.yyyyMMddHHmmss.format(ticketCreateParam.getTimeStart()));
+            kylinTicketPartnerVo.setTimeEnd(ticketCreateParam.getTimeEnd().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+
+            KylinTicketTimesPartnerVo kylinTicketTimesPartnerVo = mongoTemplate.findOne(Query.query(Criteria.where("ticketTimesId").is(ticketCreateParam.getTimesId())), KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+            kylinTicketPartnerVo.setUseStart(kylinTicketTimesPartnerVo.getUseStart());
+            kylinTicketPartnerVo.setUseEnd(kylinTicketTimesPartnerVo.getUseEnd());
+            kylinTicketPartnerVo.setType(kylinTicketTimesPartnerVo.getType());
+            kylinTicketPartnerVo.setStatus(0);
+            kylinTicketPartnerVo.setDefault();
+            if (ticketCreateParam.getIsExpress() == 1) {
+                kylinTicketPartnerVo.setDescribeExpress(ticketCreateParam.getDescribeExpress()==null?"":ticketCreateParam.getDescribeExpress());
+            } else {
+                kylinTicketPartnerVo.setDescribeExpress("");
+            }
+            if (ticketCreateParam.getIsElectronic() == 1) {
+                kylinTicketPartnerVo.setDescribeElectronic(ticketCreateParam.getDescribeElectronic()==null?"":ticketCreateParam.getDescribeElectronic());
+            } else {
+                kylinTicketPartnerVo.setDescribeElectronic("");
+            }
+
+            if (ticketCreateParam.getIsExpress() == 1) {
+                kylinTicketPartnerVo.setTimeEndExpress(ticketCreateParam.getTimeEndExpress().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            }
+
+            if (ticketCreateParam.getIsShowCode() == 1) {
+                kylinTicketPartnerVo.setQrCodeShowTime(ticketCreateParam.getQrCodeShowTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            }
+
+            KylinTicketPartnerVo data = mongoTemplate.insert(
+                    kylinTicketPartnerVo, KylinTicketPartnerVo.class.getSimpleName()
+            );
+
+            return ResponseDto.success(kylinTicketPartnerVo);
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20105));
+        }
+    }
+
+    @Override
+    public ResponseDto<KylinTicketPartnerVo> addNewTicket(TicketCreateParam ticketCreateParam) {
+        try {
+            // 获取 主键id
+            String ticketsId = IDGenerator.nextSnowId().toString();
+            // 获取 当前时间 -> 创建时间
+            LocalDateTime createdAt = LocalDateTime.now();
+            ticketCreateParam.setTicketsId(ticketsId);
+
+            // mongo 操作
+            KylinTicketPartnerVo kylinTicketPartnerVo = new KylinTicketPartnerVo();
+            BeanUtils.copyProperties(ticketCreateParam, kylinTicketPartnerVo);
+            kylinTicketPartnerVo.setTicketsId(ticketsId);
+            kylinTicketPartnerVo.setCreatedAt(createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketPartnerVo.setTimeStart(ticketCreateParam.getTimeStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketPartnerVo.setTimeEnd(ticketCreateParam.getTimeEnd().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+
+            KylinTicketTimesPartnerVo kylinTicketTimesPartnerVo = mongoTemplate.findOne(Query.query(Criteria.where("ticketTimesId").is(ticketCreateParam.getTimesId())), KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+            kylinTicketPartnerVo.setUseStart(kylinTicketTimesPartnerVo.getUseStart());
+            kylinTicketPartnerVo.setUseEnd(kylinTicketTimesPartnerVo.getUseEnd());
+            kylinTicketPartnerVo.setType(kylinTicketTimesPartnerVo.getType());
+            if (ticketCreateParam.getIsExpress() == 1) {
+                kylinTicketPartnerVo.setDescribeExpress(ticketCreateParam.getDescribeExpress()==null?"":ticketCreateParam.getDescribeExpress());
+            } else {
+                kylinTicketPartnerVo.setDescribeExpress("");
+            }
+            if (ticketCreateParam.getIsElectronic() == 1) {
+                kylinTicketPartnerVo.setDescribeElectronic(ticketCreateParam.getDescribeElectronic()==null?"":ticketCreateParam.getDescribeElectronic());
+            } else {
+                kylinTicketPartnerVo.setDescribeElectronic("");
+            }
+
+            kylinTicketPartnerVo.setStatus(-2);
+            kylinTicketPartnerVo.setDefault();
+
+            if (ticketCreateParam.getIsExpress() == 1) {
+                kylinTicketPartnerVo.setTimeEndExpress(ticketCreateParam.getTimeEndExpress().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            }
+
+            if (ticketCreateParam.getIsShowCode() == 1) {
+                kylinTicketPartnerVo.setQrCodeShowTime(ticketCreateParam.getQrCodeShowTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            }
+
+            KylinTicketPartnerVo data = mongoTemplate.insert(
+                    kylinTicketPartnerVo, KylinTicketPartnerVo.class.getSimpleName()
+            );
+
+            return ResponseDto.success(kylinTicketPartnerVo);
+        } catch (Exception e) {
+            return ResponseDto.failure(ErrorMapping.get(20101));
+        }
+    }
+
+    @Override
+    public ResponseDto<KylinTicketPartnerVo> updateTicket(TicketCreateParam ticketCreateParam) {
+        try {
+            KylinTicketTimesPartnerVo ticketTimeRelation = mongoTemplate.findOne(Query.query(Criteria.where("ticketTimesId").is(ticketCreateParam.getTimesId())),
+                    KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+
+            PerformancePartnerVo data = mongoTemplate.findOne(Query.query(Criteria.where("performancesId").is(ticketTimeRelation.getPerformancesId())),
+                    PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName());
+            if (data == null || data.getAuditStatus() == null || data.getAuditStatus() == 0) {
+                return ResponseDto.failure(ErrorMapping.get("20112"));
+            }
+
+            String ticketId = ticketCreateParam.getTicketsId();
+            LocalDateTime updatedAt = LocalDateTime.now();
+            // mongo 操作
+            KylinTicketPartnerVo kylinTicketPartnerVo = new KylinTicketPartnerVo();
+            BeanUtils.copyProperties(ticketCreateParam, kylinTicketPartnerVo);
+            kylinTicketPartnerVo.setUpdatedAt(updatedAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketPartnerVo.setTimeStart(ticketCreateParam.getTimeStart().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketPartnerVo.setTimeEnd(ticketCreateParam.getTimeEnd().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketPartnerVo.setTimesId(null);
+            kylinTicketPartnerVo.setStatus(null);
+            if (ticketCreateParam.getIsExpress() == 1) {
+                kylinTicketPartnerVo.setDescribeExpress(ticketCreateParam.getDescribeExpress()==null?"":ticketCreateParam.getDescribeExpress());
+            }
+            if (ticketCreateParam.getIsElectronic() == 1) {
+                kylinTicketPartnerVo.setDescribeElectronic(ticketCreateParam.getDescribeElectronic()==null?"":ticketCreateParam.getDescribeElectronic());
+            }
+
+            kylinTicketPartnerVo.setDefault();
+            if (ticketCreateParam.getIsExpress() == 1) {
+                kylinTicketPartnerVo.setTimeEndExpress(ticketCreateParam.getTimeEndExpress().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            }
+            if (ticketCreateParam.getIsShowCode() == 1) {
+                kylinTicketPartnerVo.setQrCodeShowTime(ticketCreateParam.getQrCodeShowTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            }
+
+            BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(kylinTicketPartnerVo));
+            Document doc = mongoTemplate.getCollection(KylinTicketPartnerVo.class.getSimpleName()).findOneAndUpdate(
+                    Query.query(Criteria.where("ticketsId").is(ticketId)).getQueryObject(),
+                    object,
+                    new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER)
+            );
+
+            KylinTicketPartnerVo kylinTicketPartnerVoData = JsonUtils.fromJson(doc.toJson(), KylinTicketPartnerVo.class);
+            return ResponseDto.success(kylinTicketPartnerVoData);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseDto.failure(ErrorMapping.get(20103));
+        }
+    }
+
+    @Override
+    public ResponseDto<String> deleteTicket(String ticketsId) {
+        try {
+            LocalDateTime updatedAt = LocalDateTime.now();
+
+            KylinTicketRelations ticketRelations = ticketRelationsMapper.selectOne(
+                    new UpdateWrapper<KylinTicketRelations>().eq("ticket_id", ticketsId));
+
+            if (ticketRelations == null) {
+                mongoTemplate.remove(Query.query(Criteria.where("ticketsId").is(ticketsId)), KylinTicketPartnerVo.class, KylinTicketPartnerVo.class.getSimpleName());
+                return ResponseDto.success("删除成功");
+            }
+            KylinTicketTimeRelation ticketTimeRelation = ticketTimeRelationMapper.selectOne(
+                    new UpdateWrapper<KylinTicketTimeRelation>().eq("times_id", ticketRelations.getTimesId()));
+
+            PerformancePartnerVo data = mongoTemplate.findOne(Query.query(Criteria.where("performancesId").is(ticketTimeRelation.getPerformanceId())),
+                    PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName());
+            if (data == null || data.getAuditStatus() == null || data.getAuditStatus() == 0) {
+                return ResponseDto.failure(ErrorMapping.get("20106"));
+            }
+
+            KylinPerformanceStatus performanceStatus = performanceStatusMapper.selectOne(
+                    new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", ticketTimeRelation.getPerformanceId()));
+
+            if (performanceStatus.getStatus() == 0 || performanceStatus.getStatus() == 4) {//未提审||被拒绝
+                // mongo 操作
+                HashMap<String, Object> map = new HashMap<>();
+                map.put("updatedAt", updatedAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+                map.put("status", -1);
+
+                BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                Document doc = mongoTemplate.getCollection(KylinTicketPartnerVo.class.getSimpleName()).findOneAndUpdate(
+                        Query.query(Criteria.where("ticketsId").is(ticketsId)).getQueryObject(),
+                        object,
+                        new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER)
+                );
+                return ResponseDto.success("删除成功");
+            } else {
+                return ResponseDto.failure(ErrorMapping.get(20106));
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseDto.failure(ErrorMapping.get(20102));
+        }
+    }
+
+    @Override
+    public ResponseDto<KylinTicketPartnerVo> copyTicket(String performanceId, String ticketsId) {
+        try {
+            // 获取 当前时间 -> 创建时间
+            LocalDateTime createdAt = LocalDateTime.now();
+
+            PerformancePartnerVo performancePartnerVo = mongoTemplate.findOne(Query.query(Criteria.where("performancesId").is(performanceId)), PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName());
+            if (performancePartnerVo.getAuditStatus() == 0 || performancePartnerVo.getAuditStatus() == 1) {
+                return ResponseDto.failure(ErrorMapping.get(20107));
+            }
+
+            KylinTicketPartnerVo kylinTicketPartnerVo = mongoTemplate.findOne(Query.query(Criteria.where("ticketsId").is(ticketsId)), KylinTicketPartnerVo.class, KylinTicketPartnerVo.class.getSimpleName());
+            kylinTicketPartnerVo.setCreatedAt(createdAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            kylinTicketPartnerVo.setTicketsId(IDGenerator.nextSnowId().toString());
+
+            KylinTicketPartnerVo data = mongoTemplate.insert(
+                    kylinTicketPartnerVo, KylinTicketPartnerVo.class.getSimpleName()
+            );
+            return ResponseDto.success(kylinTicketPartnerVo);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseDto.failure(ErrorMapping.get(20107));
+        }
+    }
+
+    @Override
+    public boolean submitTicketByTimes(String timesId, Integer status) {
+        LocalDateTime updatedAt = LocalDateTime.now();
+
+        HashMap<String, Object> map = new HashMap<>();
+        if (null == status) {
+            map.put("status", 1);
+        } else {
+            map.put("status", status);
+        }
+        map.put("updatedAt", updatedAt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+        BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+        mongoTemplate.getCollection(KylinTicketPartnerVo.class.getSimpleName()).updateMany(
+                Query.query(Criteria.where("timesId").is(timesId).and("status").nin(-2, 7)).getQueryObject(),
+                object
+        );
+
+        long count = mongoTemplate.count(
+                Query.query(Criteria.where("timesId").is(timesId)),
+                KylinTicketPartnerVo.class,
+                KylinTicketPartnerVo.class.getSimpleName()
+        );
+        return count <= 0;
+    }
+
+    @Override
+    public List<KylinTicketPartnerVo> getTicketMongoList(String timesId) {
+        return mongoTemplate.find(Query.query(Criteria.where("timesId").is(timesId).and("status").ne(-1)), KylinTicketPartnerVo.class, KylinTicketPartnerVo.class.getSimpleName());
+    }
+
+    @Override
+    public KylinTicketPartnerVo getTicketsMongo(String ticketsId) {
+        return mongoTemplate.findOne(Query.query(Criteria.where("ticketsId").is(ticketsId)), KylinTicketPartnerVo.class, KylinTicketPartnerVo.class.getSimpleName());
+    }
+
+    @Override
+    public ResponseDto<String> onLine(String ticketsId, String performancesId) {
+        try {
+            LocalDateTime updatedAt = LocalDateTime.now();
+            KylinTicketStatus ticketStatus = ticketStatusMapper.selectOne(new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", ticketsId));
+            if (ticketStatus.getStatus() >= 3 && ticketStatus.getStatus() != 4 && ticketStatus.getStatus() != 6) {//未提审||被拒绝
+                //mysql
+                KylinTicketStatus changeStatus = new KylinTicketStatus();
+                changeStatus.setUpdatedAt(updatedAt);
+                changeStatus.setStatus(9);
+                ticketStatusMapper.update(changeStatus, new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", ticketsId));
+
+
+                HashMap<String, Object> map = new HashMap<>();
+                map.put("status", 9);
+                BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                mongoTemplate.getCollection(KylinTicketPartnerVo.class.getSimpleName()).updateOne(
+                        Query.query(Criteria.where("ticketsId").is(ticketsId)).getQueryObject(),
+                        object
+                );
+
+                performanceVoTask.performanceVoStatus(performancesId);
+                return ResponseDto.success("上线成功");
+            } else {
+                return ResponseDto.failure(ErrorMapping.get(20110));
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseDto.failure(ErrorMapping.get(20108));
+        }
+    }
+
+    @Override
+    public ResponseDto<String> outLine(String ticketsId, String performancesId) {
+        try {
+            LocalDateTime updatedAt = LocalDateTime.now();
+            KylinTicketStatus ticketStatus = ticketStatusMapper.selectOne(new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", ticketsId));
+            if (ticketStatus.getStatus() >= 3 && ticketStatus.getStatus() != 4 && ticketStatus.getStatus() != 7) {//未提审||被拒绝
+                //mysql
+                KylinTicketStatus changeStatus = new KylinTicketStatus();
+                changeStatus.setUpdatedAt(updatedAt);
+                changeStatus.setStatus(7);
+                ticketStatusMapper.update(changeStatus, new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", ticketsId));
+                // mongo 操作
+                HashMap<String, Object> map = new HashMap<>();
+                map.put("status", 7);
+                BasicDBObject object = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                mongoTemplate.getCollection(KylinTicketPartnerVo.class.getSimpleName()).updateOne(
+                        Query.query(Criteria.where("ticketsId").is(ticketsId)).getQueryObject(),
+                        object
+                );
+
+                performanceVoTask.performanceVoStatus(performancesId);
+                return ResponseDto.success("下线成功");
+            } else {
+                return ResponseDto.failure(ErrorMapping.get(20111));
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseDto.failure(ErrorMapping.get(20109));
+        }
+    }
+
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/utils/DataUtils.java

+package com.liquidnet.service.kylin.partner.utils;
+
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.liquidnet.common.cache.redis.util.RedisUtil;
+import com.liquidnet.commons.lang.util.DateUtil;
+import com.liquidnet.commons.lang.util.JsonUtils;
+import com.liquidnet.service.kylin.constant.KylinRedisConst;
+import com.liquidnet.service.kylin.dto.vo.middle.KylinTicketTimesVo;
+import com.liquidnet.service.kylin.dto.vo.middle.KylinTicketVo;
+import com.liquidnet.service.kylin.dto.vo.mongo.*;
+import com.liquidnet.service.kylin.dto.vo.returns.KylinOrderListVo;
+import com.liquidnet.service.kylin.entity.KylinBuyNotice;
+import com.liquidnet.service.kylin.mapper.KylinBuyNoticeMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.math.BigDecimal;
+import java.text.SimpleDateFormat;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.regex.Pattern;
+
+@Component
+public class DataUtils {
+
+    @Autowired
+    private KylinBuyNoticeMapper buyNoticeMapper;
+    @Autowired
+    private MongoTemplate mongoTemplate;
+    @Autowired
+    private RedisUtil redisUtil;
+    @Autowired
+    private MongoVoUtils mongoVoUtils;
+    @Autowired
+    private RedisTemplate redisTemplate;
+
+    /**
+     * 根据 购票须知 id 获取 购票须知文案
+     *
+     * @param buyNoticeIds 购票须知 数组
+     * @return 购票须知 json串
+     */
+    public String getBuyNoticeJsonString(List<String> buyNoticeIds) {
+        List<KylinBuyNotice> data = buyNoticeMapper.selectList(new UpdateWrapper<KylinBuyNotice>().in("buy_notice_id", buyNoticeIds));
+        return JsonUtils.toJson(data);
+    }
+
+    /**
+     * 初始化普通库存
+     *
+     * @param ticketId     票id
+     * @param totalGeneral 普通库存
+     */
+    public void setSurplusGeneral(String ticketId, int totalGeneral) {
+        redisUtil.set(KylinRedisConst.PERFORMANCES_INVENTORY + ticketId + ":" + KylinRedisConst.SURPLUS_GENERAL, totalGeneral);
+    }
+
+    /**
+     * 获取普通剩余库存
+     *
+     * @param ticketId 票id
+     * @return 普通剩余库存
+     */
+    public int getSurplusGeneral(String ticketId) {
+        return (int) redisUtil.get(KylinRedisConst.PERFORMANCES_INVENTORY + ticketId + ":" + KylinRedisConst.SURPLUS_GENERAL);
+    }
+
+    /**
+     * 修改普通库存 并 返回修改后的数量
+     *
+     * @param ticketId       票id
+     * @param surplusGeneral 普通库存
+     * @return 普通剩余库存
+     */
+    public int changeSurplusGeneral(String ticketId, int surplusGeneral) {
+        if (surplusGeneral > 0) {
+            return (int) redisUtil.incr(KylinRedisConst.PERFORMANCES_INVENTORY + ticketId + ":" + KylinRedisConst.SURPLUS_GENERAL, surplusGeneral);
+        } else {
+            return (int) redisUtil.decr(KylinRedisConst.PERFORMANCES_INVENTORY + ticketId + ":" + KylinRedisConst.SURPLUS_GENERAL, Math.abs(surplusGeneral));
+        }
+    }
+
+    /**
+     * 判断 当前库存是否售罄
+     *
+     * @param ticketId 票id
+     * @return boolean
+     */
+    public boolean ticketIsSoldOut(String ticketId) {
+        if (0 >= getSurplusGeneral(ticketId)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * 初始化兑换库存
+     *
+     * @param ticketId      票id
+     * @param totalExchange 兑换库存
+     */
+    public void setSurplusExchange(String ticketId, int totalExchange) {
+        redisUtil.set(KylinRedisConst.PERFORMANCES_INVENTORY + ticketId + ":" + KylinRedisConst.SURPLUS_EXCHANGE, totalExchange);
+    }
+
+    /**
+     * 获取兑换剩余库存
+     *
+     * @param ticketId 票id
+     * @return 兑换剩余库存
+     */
+    public int getSurplusExchange(String ticketId) {
+        return (int) redisUtil.get(KylinRedisConst.PERFORMANCES_INVENTORY + ticketId + ":" + KylinRedisConst.SURPLUS_EXCHANGE);
+    }
+
+    /**
+     * 变更兑换库存 并 返回 修改后的数量
+     *
+     * @param ticketId        票id
+     * @param surplusExchange 普通库存
+     * @return 兑换剩余库存
+     */
+    public int changeSurplusExchange(String ticketId, int surplusExchange) {
+        if (surplusExchange > 0) {
+            return (int) redisUtil.incr(KylinRedisConst.PERFORMANCES_INVENTORY + ticketId + ":" + KylinRedisConst.SURPLUS_EXCHANGE, surplusExchange);
+        } else {
+            return (int) redisUtil.decr(KylinRedisConst.PERFORMANCES_INVENTORY + ticketId + ":" + KylinRedisConst.SURPLUS_EXCHANGE, Math.abs(surplusExchange));
+        }
+    }
+
+    public void setOrderList(String userId, List<KylinOrderListVo> vo) {
+        redisUtil.set(KylinRedisConst.ORDER_LIST + userId, vo);
+    }
+
+    public List<KylinOrderListVo> getOrderList(String userId) {
+        if (redisUtil.hasKey(KylinRedisConst.ORDER_LIST + userId)) {
+        } else {
+            List<KylinOrderListVo> voList = mongoTemplate.find(Query.query(Criteria.where("userId").is(userId))
+                            .with(Sort.by(Sort.Direction.DESC, "createdAt")).limit(40),
+                    KylinOrderListVo.class, KylinOrderTicketVo.class.getSimpleName());
+            redisUtil.set(KylinRedisConst.ORDER_LIST + userId, voList);
+        }
+        return (List<KylinOrderListVo>) redisUtil.get(KylinRedisConst.ORDER_LIST + userId);
+    }
+
+    /**
+     * 根据订单id 获取 订单vo 详情
+     *
+     * @param orderId
+     * @return
+     */
+    public KylinOrderTicketVo getOrderTicketVo(String orderId) {
+        if (redisUtil.hasKey(KylinRedisConst.ORDER + orderId)) {
+        } else {
+            KylinOrderTicketVo ticketData = mongoTemplate.findOne(Query.query(Criteria.where("orderTicketsId").is(orderId)), KylinOrderTicketVo.class, KylinOrderTicketVo.class.getSimpleName());
+            List<KylinOrderTicketEntitiesVo> kylinOrderTicketEntitiesVoList = mongoTemplate.find(Query.query(Criteria.where("orderId").is(orderId)), KylinOrderTicketEntitiesVo.class, KylinOrderTicketEntitiesVo.class.getSimpleName());
+            ticketData.setEntitiesVoList(kylinOrderTicketEntitiesVoList);
+            redisUtil.set(KylinRedisConst.ORDER + orderId, ticketData);
+        }
+        return (KylinOrderTicketVo) redisUtil.get(KylinRedisConst.ORDER + orderId);
+    }
+
+    /**
+     * 删除订单redis
+     *
+     * @param orderId
+     */
+    public void delOrderTicketRedis(String orderId) {
+        redisUtil.del(KylinRedisConst.ORDER + orderId);
+    }
+
+    /**
+     * 获取 验票账号 vo
+     *
+     * @param checkUserId
+     * @return
+     */
+    public KylinCheckUserVo getCheckUserVo(String checkUserId) {
+        if (redisUtil.hasKey(KylinRedisConst.CHECK_USER + checkUserId)) {
+        } else {
+            KylinCheckUserVo ticketData = mongoTemplate.findOne(Query.query(Criteria.where("checkUserId").is(checkUserId)), KylinCheckUserVo.class, KylinCheckUserVo.class.getSimpleName());
+            redisUtil.set(KylinRedisConst.CHECK_USER + checkUserId, ticketData);
+        }
+        return (KylinCheckUserVo) redisUtil.get(KylinRedisConst.CHECK_USER + checkUserId);
+    }
+
+    /**
+     * 删除 验票账号 redis
+     *
+     * @param checkUserId
+     */
+    public void delCheckUserRedis(String checkUserId) {
+        redisUtil.del(KylinRedisConst.CHECK_USER + checkUserId);
+    }
+
+    /**
+     * 获取 验票账号关系 vo
+     *
+     * @param checkUserId
+     * @return
+     */
+    public KylinCheckUserPerformanceVo getCheckUserRelationVo(String checkUserId) {
+        if (redisUtil.hasKey(KylinRedisConst.CHECK_USER_RELATION + checkUserId)) {
+        } else {
+            KylinCheckUserPerformanceVo ticketData = mongoTemplate.findOne(Query.query(Criteria.where("checkUserId").is(checkUserId)), KylinCheckUserPerformanceVo.class, KylinCheckUserPerformanceVo.class.getSimpleName());
+            redisUtil.set(KylinRedisConst.CHECK_USER_RELATION + checkUserId, ticketData);
+        }
+        return (KylinCheckUserPerformanceVo) redisUtil.get(KylinRedisConst.CHECK_USER_RELATION + checkUserId);
+    }
+
+    /**
+     * 删除 验票账号关系 vo
+     *
+     * @param checkUserId
+     */
+    public void delCheckUserRelationRedis(String checkUserId) {
+        redisUtil.del(KylinRedisConst.CHECK_USER_RELATION + checkUserId);
+    }
+
+    /**
+     * 获取入场须知
+     *
+     * @param enterInfoId
+     * @return
+     */
+    public String getEnterInfo(String enterInfoId) {
+        if (redisUtil.hasKey(KylinRedisConst.ENTER_INFO + enterInfoId)) {
+        } else {
+            return "入场须知";
+        }
+        return (String) redisUtil.get(KylinRedisConst.ENTER_INFO + enterInfoId);
+    }
+
+
+    public void updatePerformanceMongo(String performanceIds, KylinPerformanceVo paramVo) {
+        //查询 mysql 数据
+        KylinPerformanceVo vo;
+        if (null == paramVo) {
+            vo = mongoVoUtils.combinePerformanceVoData(performanceIds);
+        } else {
+            vo = paramVo;
+        }
+        if (vo != null) {
+            try {
+                //删除 mongo数据
+                mongoTemplate.remove(Query.query(Criteria.where("performancesId").is(performanceIds)), KylinPerformanceVo.class, KylinPerformanceVo.class.getSimpleName());
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            try {
+                //新增 mongo数据
+                mongoTemplate.insert(vo, KylinPerformanceVo.class.getSimpleName());
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            try {
+                //删除redis
+                redisUtil.del(KylinRedisConst.PERFORMANCES + performanceIds);
+                // 大龙相关 演出列表
+                redisUtil.del(KylinRedisConst.PERFORMANCES_LIST_CITYNAME + vo.getCityName());
+                redisUtil.del(KylinRedisConst.PERFORMANCES_ROADLIST + vo.getRoadShowId());
+                redisUtil.del(KylinRedisConst.PERFORMANCES_LIST_SYSTEM_RECOMMEND);
+                redisUtil.del(KylinRedisConst.PERFORMANCES_LIST_RECOMMEND);
+                redisUtil.del(KylinRedisConst.PERFORMANCES_LIST_NOTICE);
+                redisUtil.del(KylinRedisConst.PERFORMANCES_LIST_EXCLUSIVE);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        } else {
+            System.out.println("创建Vo异常");
+        }
+    }
+
+    /**
+     * @param performanceId 演出id
+     * @param ticketId      票种id
+     * @param buyCount      购买数量 大于 0 增加 小于 0 减少 对应 支付 退款表
+     */
+    public void changeBuyInfo(String userId, String idCard, String performanceId, String ticketId, int buyCount) {
+        String redisKey;
+
+        KylinPerformanceVo vo = getPerformanceVo(performanceId);
+        int isTrueName = vo.getIsTrueName();
+        String useTime = "";
+        HashMap<String, ArrayList<String>> allTicketId = new HashMap<>();
+        for (int x = 0; x < vo.getTicketTimeList().size(); x++) {
+            KylinTicketTimesVo timeItem = vo.getTicketTimeList().get(x);
+            ArrayList<String> ticketList = new ArrayList<>();
+            for (int y = 0; y < timeItem.getTicketList().size(); y++) {
+                KylinTicketVo ticketItem = timeItem.getTicketList().get(y);
+                if (ticketItem.getType() == 1) {
+                    ticketList.add(ticketItem.getTicketsId());
+                }
+                if (ticketItem.getTicketsId().equals(ticketId)) {
+                    useTime = ticketItem.getUseStart();
+                }
+            }
+            allTicketId.put(timeItem.getUseStart(), ticketList);
+        }
+
+        if (0 == isTrueName) {
+            redisKey = KylinRedisConst.USERID_BUY_INFO + userId;
+        } else {
+            redisKey = KylinRedisConst.IDCARD_BUY_INFO + idCard;
+        }
+
+        String performanceIdKey = redisKey + ":" + KylinRedisConst.PERFORMANCE_ID + ":" + performanceId;
+        String ticketIdKey = redisKey + ":" + KylinRedisConst.TICKET_ID + ":" + ticketId;
+        String ticketUseTimeKey = ticketIdKey + ":" + KylinRedisConst.USE_TIME;
+        redisUtil.set(ticketUseTimeKey, useTime);
+
+        if (buyCount > 0) {
+            redisUtil.incr(ticketIdKey, buyCount);
+            redisUtil.incr(performanceIdKey, buyCount);
+        }else{
+            redisUtil.decr(ticketIdKey, Math.abs(buyCount));
+            redisUtil.decr(performanceIdKey, Math.abs(buyCount));
+        }
+    }
+
+
+
+
+    // 获取 用户维度 演出购买数量
+    public int getUserPBuyCount(String userId, String performanceId) {
+        try {
+            return (int) redisUtil.get(KylinRedisConst.USERID_BUY_INFO + userId + ":" + KylinRedisConst.PERFORMANCE_ID + ":" + performanceId);
+        } catch (Exception e) {
+            return 0;
+        }
+    }
+
+    // 获取 用户维度 票种购买数量
+    public int getUserTBuyCount(String userId, String ticketId) {
+        try {
+            return (int) redisUtil.get(KylinRedisConst.USERID_BUY_INFO + userId + ":" + KylinRedisConst.TICKET_ID + ":" + ticketId);
+        } catch (Exception e) {
+            return 0;
+        }
+    }
+
+    // 获取 证件维度 演出购买数量
+    public int getIdCardPBuyCount(String idCard, String performanceId) {
+        try {
+            return (int) redisUtil.get(KylinRedisConst.IDCARD_BUY_INFO + idCard + ":" + KylinRedisConst.PERFORMANCE_ID + ":" + performanceId);
+        } catch (Exception e) {
+            return 0;
+        }
+    }
+
+    // 获取 证件维度 票种购买数量
+    public int getIdCardTBuyCount(String idCard, String ticketId) {
+        try {
+            return (int) redisUtil.get(KylinRedisConst.IDCARD_BUY_INFO + idCard + ":" + KylinRedisConst.TICKET_ID + ":" + ticketId);
+        } catch (Exception e) {
+            return 0;
+        }
+    }
+
+    /**
+     * 删除订单redis
+     *
+     * @param orderEntitiesId
+     */
+    public void delOrderTicketEntitiesRedis(String orderEntitiesId) {
+        redisUtil.del(KylinRedisConst.ORDER_ENTITIES + orderEntitiesId);
+    }
+
+    /**
+     * 根据演出id 获取 演出vo 详情
+     *
+     * @param performanceId
+     * @return
+     */
+    public KylinPerformanceVo getPerformanceVo(String performanceId) {
+        if (redisUtil.hasKey(KylinRedisConst.PERFORMANCES + performanceId)) {
+        } else {
+            KylinPerformanceVo performanceData = mongoTemplate.findOne(Query.query(Criteria.where("performancesId").is(performanceId)), KylinPerformanceVo.class, KylinPerformanceVo.class.getSimpleName());
+            redisUtil.set(KylinRedisConst.PERFORMANCES + performanceId, performanceData);
+        }
+        return (KylinPerformanceVo) redisUtil.get(KylinRedisConst.PERFORMANCES + performanceId);
+    }
+
+    /**
+     * 获取分销用户名字
+     *
+     * @param agentId
+     * @return
+     */
+    public String getAgentInfoName(String agentId) {
+        String redisKey = KylinRedisConst.PERFORMANCES_AGENT_INFO.concat(agentId);
+//        String name = (String) redisUtil.hget(redisKey, "name");
+        String name = "";
+        return name;
+    }
+
+    /**
+     * 获取演出列表redis
+     *
+     * @param cityName
+     */
+    public List<KylinPerformanceVo> getPerformancesListOfcityName(String cityName) {
+        String redisKey = KylinRedisConst.PERFORMANCES_LIST_CITYNAME.concat(cityName);
+        if (!redisUtil.hasKey(redisKey)) {
+            // 固定查询条件
+            Query query = getCommonWhere();
+            // 其他条件
+            Pattern cityNameCompile = Pattern.compile("^.*" + cityName + ".*$", Pattern.CASE_INSENSITIVE);
+            query.addCriteria(Criteria.where("cityName").regex(cityNameCompile));
+            // 排序
+            Sort sortName = Sort.by(Sort.Direction.ASC, "timeStart");
+            query.with(sortName);
+            // 不要查询的字段
+            query.fields().exclude("details");
+            query.fields().exclude("noticeImage");
+            query.fields().exclude("ticketTimeList");
+            query.fields().exclude("describeElectronic");
+            List<KylinPerformanceVo> performancesList = mongoTemplate.find(query, KylinPerformanceVo.class, KylinPerformanceVo.class.getSimpleName());
+            redisUtil.set(redisKey, performancesList);
+        }
+        return (List<KylinPerformanceVo>) redisUtil.get(redisKey);
+    }
+
+    /**
+     * 获取系统推荐演出列表redis
+     */
+    public List<KylinPerformanceVo> getPerformancesListIsSystemRecommend() {
+        String redisKey = KylinRedisConst.PERFORMANCES_LIST_SYSTEM_RECOMMEND;
+        if (!redisUtil.hasKey(redisKey)) {
+            // 固定条件
+            Query query = getCommonWhere();
+            // 排序
+            Sort sortName = Sort.by(Sort.Direction.ASC, "timeStart");
+            Pageable pageable = PageRequest.of(0, 8, sortName);
+            query.with(pageable);
+            // 不要查询的字段
+            query.fields().exclude("details");
+            query.fields().exclude("noticeImage");
+            query.fields().exclude("ticketTimeList");
+            query.fields().exclude("describeElectronic");
+            // 推荐
+            List<KylinPerformanceVo> systemRecommendList = mongoTemplate.find(query, KylinPerformanceVo.class, KylinPerformanceVo.class.getSimpleName());
+            redisUtil.set(redisKey, systemRecommendList);
+        }
+        return (List<KylinPerformanceVo>) redisUtil.get(redisKey);
+    }
+
+    /**
+     * 获取演出预告列表redis
+     */
+    public HashMap<String, Object> getPerformancesListNotice() {
+        String redisKey = KylinRedisConst.PERFORMANCES_LIST_NOTICE;
+        if (!redisUtil.hasKey(redisKey)) {
+            // 固定条件
+            Query query = getCommonWhere();
+
+            // 今天的
+            HashMap toDayTime = DateUtil.oneDayStartEnd();
+            String nowTimeTStr = (String) toDayTime.get("startStr");
+            String toDayEndTimeStr = (String) toDayTime.get("endStr");
+            query.addCriteria(Criteria.where("sellTime").gte(nowTimeTStr).lt(toDayEndTimeStr));
+            query.fields().exclude("details");
+            query.fields().exclude("noticeImage");
+            query.fields().exclude("ticketTimeList");
+            query.fields().exclude("describeElectronic");
+            List<KylinPerformanceVo> toDayList = mongoTemplate.find(query, KylinPerformanceVo.class, KylinPerformanceVo.class.getSimpleName());
+
+            // 固定条件
+            Query queryT = getCommonWhere();
+
+            // 三天的
+            Calendar cal = Calendar.getInstance();
+            cal.setTime((Date) toDayTime.get("end"));
+            Date beforeDayEnd = DateUtil.getBeforeDayEnd(cal, 3);
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            String threeDaysLaterStr = sdf.format(beforeDayEnd);
+
+            queryT.addCriteria(Criteria.where("sellTime").gte(toDayEndTimeStr).lt(threeDaysLaterStr));
+            queryT.fields().exclude("details");
+            queryT.fields().exclude("noticeImage");
+            queryT.fields().exclude("ticketTimeList");
+            queryT.fields().exclude("describeElectronic");
+            List<KylinPerformanceVo> threeDaysList = mongoTemplate.find(queryT, KylinPerformanceVo.class, KylinPerformanceVo.class.getSimpleName());
+
+            HashMap<String, Object> info = new HashMap<>();
+            info.put("toDayList", toDayList);
+            info.put("threeDaysList", threeDaysList);
+            redisUtil.set(redisKey, info);
+        }
+        return (HashMap<String, Object>) redisUtil.get(redisKey);
+    }
+
+    /**
+     * 获取推荐演出列表redis
+     */
+    public List<KylinPerformanceVo> getPerformancesListIsRecommend() {
+        String redisKey = KylinRedisConst.PERFORMANCES_LIST_RECOMMEND;
+        if (!redisUtil.hasKey(redisKey)) {
+            // 固定条件
+            Query query = getCommonWhere();
+            // 排序
+            Sort sortName = Sort.by(Sort.Direction.DESC, "isRecommend");
+            query.with(sortName);
+            // 不要查询的字段
+            query.fields().exclude("details");
+            query.fields().exclude("noticeImage");
+            query.fields().exclude("ticketTimeList");
+            query.fields().exclude("describeElectronic");
+            // 推荐
+            query.addCriteria(Criteria.where("isRecommend").gte(1));
+            List<KylinPerformanceVo> recommendList = mongoTemplate.find(query, KylinPerformanceVo.class, KylinPerformanceVo.class.getSimpleName());
+            redisUtil.set(redisKey, recommendList);
+        }
+        return (List<KylinPerformanceVo>) redisUtil.get(redisKey);
+    }
+
+    /**
+     * 获取会员专属演出列表redis
+     */
+    public List<KylinPerformanceVo> getPerformancesListIsExclusive() {
+        String redisKey = KylinRedisConst.PERFORMANCES_LIST_EXCLUSIVE;
+        if (!redisUtil.hasKey(redisKey)) {
+            // 固定条件
+            Query query = getCommonWhere();
+            // 不要查询的字段
+            query.fields().exclude("details");
+            query.fields().exclude("noticeImage");
+            query.fields().exclude("ticketTimeList");
+            query.fields().exclude("describeElectronic");
+            // 推荐
+            query.addCriteria(Criteria.where("isExclusive").is(1));
+            List<KylinPerformanceVo> exclusiveList = mongoTemplate.find(query, KylinPerformanceVo.class, KylinPerformanceVo.class.getSimpleName());
+            redisUtil.set(redisKey, exclusiveList);
+        }
+        return (List<KylinPerformanceVo>) redisUtil.get(redisKey);
+    }
+
+    /**
+     * 获取所有城市演出列表redis
+     */
+    public List<KylinPerformanceVo> getPerformancesListAll() {
+        List<KylinPerformanceVo> list = new ArrayList<>();
+        Set<String> keys = redisTemplate.keys(KylinRedisConst.PERFORMANCES_LIST_ALL);
+        for (String key : keys) {
+            List<KylinPerformanceVo> OneCityList = (List<KylinPerformanceVo>) redisUtil.get(key);
+            list.addAll(OneCityList);
+        }
+        return list;
+    }
+
+    /**
+     * 获取巡演列表redis
+     */
+    public List<KylinPerformanceVo> getRoadList(String roadShowId) {
+        String redisKey = KylinRedisConst.PERFORMANCES_ROADLIST.concat(roadShowId);
+        if (!redisUtil.hasKey(redisKey)) {
+            List<KylinPerformanceVo> roadList = mongoTemplate.find(
+                    Query.query(Criteria.where("roadShowId").is(roadShowId)),
+                    KylinPerformanceVo.class,
+                    KylinPerformanceVo.class.getSimpleName()
+            );
+            redisUtil.set(redisKey, roadList);
+        }
+        return (List<KylinPerformanceVo>) redisUtil.get(redisKey);
+    }
+
+    /**
+     * 演出搜索固定参数
+     */
+    public Query getCommonWhere() {
+        // 固定条件
+        Query query = new Query();
+        LocalDateTime nowTime = LocalDateTime.now();
+        String nowTimeStr = DateUtil.Formatter.yyyyMMddHHmmss.format(nowTime);
+        query.addCriteria(Criteria.where("timeEnd").gte(nowTimeStr));
+        query.addCriteria(Criteria.where("appStatus").in(3, 6, 8, 9, 10));
+        query.addCriteria(Criteria.where("isShow").is(1));
+        return query;
+    }
+
+    public KylinOrderRefundsVoBase getOrderRefundVo(String orderRefundsId){
+        if (redisUtil.hasKey(KylinRedisConst.ORDER_REFUND + orderRefundsId)) {
+        } else {
+            KylinOrderRefundsVoBase orderRefundsVo = mongoTemplate.findOne(Query.query(Criteria.where("orderRefundsId").is(orderRefundsId)), KylinOrderRefundsVoBase.class, KylinOrderRefundsVoBase.class.getSimpleName());
+            List<KylinOrderRefundEntitiesVo> kylinOrderTicketEntitiesVoList = mongoTemplate.find(Query.query(Criteria.where("orderRefundsId").is(orderRefundsId)), KylinOrderRefundEntitiesVo.class, KylinOrderRefundEntitiesVo.class.getSimpleName());
+            List<KylinOrderRefundPicVo> picVos = mongoTemplate.find(Query.query(Criteria.where("orderRefundsId").is(orderRefundsId)),KylinOrderRefundPicVo.class,KylinOrderRefundPicVo.class.getSimpleName());
+            orderRefundsVo.setOrderRefundEntitiesVoList(kylinOrderTicketEntitiesVoList);
+            orderRefundsVo.setOrderRefundPicVos(picVos);
+            redisUtil.set(KylinRedisConst.ORDER_REFUND + orderRefundsId, orderRefundsVo);
+        }
+        return (KylinOrderRefundsVoBase) redisUtil.get(KylinRedisConst.ORDER_REFUND + orderRefundsId);
+    }
+
+    public List<KylinOrderRefundsVoBase> getOrderRefundVoByOrderId(String orderId){
+        if (redisUtil.hasKey(KylinRedisConst.ORDER_REFUND_BY_ORDER_ID + orderId)) {
+        } else {
+            List<KylinOrderRefundsVoBase> orderRefundsVoList = new ArrayList<>();
+            List<KylinOrderRefundsVoBase> data = mongoTemplate.find(Query.query(Criteria.where("orderTicketsId").is(orderId)), KylinOrderRefundsVoBase.class, KylinOrderRefundsVoBase.class.getSimpleName());
+            for (KylinOrderRefundsVoBase item : data) {
+                List<KylinOrderRefundEntitiesVo> kylinOrderTicketEntitiesVoList = mongoTemplate.find(Query.query(Criteria.where("orderRefundsId").is(item.getOrderRefundsId())), KylinOrderRefundEntitiesVo.class, KylinOrderRefundEntitiesVo.class.getSimpleName());
+                if(kylinOrderTicketEntitiesVoList.size()>1){
+                    continue;
+                }
+                item.setOrderRefundEntitiesVoList(kylinOrderTicketEntitiesVoList);
+                List<KylinOrderRefundPicVo> picVos = mongoTemplate.find(Query.query(Criteria.where("orderRefundsId").is(item.getOrderRefundsId())),KylinOrderRefundPicVo.class,KylinOrderRefundPicVo.class.getSimpleName());
+                item.setOrderRefundPicVos(picVos);
+                orderRefundsVoList.add(item);
+            }
+            redisUtil.set(KylinRedisConst.ORDER_REFUND_BY_ORDER_ID + orderId, orderRefundsVoList);
+        }
+        return (List<KylinOrderRefundsVoBase>) redisUtil.get(KylinRedisConst.ORDER_REFUND_BY_ORDER_ID + orderId);
+    }
+
+    public void delOrderRefundVo(String orderRefundsId){
+        redisUtil.del(KylinRedisConst.ORDER_REFUND + orderRefundsId);
+    }
+
+    public void delOrderRefundVoByOrderId(String orderId){
+        redisUtil.del(KylinRedisConst.ORDER_REFUND_BY_ORDER_ID + orderId);
+    }
+
+    /**
+     * 获取可退款票单价格
+     * @param orderTicketVo         订单vo数据
+     * @param orderTicketEntitiesId 票单id
+     * @return
+     */
+    public BigDecimal getCanRefundOrderEntitiesPrice(KylinOrderTicketVo orderTicketVo, List<KylinOrderRefundsVoBase> kylinOrderRefundsVoBaseList, String orderTicketEntitiesId){
+        //单票实付价格
+        BigDecimal singlePrice = orderTicketVo.getPriceActual().subtract(orderTicketVo.getPriceExpress()).divide(BigDecimal.valueOf(orderTicketVo.getNumber()));
+        //单票剩余未退款金额
+        BigDecimal canRefundSinglePrice = new BigDecimal("0.00");
+        for (KylinOrderTicketEntitiesVo item : orderTicketVo.getEntitiesVoList()) {
+            if (item.getOrderTicketEntitiesId().equals(orderTicketEntitiesId)) {
+                canRefundSinglePrice = singlePrice.subtract(item.getRefundPrice()==null?BigDecimal.valueOf(0.00):item.getRefundPrice());
+            }
+        }
+        //订单锁定金额
+        BigDecimal orderLockPrice = new BigDecimal("0.00");
+        for (KylinOrderRefundsVoBase refundVo : kylinOrderRefundsVoBaseList) {
+            int status = refundVo.getStatus();
+            if (status == 0 || status == 3 || status == 5 || status == 7) { //退款流程未完成 金额锁定
+                List<KylinOrderRefundEntitiesVo> refundEntitiesVos = refundVo.getOrderRefundEntitiesVoList();
+                for (KylinOrderRefundEntitiesVo refundEntitiesVo : refundEntitiesVos) {
+                    if (refundEntitiesVo.getOrderTicketEntitiesId().equals(orderTicketEntitiesId)) {
+                        orderLockPrice = orderLockPrice.add(refundEntitiesVo.getRefundPrice());
+                    }
+                }
+            }
+        }
+        //订单可退金额
+        BigDecimal refundSinglePrice = canRefundSinglePrice.subtract(orderLockPrice);
+        //是否包含快递费
+        if (orderTicketVo.getPriceActual().subtract(orderTicketVo.getPriceExpress()).subtract(orderTicketVo.getPriceRefund()).compareTo(canRefundSinglePrice) == 0) {
+            refundSinglePrice = refundSinglePrice.add(orderTicketVo.getPriceExpress());
+        }
+        return refundSinglePrice;
+    }
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/utils/MongoVoUtils.java

+package com.liquidnet.service.kylin.partner.utils;
+
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.liquidnet.common.cache.redis.util.RedisUtil;
+import com.liquidnet.commons.lang.util.DateUtil;
+import com.liquidnet.service.kylin.constant.KylinRedisConst;
+import com.liquidnet.service.kylin.dto.vo.middle.KylinTicketTimesVo;
+import com.liquidnet.service.kylin.dto.vo.middle.KylinTicketVo;
+import com.liquidnet.service.kylin.dto.vo.mongo.KylinOrderTicketVo;
+import com.liquidnet.service.kylin.dto.vo.mongo.KylinPerformanceVo;
+import com.liquidnet.service.kylin.dto.vo.returns.KylinOrderListVo;
+import com.liquidnet.service.kylin.entity.*;
+import com.liquidnet.service.kylin.mapper.*;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+@Component
+public class MongoVoUtils {
+    @Autowired
+    private KylinPerformancesMapper performancesMapper;
+    @Autowired
+    private KylinPerformanceStatusMapper performanceStatusMapper;
+    @Autowired
+    private KylinPerformanceRelationsMapper performanceRelationsMapper;
+    @Autowired
+    private KylinTicketTimesMapper ticketTimesMapper;
+    @Autowired
+    private KylinTicketTimeRelationMapper ticketTimeRelationMapper;
+    @Autowired
+    private KylinTicketsMapper ticketsMapper;
+    @Autowired
+    private KylinTicketStatusMapper ticketStatusMapper;
+    @Autowired
+    private KylinTicketRelationsMapper ticketRelationsMapper;
+    @Autowired
+    private RedisUtil redisUtil;
+    @Autowired
+    private DataUtils dataUtils;
+
+    public KylinPerformanceVo combinePerformanceVoData(String performancesId) {
+        try {
+            KylinPerformanceVo voData = new KylinPerformanceVo();
+
+            //演出数据
+            KylinPerformances p1 = performancesMapper.selectOne(new UpdateWrapper<KylinPerformances>().eq("performances_id", performancesId));
+            KylinPerformanceStatus p2 = performanceStatusMapper.selectOne(new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+            KylinPerformanceRelations p3 = performanceRelationsMapper.selectOne(new UpdateWrapper<KylinPerformanceRelations>().eq("performance_id", performancesId));
+            //场地相关数据
+            KylinFields fields = new KylinFields();
+            String cityName = (String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + p3.getFieldId(), "city_name");
+            fields.setCityId(Integer.parseInt((String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + p3.getFieldId(), "city_id")));
+            fields.setLatitude((String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + p3.getFieldId(), "latitude"));
+            fields.setLongitude((String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + p3.getFieldId(), "longitude"));
+            fields.setCityName((String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + p3.getFieldId(), "city_name"));
+            fields.setName((String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + p3.getFieldId(), "name"));
+
+            //相关状态时间初始变量
+            LocalDateTime stopSellTime = null;
+            LocalDateTime sellTime = null;
+            LocalDateTime sellMemberTime = null;
+
+            int isLackRegister = 0;
+            int isMember = 0;
+            int isExclusive = 0;
+            int isAdvance = 0;
+            int isDiscount = 0;
+            int payCountdownMinute = 15;
+            BigDecimal price = new BigDecimal("0.00");
+
+            //场次数据
+            List<KylinTicketTimeRelation> tt3 = ticketTimeRelationMapper.selectList(new UpdateWrapper<KylinTicketTimeRelation>().eq("performance_id", performancesId));
+            List<KylinTicketTimesVo> timeList = new ArrayList<>();
+            for (int x = 0; x < tt3.size(); x++) {
+                KylinTicketTimeRelation times = tt3.get(x);
+                KylinTicketTimes tt1 = ticketTimesMapper.selectOne(new UpdateWrapper<KylinTicketTimes>().eq("ticket_times_id", times.getTimesId()));
+
+                //票种数据
+                List<KylinTicketRelations> t3 = ticketRelationsMapper.selectList(new UpdateWrapper<KylinTicketRelations>().eq("times_id", times.getTimesId()));
+                List<KylinTicketVo> ticketList = new ArrayList<>();
+                for (int y = 0; y < t3.size(); y++) {
+                    KylinTicketRelations ticket = t3.get(y);
+                    KylinTickets t1 = ticketsMapper.selectOne(new UpdateWrapper<KylinTickets>().eq("tickets_id", ticket.getTicketId()));
+                    KylinTicketStatus t2 = ticketStatusMapper.selectOne(new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", ticket.getTicketId()));
+//                    if(t2.getStatus()==7){
+//                        continue;
+//                    }
+                    KylinTicketVo kylinTicketVo = new KylinTicketVo();
+                    kylinTicketVo.setTimeId(ticket.getTimesId());
+                    kylinTicketVo.setTicket(t1);
+                    kylinTicketVo.setTicketStatus(t2);
+                    ticketList.add(kylinTicketVo);
+
+//                    //票种 库存redis
+//                    if (!redisUtil.hHasKey(KylinRedisConst.PERFORMANCES_INVENTORY + kylinTicketVo.getTicketsId(), KylinRedisConst.SURPLUS_GENERAL)) {
+//                        dataUtils.setSurplusGeneral(kylinTicketVo.getTicketsId(), t2.getTotalGeneral());
+//                        dataUtils.setSurplusExchange(kylinTicketVo.getTicketsId(), t2.getSurplusExchange());
+//                    }
+
+                    if (kylinTicketVo.getIsMember() == 1) {
+                        if (kylinTicketVo.getMemberPrice().compareTo(kylinTicketVo.getPrice()) != 0) {
+                            isDiscount = 1;
+                        }
+
+                        if (DateUtil.compareStrDay(DateUtil.getNowTime(), kylinTicketVo.getMemberTimeStart()) < 0) {
+                            isAdvance = 1;
+                        }
+                        if (kylinTicketVo.getIsMember() == 1) {
+                            isMember = 1;
+                        }
+                        if (kylinTicketVo.getIsExclusive() == 1) {
+                            isExclusive = 1;
+                        }
+
+                        if (isAdvance == 0 && isDiscount == 0 && isExclusive == 0) {
+                            isMember = 0;
+                        }
+                    }
+                    if (kylinTicketVo.getIsLackRegister() == 1) {
+                        isLackRegister = 1;
+                    }
+                    payCountdownMinute = t1.getPayCountdownMinute();
+                    if (price.compareTo(new BigDecimal("0.00")) == 0) {
+                        price = kylinTicketVo.getPrice();
+                    } else {
+                        if (kylinTicketVo.getPrice().compareTo(price) < 0) {
+                            price = kylinTicketVo.getPrice();
+                        }
+                    }
+                    if (stopSellTime == null || stopSellTime.isBefore(t1.getTimeEnd())) {
+                        stopSellTime = t1.getTimeEnd();
+                    }
+                    if (sellMemberTime == null || sellMemberTime.isAfter(t1.getTimeStart().plusMinutes(-t1.getAdvanceMinuteMember()))) {
+                        sellMemberTime = t1.getTimeStart().plusMinutes(-t1.getAdvanceMinuteMember());
+                    }
+                    if (sellTime == null || sellTime.isAfter(t1.getTimeStart())) {
+                        sellTime = t1.getTimeStart();
+                    }
+                }
+
+//                if(ticketList.size()>0) {
+                KylinTicketTimesVo kylinTicketTimesVo = new KylinTicketTimesVo();
+                kylinTicketTimesVo.setTicketTimes(tt1);
+                kylinTicketTimesVo.setPerformanceId(times.getPerformanceId());
+                kylinTicketTimesVo.setTimeId(times.getTimesId());
+                kylinTicketTimesVo.setTicketList(ticketList);
+                timeList.add(kylinTicketTimesVo);
+//                }
+            }
+
+            voData.setPerformance(p1);
+            voData.setPerformanceStatus(p2);
+            voData.setPerformanceRelations(p3);
+            voData.setFieldsData(fields, cityName);
+            voData.setTimePriceVipAndLack(isLackRegister, isMember, isExclusive, price, stopSellTime, sellMemberTime, sellTime, isAdvance, isDiscount, payCountdownMinute);
+            voData.setTicketTimeList(timeList);
+            voData.setAppStatus(p2.getStatus());
+            return voData;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * @param userId  用户id
+     * @param type    1新增 2修改
+     * @param orderId 订单id [需要新增或者修改的订单id]
+     */
+    public Boolean resetOrderListVo(String userId, Integer type, String orderId, KylinOrderTicketVo dataSingle) {
+        List<KylinOrderListVo> vo = new ArrayList<>();
+        List<KylinOrderListVo> redisVo = new ArrayList();
+        KylinOrderListVo voItem = new KylinOrderListVo();
+        KylinOrderTicketVo data;
+        if (dataSingle == null) {
+            data = dataUtils.getOrderTicketVo(orderId);
+        } else {
+            data = dataSingle;
+        }
+        BeanUtils.copyProperties(data, voItem);
+        List<KylinOrderListVo> redisData = dataUtils.getOrderList(userId);
+        if (type == 1) {
+            redisVo.add(voItem);
+            if (redisData.size() > 0) {
+                if (redisData.get(0).getOrderTicketsId().equals(orderId)) {
+                    redisData.remove(0);
+                }
+            }
+        }
+
+        redisVo.addAll(redisData);
+
+        switch (type) {
+            case 1:
+                for (int i = 0; i < redisVo.size(); i++) {
+                    if (i == 40) {
+                        break;
+                    }
+                    if (i == 0) {
+                        vo.add(voItem);
+                    } else {
+                        vo.add(redisVo.get(i));
+                    }
+                }
+                if (redisVo.size() == 0) {
+                    vo.add(voItem);
+                }
+                dataUtils.setOrderList(userId, vo);
+                return true;
+            case 2:
+                for (int i = 0; i < redisVo.size(); i++) {
+                    if (i == 40) {
+                        break;
+                    }
+                    if (redisVo.get(i).getOrderTicketsId().equals(orderId)) {
+                        vo.add(voItem);
+                    } else {
+                        vo.add(redisVo.get(i));
+                    }
+                }
+                dataUtils.setOrderList(userId, vo);
+                return true;
+            default:
+                return false;
+        }
+    }
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/utils/OrderUtils.java

+package com.liquidnet.service.kylin.partner.utils;
+
+import com.liquidnet.common.cache.redis.util.RedisUtil;
+import com.liquidnet.service.adam.constant.AdamRedisConst;
+import com.liquidnet.service.adam.dto.vo.AdamAddressesVo;
+import com.liquidnet.service.adam.dto.vo.AdamEntersVo;
+import com.liquidnet.service.adam.dto.vo.AdamUserMemberVo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class OrderUtils {
+
+    @Autowired
+    private DataUtils dataUtils;
+    @Autowired
+    private RedisUtil redisUtil;
+
+    public String judgeOrderLimit(
+            int type,
+            String userId,
+            String idCard,
+            String performanceId,
+            String ticketId,
+            int performanceLimitCount,
+            int performanceMemberLimitCount,
+            int ticketLimitCount,
+            int ticketMemberLimitCount,
+            int performanceBuyCount,
+            int ticketBuyCount,
+            int memberType,
+            int isTrueName
+    ) {
+        Integer[] integers;
+        System.out.println("TYPE = " + type);
+        if (101 == type) {
+            integers = festivalOrderLimit(userId, idCard, performanceId, ticketId, performanceBuyCount, ticketBuyCount, isTrueName);
+        } else {
+            integers = roadShowOrderLimit(userId, idCard, performanceId, ticketId, performanceBuyCount, ticketBuyCount, isTrueName);
+        }
+        System.out.println("integers PERFORMANCE= " + integers[0]);
+        System.out.println("integers TICKETS= " + integers[1]);
+
+        return judgeMemberType(performanceLimitCount, performanceMemberLimitCount, ticketLimitCount, ticketMemberLimitCount, memberType, integers[0], integers[1]);
+    }
+
+    public Integer[] roadShowOrderLimit(
+            String userId,
+            String idCard,
+            String performanceId,
+            String ticketId,
+            int performanceBuyCount,
+            int ticketBuyCount,
+            int isTrueName
+    ) {
+        if (1 == isTrueName) {//实名
+            performanceBuyCount += dataUtils.getIdCardPBuyCount(idCard, performanceId);
+            ticketBuyCount += dataUtils.getIdCardTBuyCount(idCard, ticketId);
+        } else {//非实名
+            performanceBuyCount += dataUtils.getUserPBuyCount(userId, performanceId);
+            ticketBuyCount += dataUtils.getUserTBuyCount(userId, ticketId);
+        }
+        return new Integer[]{performanceBuyCount, ticketBuyCount};
+    }
+
+    public Integer[] festivalOrderLimit(
+            String userId,
+            String idCard,
+            String performanceId,
+            String ticketId,
+            int performanceBuyCount,
+            int ticketBuyCount,
+            int isTrueName
+    ) {
+        if (1 == isTrueName) {//实名
+            performanceBuyCount += dataUtils.getIdCardPBuyCount(idCard, performanceId);
+            ticketBuyCount += dataUtils.getIdCardTBuyCount(idCard, ticketId);
+        } else {//非实名
+            performanceBuyCount += dataUtils.getUserPBuyCount(userId, performanceId);
+            ticketBuyCount += dataUtils.getUserTBuyCount(userId, ticketId);
+        }
+
+        return new Integer[]{performanceBuyCount, ticketBuyCount};
+    }
+
+    public String judgeMemberType(int performanceLimitCount, int performanceMemberLimitCount, int ticketLimitCount, int ticketMemberLimitCount, int memberType, int performanceBuyCount, int ticketBuyCount) {
+        if (memberType == 1 || memberType == 2) {
+            if (performanceBuyCount > performanceMemberLimitCount && performanceMemberLimitCount != 0) {
+                return "该演出只能购买" + performanceMemberLimitCount + "张";//超过演出维度购买量
+            }
+            if (ticketBuyCount > ticketMemberLimitCount && ticketMemberLimitCount != 0) {
+                return "该票种只能购买" + ticketMemberLimitCount + "张";//超过票维度购买量
+            }
+        } else {//非会员区间
+            if (performanceBuyCount > performanceLimitCount && performanceLimitCount != 0) {
+                return "该演出只能购买" + performanceLimitCount + "张";//超过演出维度购买量
+            }
+            if (ticketBuyCount > ticketLimitCount && ticketLimitCount != 0) {
+                return "该票种只能购买" + ticketLimitCount + "张";//超过票维度购买量
+            }
+        }
+        return "";
+    }
+
+    public boolean isMember(String uid) {
+        String rk = AdamRedisConst.INFO_USER_MEMBER.concat(uid);
+        AdamUserMemberVo vo = (AdamUserMemberVo) redisUtil.get(rk);
+        return null != vo && vo.isActive();
+    }
+
+    public AdamAddressesVo getAddress(String uid, String addressesId) {
+        String rk = AdamRedisConst.INFO_ADDRESSES.concat(uid);
+        List<AdamAddressesVo> vos = (List<AdamAddressesVo>) redisUtil.get(rk);
+        return vos.stream().filter(r -> r.getAddressesId().equals(addressesId)).findAny().orElse(null);
+    }
+
+    public AdamEntersVo getEnters(String uid, String entersId) {
+        String rk = AdamRedisConst.INFO_ENTERS.concat(uid);
+        List<AdamEntersVo> vos = (List<AdamEntersVo>) redisUtil.get(rk);
+        return vos.stream().filter(r -> r.getEntersId().equals(entersId)).findAny().orElse(null);
+    }
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/utils/OtherUtils.java

+package com.liquidnet.service.kylin.partner.utils;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.liquidnet.commons.lang.util.HttpUtil;
+import com.liquidnet.commons.lang.util.JsonUtils;
+import com.liquidnet.service.kylin.dto.vo.middle.message.MessageConfigVo;
+import com.liquidnet.service.kylin.dto.vo.middle.message.MessageDataVo;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.security.MessageDigest;
+
+@Service
+@Slf4j
+public class OtherUtils {
+
+    @Value("${liquidnet.url-service.url}")
+    private String serviceUrl;
+
+    //发短信
+    public boolean sendMessage(String mobile, MessageDataVo data, MessageConfigVo configVo, Integer sign_id) {
+        try {
+            if (null != configVo && null != configVo.getStatus() && configVo.getStatus()) {
+                LinkedMultiValueMap<String, String> httpData = new LinkedMultiValueMap<>();
+                httpData.add("mobile", mobile);
+                httpData.add("templateId", configVo.getId());
+                httpData.add("signId", sign_id.toString());
+                httpData.add("data", JsonUtils.toJson(data));
+                String sign = Ksort(httpData);
+                sign = sign.concat("&key=").concat("R7tXY9smPQPG9Ku5yI0u6sfnlckmk04V");
+                sign = sign.toUpperCase();
+                httpData.add("sign", sign);
+
+                System.out.println("data = = = "+httpData.toString());
+
+                String returnData = HttpUtil.post(serviceUrl + "sendSmsMessage", httpData);
+                JsonNode postResultNew = JsonUtils.fromJson(returnData, JsonNode.class);
+                if (!postResultNew.get("message").toString().equals("OK")) {
+                    return false;
+                } else {
+                    return true;
+                }
+            } else {
+                return false;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    public String Ksort(MultiValueMap<String, String> map) {
+        String sb = "";
+        String[] key = new String[map.size()];
+        int index = 0;
+        for (String k : map.keySet()) {
+            key[index] = k;
+            index++;
+        }
+        for (String s : key) {
+            sb += s + "=" + map.get(s).get(0) + "&";
+        }
+        sb = sb.substring(0, sb.length() - 1);
+        // 将得到的字符串进行处理得到目标格式的字符串
+        try {
+            sb = URLDecoder.decode(sb, "UTF-8");
+        } catch (UnsupportedEncodingException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }// 使用常见的UTF-8编码
+        sb = sb.replace("%3D", "=").replace("%26", "&");
+        return sb;
+    }
+
+    public static String md5s(String txt) {
+        try {
+            MessageDigest md = MessageDigest.getInstance("MD5");
+            md.update(txt.getBytes("GBK"));    //问题主要出在这里，Java的字符串是unicode编码，不受源码文件的编码影响；而PHP的编码是和源码文件的编码一致，受源码编码影响。
+            StringBuilder buf = new StringBuilder();
+            for (byte b : md.digest()) {
+                buf.append(String.format("%02x", b & 0xff));
+            }
+            return buf.toString();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

liquidnet-bus-service/liquidnet-service-platform/liquidnet-service-platform-impl/src/main/java/com/liquidnet/service/kylin/partner/utils/PerformanceVoTask.java

+package com.liquidnet.service.kylin.partner.utils;
+
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.liquidnet.common.cache.redis.util.RedisUtil;
+import com.liquidnet.commons.lang.util.DateUtil;
+import com.liquidnet.commons.lang.util.IDGenerator;
+import com.liquidnet.commons.lang.util.JsonUtils;
+import com.liquidnet.service.kylin.constant.KylinRedisConst;
+import com.liquidnet.service.kylin.dto.param.PerformancePartnerVo;
+import com.liquidnet.service.kylin.dto.vo.middle.KylinTicketTimesVo;
+import com.liquidnet.service.kylin.dto.vo.middle.KylinTicketVo;
+import com.liquidnet.service.kylin.dto.vo.mongo.KylinPerformanceVo;
+import com.liquidnet.service.kylin.dto.vo.partner.KylinPerformanceMisVo;
+import com.liquidnet.service.kylin.dto.vo.partner.KylinTicketPartnerVo;
+import com.liquidnet.service.kylin.dto.vo.partner.KylinTicketTimesPartnerVo;
+import com.liquidnet.service.kylin.dto.vo.partner.TicketTimesTicketCreatePartnerVo;
+import com.liquidnet.service.kylin.entity.*;
+import com.liquidnet.service.kylin.mapper.*;
+import com.liquidnet.service.kylin.partner.impl.KylinTicketTimesPartnerServiceImpl;
+import com.liquidnet.service.kylin.partner.impl.KylinTicketsPartnerServiceImpl;
+import com.mongodb.BasicDBObject;
+import com.mongodb.client.model.FindOneAndUpdateOptions;
+import com.mongodb.client.model.ReturnDocument;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.Document;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.stereotype.Component;
+
+import java.math.BigDecimal;
+import java.text.SimpleDateFormat;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+
+@Component
+@Slf4j
+public class PerformanceVoTask {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private MongoConverter mongoConverter;
+
+    @Autowired
+    private DataUtils dataUtils;
+    @Autowired
+    private RedisUtil redisUtil;
+    @Autowired
+    private MongoVoUtils mongoVoUtils;
+
+    @Autowired
+    private KylinPerformancesMapper performancesMapper;
+
+    @Autowired
+    private KylinPerformanceStatusMapper performanceStatusMapper;
+
+    @Autowired
+    private KylinPerformanceRelationsMapper performanceRelationsMapper;
+
+    @Autowired
+    private KylinTicketTimesPartnerServiceImpl ticketTimesPartnerService;
+
+    @Autowired
+    private KylinTicketsMapper ticketsMapper;
+
+    @Autowired
+    private KylinTicketStatusMapper ticketStatusMapper;
+
+    @Autowired
+    private KylinTicketRelationsMapper ticketRelationsMapper;
+
+    @Autowired
+    private KylinTicketTimesMapper ticketTimesMapper;
+
+    @Autowired
+    private KylinTicketTimeRelationMapper ticketTimeRelationMapper;
+
+    @Autowired
+    private KylinTicketsPartnerServiceImpl ticketsPartnerService;
+
+
+    /**
+     * 根据票状态判断 演出状态 票状态
+     *
+     * @param performanceSingleId
+     */
+    public void performanceVoStatus(String performanceSingleId) {
+        LocalDateTime timeNow = LocalDateTime.now();
+        List<String> performanceIdList = new ArrayList<>();
+
+        if (performanceSingleId == null) {
+            List<KylinPerformanceStatus> list = performanceStatusMapper.selectList(new UpdateWrapper<KylinPerformanceStatus>().in("status", 6, 8, 9));
+            for (KylinPerformanceStatus item : list) {
+                performanceIdList.add(item.getPerformanceId());
+            }
+        } else {
+            performanceIdList.add(performanceSingleId);
+        }
+
+        for (String performancesId : performanceIdList) {
+            KylinPerformanceVo vo = mongoVoUtils.combinePerformanceVoData(performancesId);
+            //场次
+            List<KylinTicketTimesVo> timesData = vo.getTicketTimeList();
+            if (timesData.size() == 0) {
+                continue;
+            }
+            int ticketCount = 0;            //总循环次数
+            int status9Count = 0;            //未开售次数
+            int status8Count = 0;            //售罄次数
+            int status10Count = 0;            //已结束次数
+
+            //演出数据
+            int appStatus = 6;
+            for (KylinTicketTimesVo kylinTicketTimesVoItem : timesData) {
+                //票
+                List<KylinTicketVo> kylinTicketVoList = kylinTicketTimesVoItem.getTicketList();
+                ticketCount += kylinTicketVoList.size();
+                for (KylinTicketVo kylinTicketVoItem : kylinTicketVoList) {
+                    //时间判断
+                    LocalDateTime timeStart = DateUtil.Formatter.yyyyMMddHHmmss.parse(kylinTicketVoItem.getMemberTimeStart());
+                    LocalDateTime timeEnd = DateUtil.Formatter.yyyyMMddHHmmss.parse(kylinTicketVoItem.getTimeEnd());
+                    int surplusGeneral = -1;
+                    int status = 0;
+                    if (timeStart.isAfter(timeNow)) {
+                        //未开始
+                        status = 9;
+                        status9Count += 1;
+                    } else if (timeEnd.isBefore(timeNow)) {
+                        //结束
+                        status = 10;
+                        status10Count += 1;
+                    } else {
+                        //库存判断
+                        surplusGeneral = dataUtils.getSurplusGeneral(kylinTicketVoItem.getTicketsId());
+                        if (surplusGeneral > 0) {
+                            status = 6;
+                        } else {
+                            status = 8;
+                            status8Count += 1;
+                        }
+                    }
+
+                    if (kylinTicketVoItem.getStatus() == 7) {
+                        status = 7;
+                    }
+
+                    //修改票状态
+                    KylinTicketStatus changeStatus = new KylinTicketStatus();
+                    changeStatus.setStatus(status);
+                    if (surplusGeneral != -1) {
+                        changeStatus.setSurplusGeneral(surplusGeneral);
+                    }
+                    ticketStatusMapper.update(changeStatus, new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", kylinTicketVoItem.getTicketsId()));
+                    kylinTicketVoItem.setStatus(status);
+
+                    //演出状态
+                    if (status == 6) {//单一票 可购买 则为可购买
+                        appStatus = 6;
+                    } else if (ticketCount == status10Count) {//全票结束 为结束
+                        appStatus = 10;
+                    } else if (ticketCount == status8Count) {//全票售罄为售罄
+                        appStatus = 8;
+                    } else if (ticketCount == status9Count) {//全票未开始 为未开始
+                        appStatus = 9;
+                    }
+                }
+            }
+            if (vo.getAppStatus() <= 4) {
+                appStatus = vo.getAppStatus();
+            }
+            if (vo.getAppStatus() == 7) {
+                appStatus = 7;
+            }
+            //修改演出状态
+            KylinPerformanceStatus changeStatus = new KylinPerformanceStatus();
+            changeStatus.setStatus(appStatus);
+            performanceStatusMapper.update(changeStatus, new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performancesId));
+            vo.setAppStatus(appStatus);
+            dataUtils.updatePerformanceMongo(performancesId, vo);
+        }
+    }
+
+
+    /**
+     * 生成 PerformanceCreatePartnerVo(用于审核第一次提交数据)
+     *
+     * @param performancesId
+     * @return
+     */
+    public KylinPerformanceMisVo getPerformanceMisVo(String performancesId) {
+        try {
+            PerformancePartnerVo performanceData = mongoTemplate.findOne(Query.query(Criteria.where("performancesId").is(performancesId)), PerformancePartnerVo.class, PerformancePartnerVo.class.getSimpleName());
+            List<KylinTicketTimesPartnerVo> kylinTicketTimesPartnerVos = ticketTimesPartnerService.getTimesMongoList(performancesId);
+            List<TicketTimesTicketCreatePartnerVo> ticketTimesTicketCreatePartnerVoList = new ArrayList<TicketTimesTicketCreatePartnerVo>();
+
+            ArrayList<BigDecimal> floatList = new ArrayList<>();
+            ArrayList<String> StringList = new ArrayList<>();
+
+            for (KylinTicketTimesPartnerVo ticketTimes : kylinTicketTimesPartnerVos) {
+                TicketTimesTicketCreatePartnerVo ticketTimesTicketCreatePartnerVo = new TicketTimesTicketCreatePartnerVo();
+                BeanUtils.copyProperties(ticketTimes, ticketTimesTicketCreatePartnerVo);
+                List<KylinTicketPartnerVo> kylinTicketPartnerVos = ticketsPartnerService.getTicketMongoList(ticketTimes.getTicketTimesId());
+                ticketTimesTicketCreatePartnerVo.setTicket(kylinTicketPartnerVos);
+                ticketTimesTicketCreatePartnerVoList.add(ticketTimesTicketCreatePartnerVo);
+                for (KylinTicketPartnerVo kylinTicketPartnerVoItem : kylinTicketPartnerVos) {
+                    floatList.add(kylinTicketPartnerVoItem.getPrice());
+                    StringList.add(kylinTicketPartnerVoItem.getTimeEnd());
+                }
+            }
+            KylinPerformanceMisVo kylinPerformanceMisVo = new KylinPerformanceMisVo();
+            BeanUtils.copyProperties(performanceData, kylinPerformanceMisVo);
+
+            floatList.sort(Comparator.naturalOrder());
+            StringList.sort(Comparator.naturalOrder());
+
+            kylinPerformanceMisVo.setPrice(floatList.get(0) + "起");
+            kylinPerformanceMisVo.setStopSellTime(StringList.get(0));
+            kylinPerformanceMisVo.setTicketTimes(ticketTimesTicketCreatePartnerVoList);
+
+            kylinPerformanceMisVo.setIsDistribution(0);
+            kylinPerformanceMisVo.setSyncAgent(0);
+            kylinPerformanceMisVo.setAuditStatus(0);
+
+            return kylinPerformanceMisVo;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * 插入数据库
+     *
+     * @param performancesId
+     * @param map
+     * @param kylinPerformanceMisVo
+     * @param updatedAt
+     */
+    public void createPerformanceMySql(String performancesId, HashMap<String, Object> map, KylinPerformanceMisVo kylinPerformanceMisVo, LocalDateTime updatedAt) {
+        try {
+            //创建演出
+            KylinPerformances performances = new KylinPerformances();
+            BeanUtils.copyProperties(kylinPerformanceMisVo, performances);
+            KylinPerformanceStatus performanceStatus = new KylinPerformanceStatus();
+            BeanUtils.copyProperties(kylinPerformanceMisVo, performanceStatus);
+            KylinPerformanceRelations performanceRelations = new KylinPerformanceRelations();
+            BeanUtils.copyProperties(kylinPerformanceMisVo, performanceRelations);
+
+            performances.setCreatedAt(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(kylinPerformanceMisVo.getCreatedAt())));
+            performances.setTimeStart(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(kylinPerformanceMisVo.getTimeStart())));
+            performances.setTimeEnd(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(kylinPerformanceMisVo.getTimeEnd())));
+            performances.setCityName((String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + performanceRelations.getFieldId(), "city_name"));
+            performances.setCityId(Integer.parseInt((String) redisUtil.hget(KylinRedisConst.FIELDS + ":" + performanceRelations.getFieldId(), "city_id")));
+            performances.setUpdatedAt(updatedAt);
+
+            performanceStatus.setPerformanceId(performances.getPerformancesId());
+            performanceStatus.setPerformanceStatusId(IDGenerator.nextSnowId().toString());
+            performanceStatus.setCreatedAt(performances.getCreatedAt());
+            performanceStatus.setAuditStatus(0);
+            performanceStatus.setUpdatedAt(updatedAt);
+
+            performanceStatus.setLimitCountMember(1);
+
+            performanceRelations.setPerformanceId(performances.getPerformancesId());
+            performanceRelations.setPerformanceRelationsId(IDGenerator.nextSnowId().toString());
+            performanceRelations.setCreatedAt(performances.getCreatedAt());
+            performanceRelations.setUpdatedAt(updatedAt);
+
+            performancesMapper.delete(new UpdateWrapper<KylinPerformances>().eq("performances_id", performances.getPerformancesId()));
+            performancesMapper.insert(performances);
+            performanceStatusMapper.delete(new UpdateWrapper<KylinPerformanceStatus>().eq("performance_id", performanceStatus.getPerformanceId()));
+            performanceStatusMapper.insert(performanceStatus);
+            performanceRelationsMapper.delete(new UpdateWrapper<KylinPerformanceRelations>().eq("performance_id", performanceRelations.getPerformanceId()));
+            performanceRelationsMapper.insert(performanceRelations);
+
+
+            //场次数据
+            List<KylinTicketTimesPartnerVo> kylinTicketTimesPartnerVos = ticketTimesPartnerService.getTimesMongoList(performancesId);
+            for (KylinTicketTimesPartnerVo ticketTimeItem : kylinTicketTimesPartnerVos) {
+                //创建场次
+                KylinTicketTimes ticketTimes = new KylinTicketTimes();
+                BeanUtils.copyProperties(ticketTimeItem, ticketTimes);
+                KylinTicketTimeRelation ticketTimeRelation = new KylinTicketTimeRelation();
+                BeanUtils.copyProperties(ticketTimeItem, ticketTimeRelation);
+
+                ticketTimes.setUseStart(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketTimeItem.getUseStart())));
+                ticketTimes.setUseEnd(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketTimeItem.getUseEnd())));
+                ticketTimes.setCreatedAt(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketTimeItem.getCreatedAt())));
+                ticketTimes.setUpdatedAt(updatedAt);
+
+                ticketTimeRelation.setPerformanceId(performancesId);
+                ticketTimeRelation.setTicketTimeRelationId(IDGenerator.nextSnowId().toString());
+                ticketTimeRelation.setTimesId(ticketTimes.getTicketTimesId());
+                ticketTimeRelation.setCreatedAt(ticketTimes.getCreatedAt());
+                ticketTimeRelation.setUpdatedAt(updatedAt);
+
+                ticketTimesMapper.delete(new UpdateWrapper<KylinTicketTimes>().eq("ticket_times_id", ticketTimes.getTicketTimesId()));
+                ticketTimesMapper.insert(ticketTimes);
+                ticketTimeRelationMapper.delete(new UpdateWrapper<KylinTicketTimeRelation>().eq("times_id", ticketTimeRelation.getTimesId()));
+                ticketTimeRelationMapper.insert(ticketTimeRelation);
+
+                //修改票
+                for (KylinTicketPartnerVo ticketItem : ticketsPartnerService.getTicketMongoList(ticketTimeItem.getTicketTimesId())) {
+                    BasicDBObject objectTicketVo = new BasicDBObject("$set", mongoConverter.convertToMongoType(map));
+                    Document docTicket = mongoTemplate.getCollection(KylinTicketPartnerVo.class.getSimpleName()).findOneAndUpdate(
+                            Query.query(Criteria.where("ticketsId").is(ticketItem.getTicketsId())).getQueryObject(),
+                            objectTicketVo,
+                            new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER)
+                    );
+                    KylinTicketPartnerVo kylinTicketPartnerVo = JsonUtils.fromJson(docTicket.toJson(), KylinTicketPartnerVo.class);
+
+                    //创建演出
+                    KylinTickets tickets = new KylinTickets();
+                    BeanUtils.copyProperties(kylinTicketPartnerVo, tickets);
+                    KylinTicketStatus ticketStatus = new KylinTicketStatus();
+                    BeanUtils.copyProperties(kylinTicketPartnerVo, ticketStatus);
+                    KylinTicketRelations ticketRelations = new KylinTicketRelations();
+                    BeanUtils.copyProperties(kylinTicketPartnerVo, ticketRelations);
+
+                    tickets.setPriceExpress(new BigDecimal("0.00"));
+                    tickets.setPriceDiscountMember(new BigDecimal("0.00"));
+                    tickets.setPriceDiscount(new BigDecimal("0.00"));
+                    tickets.setTimeStart(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketItem.getTimeStart())));
+                    tickets.setTimeEnd(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketItem.getTimeEnd())));
+                    if (ticketItem.getIsExpress() == 1) {
+                        tickets.setTimeEndExpress(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketItem.getTimeEndExpress())));
+                        tickets.setDescribeExpress(ticketItem.getDescribeExpress());
+                    }
+                    if (ticketItem.getIsElectronic() == 1) {
+                        tickets.setDescribeElectronic(ticketItem.getDescribeElectronic());
+                    }
+                    tickets.setUseStart(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketTimeItem.getUseStart())));
+                    tickets.setUseEnd(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketTimeItem.getUseEnd())));
+                    tickets.setSaleRemindMinute(60);
+                    tickets.setCreatedAt(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketItem.getCreatedAt())));
+                    tickets.setUpdatedAt(updatedAt);
+
+                    ticketStatus.setTicketStatusId(IDGenerator.nextSnowId().toString());
+                    ticketStatus.setTicketId(tickets.getTicketsId());
+                    ticketStatus.setIsMember(1);
+                    ticketStatus.setIsExclusive(0);
+                    ticketStatus.setIsTrueName(performanceStatus.getIsTrueName());
+                    ticketStatus.setMemberLimitCount(1);
+                    ticketStatus.setStatusExchange(7);
+                    if (ticketItem.getIsShowCode() == 1) {
+                        ticketStatus.setQrCodeShowTime(DateUtil.asLocalDateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(ticketItem.getQrCodeShowTime())));
+                    }
+
+                    ticketRelations.setCreatedAt(tickets.getCreatedAt());
+                    ticketRelations.setUpdatedAt(updatedAt);
+
+                    ticketRelations.setTicketRelationsId(IDGenerator.nextSnowId().toString());
+                    ticketRelations.setTicketId(tickets.getTicketsId());
+                    ticketRelations.setCreatedAt(tickets.getCreatedAt());
+                    ticketRelations.setUpdatedAt(updatedAt);
+
+                    ticketsMapper.delete(new UpdateWrapper<KylinTickets>().eq("tickets_id", tickets.getTicketsId()));
+                    ticketsMapper.insert(tickets);
+                    ticketStatusMapper.delete(new UpdateWrapper<KylinTicketStatus>().eq("ticket_id", ticketStatus.getTicketId()));
+                    ticketStatusMapper.insert(ticketStatus);
+                    ticketRelationsMapper.delete(new UpdateWrapper<KylinTicketRelations>().eq("ticket_id", ticketRelations.getTicketId()));
+                    ticketRelationsMapper.insert(ticketRelations);
+
+                    dataUtils.setSurplusExchange(tickets.getTicketsId(), ticketStatus.getSurplusExchange());
+                    dataUtils.setSurplusGeneral(tickets.getTicketsId(), ticketStatus.getSurplusGeneral());
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    // 判断是否需要审核
+    public boolean judgeIsAudit(String performanceId) {
+        KylinPerformanceMisVo misVo = getPerformanceMisVo(performanceId);
+        KylinPerformanceVo mongoVo = mongoVoUtils.combinePerformanceVoData(performanceId);
+        if (!misVo.getTitle().equals(mongoVo.getTitle())) {
+            log.debug("NEED CHANGE TITLE");
+            return true;
+        } else if (!misVo.getType().equals(mongoVo.getType())) {
+            log.debug("NEED CHANGE TYPE");
+            return true;
+        } else if (!misVo.getTimeStart().equals(mongoVo.getTimeStart())) {
+            log.debug("NEED CHANGE TIMESTART");
+            return true;
+        } else if (!misVo.getTimeEnd().equals(mongoVo.getTimeEnd())) {
+            log.debug("NEED CHANGE TIMEEND");
+            return true;
+        } else if (!misVo.getFieldId().equals(mongoVo.getFieldId())) {
+            log.debug("NEED CHANGE FIELDID");
+            return true;
+        } else if (!misVo.getNotice().equals(mongoVo.getNotice())) {
+            log.debug("NEED CHANGE NOTICE");
+            return true;
+        } else if (!misVo.getDetails().equals(mongoVo.getDetails())) {
+            log.debug("NEED CHANGE DETAILS");
+            return true;
+        } else if (!misVo.getApprovalUrl().equals(mongoVo.getApprovalUrl())) {
+            log.debug("NEED CHANGE APPROVALURL");
+            return true;
+        } else if (!misVo.getPayCountdownMinute().equals(mongoVo.getPayCountdownMinute())) {
+            log.debug("NEED CHANGE PAYCOUTDOWN");
+            return true;
+        }
+
+        boolean exists = mongoTemplate.exists(Query.query(Criteria.where("status").is(-1).and("performancesId").is(performanceId)),
+                KylinTicketTimesPartnerVo.class, KylinTicketTimesPartnerVo.class.getSimpleName());
+        if (exists) {
+            log.debug("NEED CHANGE NEW TIMES");
+            return true;
+        }
+
+        for (int i = 0; i < misVo.getTicketTimes().size(); i++) {
+            TicketTimesTicketCreatePartnerVo times = misVo.getTicketTimes().get(i);
+            KylinTicketTimesVo timesVo = mongoVo.getTicketTimeList().get(i);
+            boolean exists2 = mongoTemplate.exists(Query.query(Criteria.where("status").is(-2).and("timesId").is(times.getTicketTimesId())), KylinTicketPartnerVo.class, KylinTicketPartnerVo.class.getSimpleName());
+            if (exists2) {
+                log.debug("NEED CHANGE NEW TICKET");
+                return true;
+            }
+            for (KylinTicketPartnerVo ticketPartnerVo : times.getTicket()) {
+                for (KylinTicketVo ticketVo : timesVo.getTicketList()) {
+                    if (ticketVo.getTicketsId().equals(ticketPartnerVo.getTicketsId())) {
+                        if (!ticketVo.getTitle().equals(ticketPartnerVo.getTitle())) {
+                            log.debug("NEED CHANGE TICKET TITLE");
+                            log.debug("ticketVo.getTitle() = " + ticketVo.getTitle());
+                            log.debug("ticketPartnerVo.getTitle() = " + ticketPartnerVo.getTitle());
+                            return true;
+                        }
+//                        else if (!ticketVo.getQrCodeShowTime().equals(ticketPartnerVo.getQrCodeShowTime())) {
+//                            log.debug("NEED CHANGE TICKET QRCODESHOWTIME");
+//                            return true;
+//                    }
+                        else if (!ticketVo.getDescribeElectronic().equals(ticketPartnerVo.getDescribeElectronic())) {
+                            log.debug("NEED CHANGE TICKET DESCRIBEELECTRONIC");
+                            log.debug("ticketVo.getDescribeElectronic() =" + ticketVo.getDescribeElectronic());
+                            log.debug("ticketPartnerVo.getDescribeElectronic() =" + ticketPartnerVo.getDescribeElectronic());
+                            return true;
+                        } else if (!ticketVo.getDescribeExpress().equals(ticketPartnerVo.getDescribeExpress())) {
+                            log.debug("NEED CHANGE TICKET DESCRIBEELEXPRESS");
+                            log.debug("ticketVo.getDescribeExpress() =" + ticketVo.getDescribeExpress());
+                            log.debug("ticketPartnerVo.getDescribeExpress() =" + ticketPartnerVo.getDescribeExpress());
+                            return true;
+                        }
+                        if (!ticketVo.getDescribes().equals(ticketPartnerVo.getDescribes())) {
+                            log.debug("NEED CHANGE TICKET DESCRIBES");
+                            log.debug("ticketVo.getDescribes() =" + ticketVo.getDescribes());
+                            log.debug("ticketPartnerVo.getDescribes() =" + ticketPartnerVo.getDescribes());
+                            return true;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}