#feat .

yanghui

2022-11-29 3da01b2a6cf247f90aed86fc37d8cb0ab51a4b4c

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/service/impl/ComActActivityServiceImpl.java

@@ -1,40 +1,96 @@
package com.panzhihua.service_community.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import static java.util.Objects.isNull;
import static java.util.Objects.nonNull;
import static org.apache.commons.lang3.ObjectUtils.isEmpty;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.annotation.Resource;

import cn.binarywang.wx.miniapp.api.WxMaService;
import cn.hutool.core.collection.CollUtil;
import com.panzhihua.common.constants.HttpStatus;
import com.panzhihua.common.model.dtos.community.ActivityInviteDTO;
import com.panzhihua.service_community.dao.ComActNeighborCircleDAO;
import com.panzhihua.service_community.dao.ComActNeighborCircleTopicWestMapper;
import com.panzhihua.service_community.dao.ComPbMemberDAO;
import com.panzhihua.service_community.entity.ComActActivityInvite;
import com.panzhihua.service_community.model.dos.ComActNeighborCircleTopicWestDO;
import com.panzhihua.service_community.service.ComActActivityInviteService;
import com.panzhihua.service_community.util.WxMaConfiguration;
import org.apache.commons.lang3.time.DateUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.common.model.dtos.community.ExcelElderAuthDTO;
import com.panzhihua.common.model.dtos.community.bigscreen.work.ScreenActActivityListDTO;
import com.panzhihua.common.model.dtos.community.bigscreen.work.ScreenActActivityPeopleListDTO;
import com.panzhihua.common.model.dtos.community.integral.admin.AddComActIntegralUserDTO;
import com.panzhihua.common.model.dtos.property.CommonPage;
import com.panzhihua.common.model.vos.IndexDataVO;
import com.panzhihua.common.model.vos.LoginUserInfoVO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.*;
import com.panzhihua.common.model.vos.community.ActivitySignVO;
import com.panzhihua.common.model.vos.community.ComActActEvaluateVO;
import com.panzhihua.common.model.vos.community.ComActActPictureVO;
import com.panzhihua.common.model.vos.community.ComActActRegistVO;
import com.panzhihua.common.model.vos.community.ComActActivityStatisticsVO;
import com.panzhihua.common.model.vos.community.ComActActivityTypeVO;
import com.panzhihua.common.model.vos.community.ComActActivityVO;
import com.panzhihua.common.model.vos.community.CommunityActivitiesVO;
import com.panzhihua.common.model.vos.community.CommunityGovernanceTrendsVO;
import com.panzhihua.common.model.vos.community.PartyActivityLine;
import com.panzhihua.common.model.vos.community.PartyActivityStatics;
import com.panzhihua.common.model.vos.community.PartyActivityTypeChart;
import com.panzhihua.common.model.vos.community.SignactivityVO;
import com.panzhihua.common.model.vos.community.screen.work.ActActivityListVO;
import com.panzhihua.common.model.vos.user.SysTemplateConfigVO;
import com.panzhihua.common.service.user.UserService;
import com.panzhihua.common.utlis.Snowflake;
import com.panzhihua.common.utlis.WxUtil;
import com.panzhihua.common.utlis.WxXCXTempSend;
import com.panzhihua.service_community.dao.ComActActEvaluateDAO;
import com.panzhihua.service_community.dao.ComActActPictureDAO;
import com.panzhihua.service_community.dao.ComActActRegistDAO;
import com.panzhihua.service_community.dao.ComActActSignDAO;
import com.panzhihua.service_community.dao.ComActActivityCodeDao;
import com.panzhihua.service_community.dao.ComActActivityDAO;
import com.panzhihua.service_community.dao.ComActDiscussOptionUserDAO;
import com.panzhihua.service_community.dao.ComActDAO;
import com.panzhihua.service_community.dao.ComActSocialProjectDao;
import com.panzhihua.service_community.dao.ComBpActivityDAO;
import com.panzhihua.service_community.dao.ComPbCheckUnitDao;
import com.panzhihua.service_community.dao.ComStreetDAO;
import com.panzhihua.service_community.entity.ComActActivityCode;
import com.panzhihua.service_community.entity.ComPbCheckUnit;
import com.panzhihua.service_community.model.dos.ComActActEvaluateDO;
import com.panzhihua.service_community.model.dos.ComActActPictureDO;
import com.panzhihua.service_community.model.dos.ComActActRegistDO;
import com.panzhihua.service_community.model.dos.ComActActSignDO;
import com.panzhihua.service_community.model.dos.ComActActivityDO;
import com.panzhihua.service_community.model.dos.ComActDO;
import com.panzhihua.service_community.service.ComActActivityCodeService;
import com.panzhihua.service_community.service.ComActActivityService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.time.DateUtils;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import com.panzhihua.service_community.service.ComActIntegralUserTradeService;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import lombok.extern.slf4j.Slf4j;

/**
 * @program: springcloud_k8s_panzhihuazhihuishequ
@@ -44,90 +100,189 @@
 **/
@Slf4j
@Service
public class ComActActivityServiceImpl extends ServiceImpl<ComActActivityDAO, ComActActivityDO> implements ComActActivityService {
public class ComActActivityServiceImpl extends ServiceImpl<ComActActivityDAO, ComActActivityDO>
    implements ComActActivityService {
    private static final String DELIMITER = ":";
    private static final String ACTIVITY_SIGN_IN = "ACTIVITY:SIGN:IN";
    @Resource
    private ComActActivityDAO comActActivityDAO;
    @Resource
    private ComActActSignDAO comActActSignDAO;
    @Resource
    private UserService userService;
    @Resource
    private ComActActEvaluateDAO comActActEvaluateDAO;
    @Resource
    private ComActActRegistDAO comActActRegistDAO;
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Resource
    private ComActActPictureDAO comActActPictureDAO;
    @Resource
    private ComActActivityCodeDao comActActivityCodeDao;
    @Resource
    private ComBpActivityDAO comBpActivityDAO;
    @Resource
    private ComActIntegralUserTradeService comActIntegralUserTradeService;
    @Resource
    private ComActActivityCodeService comActActivityCodeService;
    @Resource
    private ComActDAO comActDAO;
    @Resource
    private ComPbCheckUnitDao comPbCheckUnitDao;
    @Resource
    private ComActSocialProjectDao comActSocialProjectDao;
    @Resource
    private ComStreetDAO comStreetDAO;
    @Resource
    private ComPbMemberDAO pbMemberDAO;
    @Resource
    private ComActNeighborCircleTopicWestMapper comActNeighborCircleTopicWestMapper;
    @Resource
    private ComActActivityInviteService comActActivityInviteService;
    @Resource
    private ComActNeighborCircleDAO comActNeighborCircleDAO;
    @Resource
    private WxMaConfiguration wxMaConfiguration;

    /**
     * 新增社区活动
     * @param comActActivityVO 新增信息
     * 
     * @param comActActivityVO
     *            新增信息
     * @return 新增结果
     */
    @Override
    public R addActivity(ComActActivityVO comActActivityVO) {
        ComActActivityDO comActActivityDO=new ComActActivityDO();
        BeanUtils.copyProperties(comActActivityVO,comActActivityDO);
        ComActActivityDO comActActivityDO = new ComActActivityDO();
        BeanUtils.copyProperties(comActActivityVO, comActActivityDO);
        Integer status = comActActivityVO.getStatus();
        Date now = new Date();
        if (status.intValue()!=1) {
            comActActivityDO.setPublishAt(now);//发布时间
        if (status.intValue() != 1) {
            comActActivityDO.setPublishAt(now);// 发布时间
        }
        //如果发布时间大于现在时间状态改为进行中
        // 如果发布时间大于现在时间状态改为进行中
        /*if(now.getTime()<comActActivityVO.getBeginAt().getTime()){
            comActActivityDO.setStatus(3);
        }*/
        if(status.intValue()==2) {//点击‘保存并发布’ 按钮
            //报名结束时间大于当前时间则设置为“进行中”
        if (status.intValue() == 2) {// 点击‘保存并发布’ 按钮
            // 报名结束时间大于当前时间则设置为“进行中”
            if (comActActivityVO.getSignUpEnd() != null && now.getTime() < comActActivityVO.getSignUpEnd().getTime()) {
                comActActivityDO.setStatus(4);
                comActActivityDO.setStatus(3);
            }
        }
        if(comActActivityVO.getType()==4){
            comActActivityDO.setIsProject(1);
        }
        if(comActActivityVO.getType()==5){
            comPbCheckUnitDao.selectOne(new QueryWrapper<ComPbCheckUnit>().lambda().eq(ComPbCheckUnit::getAdminPhone,comActActivityVO.getPhone()).last("limit 1"));
        }

        boolean save = this.save(comActActivityDO);
        if(!save){
        if (!save) {
            return R.fail();
        }
        ComActActivityDO one = this.getOne(new QueryWrapper<ComActActivityDO>().lambda().eq(ComActActivityDO::getActivityName, comActActivityDO.getActivityName()).orderByDesc(ComActActivityDO::getCreateAt).last(" limit 1 "));
        ComActActivityDO one = this.getOne(new QueryWrapper<ComActActivityDO>().lambda()
            .eq(ComActActivityDO::getActivityName, comActActivityDO.getActivityName())
            .orderByDesc(ComActActivityDO::getCreateAt).last(" limit 1 "));
        Long activityId = one.getId();

        List<ActivityInviteDTO> inviteList = comActActivityVO.getActivityInviteList();
        if (!isEmpty(inviteList)) {
            List<ComActActivityInvite> inviteEntityList = new ArrayList<>();
            inviteList.forEach(e -> {
                ComActActivityInvite inviteEntity = new ComActActivityInvite();
                BeanUtils.copyProperties(e, inviteEntity);
                inviteEntity.setActivityId(activityId);
                inviteEntity.setCreatedBy(comActActivityVO.getUserId());
                inviteEntityList.add(inviteEntity);
            });
            comActActivityInviteService.saveBatch(inviteEntityList);
        }

        ComActNeighborCircleTopicWestDO topicWestDO = new ComActNeighborCircleTopicWestDO();
        topicWestDO.setCommunityId(comActActivityDO.getCommunityId());
        topicWestDO.setBelongType(2);
        topicWestDO.setRefId(activityId);
        topicWestDO.setName(comActActivityDO.getActivityName());
        topicWestDO.setCreateAt(new Date());
        topicWestDO.setCount(0);
        topicWestDO.setHotNum(0L);
        topicWestDO.setStatus(ComActNeighborCircleTopicWestDO.status.yes);
        comActNeighborCircleTopicWestMapper.insert(topicWestDO);

        ComActActivityDO activityUpdate = new ComActActivityDO();
        BeanUtils.copyProperties(comActActivityDO, activityUpdate);
        activityUpdate.setTopicId(topicWestDO.getId());
        this.baseMapper.updateById(activityUpdate);

        //保存上传照片
        ComActActPictureDO comActActPictureDO = new ComActActPictureDO();
        comActActPictureDO.setActivityId(activityId);
        comActActPictureDO.setUserId(comActActivityVO.getUserId());
        comActActPictureDO.setUploadPicture(comActActivityVO.getCover());
        comActActPictureDO.setSysFlag(0);
        comActActPictureDAO.insert(comActActPictureDO);

        ComActActivityCode comActActivityCode = new ComActActivityCode();
        comActActivityCode.setActivityId(comActActivityDO.getId().longValue());
        comActActivityCode.setCreateTime(new Date());
        comActActivityCode.setType(comActActivityVO.getType());
        comActActivityCode.setStatus(1);
        comActActivityCodeService.save(comActActivityCode);
        return R.ok(activityId);
    }

    /**
     * 编辑社区活动
     *
     * @param comActActivityVO 编辑内容
     * @param comActActivityVO
     *            编辑内容
     * @return 编辑结果
     */
    @Override
    public R putActivity(ComActActivityVO comActActivityVO) {
        ComActActivityDO comActActivityDO = this.comActActivityDAO.selectById(comActActivityVO.getId());
        if(comActActivityDO == null){
        if (comActActivityDO == null) {
            return R.fail("未找到社区活动");
        }

        if(!comActActivityDO.getActivityAddr().equals(comActActivityVO.getActivityAddr()) || !comActActivityDO.getBeginAt().equals(comActActivityVO.getBeginAt())){
            //修改活动开始时间与活动地点需要推送订阅消息给用户
        if (!comActActivityDO.getActivityAddr().equals(comActActivityVO.getActivityAddr())
            || !comActActivityDO.getBeginAt().equals(comActActivityVO.getBeginAt())) {
            // 修改活动开始时间与活动地点需要推送订阅消息给用户
            ActivitySignVO activitySignVO = new ActivitySignVO();
            activitySignVO.setActivityId(comActActivityVO.getId());
            List<ActivitySignVO> activitySignVOS = comActActSignDAO.listActivitySigns(activitySignVO);
            if(!activitySignVOS.isEmpty()){
            if (!activitySignVOS.isEmpty()) {
                try {
                    WxXCXTempSend util = new WxXCXTempSend();
                    String accessToken = util.getAppAccessToken();

                    WxMaService maService = wxMaConfiguration.getMaService("wx118de8a734d269f0");
                    String accessToken = maService.getAccessToken();
                    ComActDO comActDO=comActDAO.selectById(comActActivityDO.getCommunityId());
                    R<SysTemplateConfigVO> r=userService.selectTemplate(comActDO.getAreaCode(),1);
                    activitySignVOS.forEach(activitySignVO1 -> {
                        //变更社区活动推送订阅消息给用户
                        WxUtil.sendSubscribeHDBG(activitySignVO1.getOpenid(),accessToken,comActActivityVO.getActivityName()
                                , com.panzhihua.common.utlis.DateUtils.format(comActActivityDO.getBeginAt()
                                        , com.panzhihua.common.utlis.DateUtils.ymdhms_format),comActActivityDO.getActivityAddr(),
                                com.panzhihua.common.utlis.DateUtils.format(comActActivityVO.getBeginAt()
                                        , com.panzhihua.common.utlis.DateUtils.ymdhms_format),comActActivityVO.getActivityAddr());
                        // 变更社区活动推送订阅消息给用户
                        WxUtil.sendSubscribeHDBG(activitySignVO1.getOpenid(), accessToken,
                            comActActivityVO.getActivityName(),
                            com.panzhihua.common.utlis.DateUtils.format(
                                comActActivityDO.getBeginAt(), com.panzhihua.common.utlis.DateUtils.ymdhms_format),
                            comActActivityDO.getActivityAddr(),
                            com.panzhihua.common.utlis.DateUtils.format(comActActivityVO.getBeginAt(),
                                com.panzhihua.common.utlis.DateUtils.ymdhms_format),
                            comActActivityVO.getActivityAddr(),r.getData().getTemplateId());
                    });
                }catch (Exception e){
                } catch (Exception e) {
                    log.error("消息推送失败，失败原因：" + e.getMessage());
                }
            }
        }
        BeanUtils.copyProperties(comActActivityVO,comActActivityDO);
        BeanUtils.copyProperties(comActActivityVO, comActActivityDO);

        //结束时间大于当前时间则设置为“进行中”
        // 结束时间大于当前时间则设置为“进行中”
        Date now = new Date();
        if(comActActivityVO.getSignUpEnd()!=null && now.getTime()<comActActivityVO.getSignUpEnd().getTime()){
            comActActivityDO.setStatus(4);
        if (comActActivityVO.getSignUpEnd() != null && now.getTime() < comActActivityVO.getSignUpEnd().getTime()
        && now.getTime() > comActActivityVO.getSignUpBegin().getTime()) {
            comActActivityDO.setStatus(3);
            comActActivityDO.setPublishAt(new Date());
        }
        boolean b = this.updateById(comActActivityDO);
        if (b) {
@@ -139,7 +294,8 @@
    /**
     * 分页查询社区活动
     *
     * @param comActActivityVO 查询参数
     * @param comActActivityVO
     *            查询参数
     * @return 分页集合
     */
    @Override
@@ -147,41 +303,65 @@
        Page page = new Page<>();
        Long pageNum = comActActivityVO.getPageNum();
        Long pageSize = comActActivityVO.getPageSize();
        if (null==pageNum||0==pageNum) {
        if (null == pageNum || 0 == pageNum) {
            pageNum = 1l;
        }
        if (null==pageSize||0==pageSize) {
        if (null == pageSize || 0 == pageSize) {
            pageSize = 10l;
        }
        page.setSize(pageSize);
        page.setCurrent(pageNum);
        IPage<ComActActivityVO> iPage = comActActivityDAO.pageActivity(page, comActActivityVO);
        List<ComActActivityVO> records = iPage.getRecords();
        if (!ObjectUtils.isEmpty(records)) {
            records.forEach(comActActivityVO1 -> {
                Integer status = comActActivityVO1.getStatus();
                if (status.intValue()==3) {
                    comActActivityVO1.setStatus(4);
                }
            });
        Long communityId = comActActivityVO.getCommunityId();
        if (null != communityId){
            List<Long> communityIds = comActDAO.selectIds(communityId);
            if (CollUtil.isEmpty(communityIds)) {
                communityIds = new ArrayList<>();
                communityIds.add(communityId);
            }
            comActActivityVO.setCommunityIds(communityIds);
        }
        Integer type = comActActivityVO.getType();
        IPage<ComActActivityVO> iPage = null;
        if (nonNull(type) && type.equals(4)) {
            if (nonNull(comActActivityVO.getCommunityId())) {
                    ComActDO comActDO = comActDAO.selectById(comActActivityVO.getCommunityId());
                    if (nonNull(comActDO)) {
                        comActActivityVO.setStreetId(comActDO.getStreetId());
                    }
            }
            iPage = comActActivityDAO.pageProjectActivity(page, comActActivityVO);
        } else {
            iPage = comActActivityDAO.pageActivity(page, comActActivityVO);
        }
//        List<ComActActivityVO> records = iPage.getRecords();
//        if (!ObjectUtils.isEmpty(records)) {
//            records.forEach(comActActivityVO1 -> {
//                Integer status = comActActivityVO1.getStatus();
//                if (status.intValue() == 3) {
//                    comActActivityVO1.setStatus(4);
//                }
//            });
//        }
        return R.ok(iPage);
    }

    /**
     * 发布活动
     *
     * @param comActActivityVO 主键id 发布时间
     * @param comActActivityVO
     *            主键id 发布时间
     * @return 发布结果
     */
    @Override
    public R releaseActivity(ComActActivityVO comActActivityVO) {
        ComActActivityDO comActActivityDO=new ComActActivityDO();
        comActActivityDO.setId(comActActivityVO.getId());
        ComActActivityDO comActActivityDO = comActActivityDAO.selectById(comActActivityVO.getId());
        comActActivityDO.setPublishAt(comActActivityVO.getPublishAt());
        comActActivityDO.setStatus(comActActivityVO.getStatus());
        comActActivityDO.setStatus(3);
        if (comActActivityVO.getPublishAt().after(comActActivityDO.getSignUpEnd())) {
            comActActivityVO.setStatus(4);
        }
        int update = comActActivityDAO.updateById(comActActivityDO);
        if (update>0) {
        if (update > 0) {
            return R.ok();
        }
        return R.fail();
@@ -190,17 +370,17 @@
    /**
     * 取消活动
     *
     * @param comActActivityVO 取消原因
     * @param comActActivityVO
     *            取消原因
     * @return 取消结果
     */
    @Override
    public R cancelActivity(ComActActivityVO comActActivityVO) {
        ComActActivityDO comActActivityDO=new ComActActivityDO();
        comActActivityDO.setId(comActActivityVO.getId());
        ComActActivityDO comActActivityDO = comActActivityDAO.selectById(comActActivityVO.getId());
        comActActivityDO.setStatus(comActActivityVO.getStatus());
        comActActivityDO.setCancelReason(comActActivityVO.getCancelReason());
        int update = comActActivityDAO.updateById(comActActivityDO);
        if (update>0) {
        if (update > 0) {
            return R.ok();
        }
        return R.fail();
@@ -209,27 +389,45 @@
    /**
     * 活动详情
     *
     * @param id 活动id
     * @param id
     *            活动id
     * @param userId
     * @return 详情
     */
    @Override
    public ComActActivityVO inforActivity(Long id, Long userId) {
        ComActActivityVO comActActivityVO=comActActivityDAO.inforActivity(id);
        ComActActivityVO comActActivityVO = comActActivityDAO.inforActivity(id);
        if (!ObjectUtils.isEmpty(comActActivityVO)) {

            LambdaQueryWrapper<ComActActSignDO> actSignQuery = new LambdaQueryWrapper<>();
            actSignQuery.eq(ComActActSignDO::getActivityId, id);
            if(userId != null){
            if (userId != null) {
                LambdaQueryWrapper<ComActActSignDO> actSignQuery = new LambdaQueryWrapper<>();
                actSignQuery.eq(ComActActSignDO::getActivityId, id);
                actSignQuery.eq(ComActActSignDO::getUserId, userId);
                actSignQuery.eq(ComActActSignDO::getStatus, 1);
                ComActActSignDO comActActSignDO = comActActSignDAO.selectOne(actSignQuery);
                if (!ObjectUtils.isEmpty(comActActSignDO)) {
                    comActActivityVO.setIsSign(1);
                    comActActivityVO.setSignIdentity(comActActSignDO.getSignIdentity());
                }
                List<ComActActRegistDO> regList = comActActRegistDAO.selectList(new QueryWrapper<ComActActRegistDO>().lambda()
                        .eq(ComActActRegistDO::getUserId, userId).eq(ComActActRegistDO::getActivityId, id));
                if (!regList.isEmpty()) {
                    List<ComActActRegistDO> collect = regList.stream().sorted(Comparator.comparing(ComActActRegistDO::getId).reversed()).collect(Collectors.toList());
                    comActActivityVO.setTimes(collect.get(0).getTimes());
                    ComActActRegistDO comActActRegistDO=collect.get(0);
                    if(comActActRegistDO.getEndTime()==null){
                        comActActivityVO.setSignType(2);
                    }
                    else {
                        comActActivityVO.setSignType(1);
                    }
                }
                else {
                    comActActivityVO.setSignType(1);
                }
            }

            ComActActSignDO comActActSignDO = comActActSignDAO.selectOne(actSignQuery);
            if (!ObjectUtils.isEmpty(comActActSignDO)) {
                comActActivityVO.setIsSign(1);
                comActActivityVO.setIsVolunteer(comActActSignDO.getIsVolunteer());
            }else {

            comActActivityVO.setCodeType(1);
            if (comActActivityVO.getRelationId() != null) {
                comActActivityVO.setListDetail(comActNeighborCircleDAO.neighborDetailByApp(comActActivityVO.getRelationId()));
            }
        }
        return comActActivityVO;
@@ -238,14 +436,22 @@
    /**
     * 活动报名名单
     *
     * @param activitySignVO 查询参数
     * @param activitySignVO
     *            查询参数
     * @return 报名人员集合
     */
    @Override
    public R listActivitySign(ActivitySignVO activitySignVO) {

        IPage<ActivitySignVO> activitySignVOS = comActActSignDAO.listActivitySign(new Page(activitySignVO.getPageNum(),activitySignVO.getPageSize()),activitySignVO);
//        List<ActivitySignVO> activitySignVOS = comActActSignDAO.listActivitySign(activitySignVO);
//        ComActActivityDO comActActivityDO=comActActivityDAO.selectById(activitySignVO.getActivityId());
//        if(comActActivityDO!=null){
//            if(comActActivityDO.getType()==3||comActActivityDO.getType()==5){
//                IPage<ActivitySignVO> activitySignVOS = comActActSignDAO
//                        .listActivitySignParty(new Page(activitySignVO.getPageNum(), activitySignVO.getPageSize()), activitySignVO);
//                return R.ok(activitySignVOS);
//            }
//        }
        IPage<ActivitySignVO> activitySignVOS = comActActSignDAO
            .listActivitySign(new Page(activitySignVO.getPageNum(), activitySignVO.getPageSize()), activitySignVO);
        return R.ok(activitySignVOS);
    }

@@ -255,10 +461,93 @@
        return R.ok(activitySignVOS);
    }

    @Override
    public R getSignLists(ActivitySignVO activitySignVO) {
        return R.ok(comActActSignDAO.getSignLists(activitySignVO));
    }

    @Override
    public R pageActivityEvaluates(ComActActEvaluateVO comActActEvaluateVO) {
        IPage<ComActActEvaluateVO> comActActEvaluateVOIPage = comActActEvaluateDAO
                .pageActivityEvaluates(new Page(comActActEvaluateVO.getPageNum(), comActActEvaluateVO.getPageSize()), comActActEvaluateVO);
        return R.ok(comActActEvaluateVOIPage);
    }

    @Override
    public R getEvaluateLists(ComActActEvaluateVO comActActEvaluateVO) {
        return R.ok(comActActEvaluateDAO.getEvaluateLists(comActActEvaluateVO));
    }

    @Override
    public R pageActivityRegists(ComActActRegistVO comActActRegistVO) {
        IPage<ComActActRegistVO> comActActRegistVOIPage = comActActRegistDAO.pageActivityRegists(new Page(comActActRegistVO.getPageNum(), comActActRegistVO.getPageSize()), comActActRegistVO);
        return R.ok(comActActRegistVOIPage);
    }

    @Override
    public R getRegistLists(ComActActRegistVO comActActRegistVO) {
        return R.ok(comActActRegistDAO.getRegistLists(comActActRegistVO));
    }

    @Override
    public R getNoRegistLists(ComActActRegistVO comActActRegistVO) {
        return R.ok(comActActRegistDAO.getNoRegistLists(comActActRegistVO));
    }

    @Override
    public R activityStatistics(Long activityId) {
        ComActActivityStatisticsVO comActActivityStatisticsVO = comActActivityDAO.activityStatistics(activityId);
        if (comActActivityStatisticsVO != null) {
            if (comActActivityStatisticsVO.getSignTotal().equals(0)){
                comActActivityStatisticsVO.setSignTotalStr("不限");
                comActActivityStatisticsVO.setNoSignTotalStr("");
                comActActivityStatisticsVO.setSignPersent("");
            }else {
                comActActivityStatisticsVO.setSignTotalStr(String.valueOf(comActActivityStatisticsVO.getSignTotal()));
                comActActivityStatisticsVO.setNoSignTotalStr(String.valueOf(Integer.valueOf(comActActivityStatisticsVO.getSignTotalStr()) - comActActivityStatisticsVO.getReallySignTotal()));
                comActActivityStatisticsVO.setSignPersent(getPersent(comActActivityStatisticsVO.getReallySignTotal(),comActActivityStatisticsVO.getSignTotal()));
            }
            comActActivityStatisticsVO.setRegistPersent(getPersent(comActActivityStatisticsVO.getReallyRegistTotal(),comActActivityStatisticsVO.getRegistTotal()));
            comActActivityStatisticsVO.setEvaluatePersent(getPersent(comActActivityStatisticsVO.getReallyEvaluateTotal(),comActActivityStatisticsVO.getEvaluateTotal()));
        }
        return R.ok(comActActivityStatisticsVO);
    }

    @Override
    public R getPictureList(Long userId) {
        List<ComActActPictureVO> comActActPictureVOS = new ArrayList<>();
        List<ComActActPictureDO> comActActPictureDOS = comActActPictureDAO.selectList(new QueryWrapper<ComActActPictureDO>().lambda().
                eq(ComActActPictureDO::getUserId, userId));
        if (comActActPictureDOS != null && comActActPictureDOS.size() != 0) {
            comActActPictureDOS.forEach(comActActPictureDO -> {
                ComActActPictureVO comActActPictureVO = new ComActActPictureVO();
                BeanUtils.copyProperties(comActActPictureDO, comActActPictureVO);
                comActActPictureVOS.add(comActActPictureVO);
            });
        }
        return R.ok(comActActPictureVOS);
    }

    @Override
    public R getSysPictureList(Integer type) {
        List<ComActActPictureVO> comActActPictureVOS = new ArrayList<>();
        List<ComActActPictureDO> comActActPictureDOS = comActActPictureDAO.selectList(new QueryWrapper<ComActActPictureDO>().lambda().
                eq(ComActActPictureDO::getSysFlag, 1).eq(ComActActPictureDO :: getType, type));
        if (comActActPictureDOS != null && comActActPictureDOS.size() != 0) {
            comActActPictureDOS.forEach(comActActPictureDO -> {
                ComActActPictureVO comActActPictureVO = new ComActActPictureVO();
                BeanUtils.copyProperties(comActActPictureDO, comActActPictureVO);
                comActActPictureVOS.add(comActActPictureVO);
            });
        }
        return R.ok(comActActPictureVOS);
    }

    /**
     * 分页展示我的所有活动 时间倒序排列
     *
     * @param comActActivityVO 分页参数
     * @param comActActivityVO
     *            分页参数
     * @return 分页集合
     */
    @Override
@@ -266,10 +555,10 @@
        Page page = new Page<>();
        Long pageNum = comActActivityVO.getPageNum();
        Long pageSize = comActActivityVO.getPageSize();
        if (null==pageNum||0==pageNum) {
        if (null == pageNum || 0 == pageNum) {
            pageNum = 1l;
        }
        if (null==pageSize||0==pageSize) {
        if (null == pageSize || 0 == pageSize) {
            pageSize = 10l;
        }
        page.setSize(pageSize);
@@ -281,7 +570,8 @@
    /**
     * 报名/取消报名社区活动
     *
     * @param signactivityVO 报名参数
     * @param signactivityVO
     *            报名参数
     * @return 报名 取消报名 结果
     */
    @Override
@@ -289,49 +579,131 @@
        Long activityId = signactivityVO.getActivityId();
        Integer type = signactivityVO.getType();
        Long userId = signactivityVO.getUserId();
        Integer isVolunteer = signactivityVO.getIsVolunteer();

        int num=0;
        if (1==type) {
            R<LoginUserInfoVO> userInfoR = userService.getUserInfoByUserId(String.valueOf(userId));
            LoginUserInfoVO loginUserInfoVO = JSONObject.parseObject(JSONObject.toJSONString(userInfoR.getData()), LoginUserInfoVO.class);
            boolean userNotVolunteer = !(loginUserInfoVO.getIsVolunteer()==1);
            if(isVolunteer == 1 && userNotVolunteer){
                return R.fail("只有志愿者才能报名");
        Integer isVolunteer = 0;
        // 查询社区活动
        ComActActivityDO actActivityDO = this.baseMapper.selectById(activityId);
        if (isNull(actActivityDO)) {
            return R.fail("活动不存在");
        }
        if(actActivityDO.getSignUpBegin().after(new Date())){
            return R.fail("未到报名时间");
        }
        int num = 0;
        ComActActSignDO comActActSignDO = comActActSignDAO.selectOne(new QueryWrapper<ComActActSignDO>()
                .lambda().eq(ComActActSignDO::getActivityId, activityId).eq(ComActActSignDO::getUserId, userId));
        Integer signIdentity = signactivityVO.getSignIdentity();
        if (1 == type) {
            if (nonNull(comActActSignDO) && comActActSignDO.getStatus().equals(1)) {
                return R.fail("已经报名过了，请勿重复提交");
            }

            //查询社区活动
            ComActActivityDO actActivityDO = this.baseMapper.selectById(activityId);
            if(actActivityDO != null){
                //查询当前活动下参与志愿者/居民数量
                Integer count = comActActSignDAO.selectCount(new QueryWrapper<ComActActSignDO>().lambda().eq(ComActActSignDO::getActivityId,activityId)
                        .eq(ComActActSignDO::getIsVolunteer,isVolunteer));
                if(isVolunteer.equals(1) && actActivityDO.getVolunteerMax() <= count && !actActivityDO.getVolunteerMax().equals(-1)){
                    return R.fail("志愿者报名人数已满");
                }

                if(isVolunteer.equals(0) && actActivityDO.getParticipantMax() <= count && !actActivityDO.getParticipantMax().equals(-1)){
                    return R.fail("居民报名人数已满");
            Integer activityType = actActivityDO.getType();
            Boolean isInvite = false;
            if (activityType == 1) {
                if (signIdentity == 1) {
                    //以居民身份参与活动
                    Integer residentMax = actActivityDO.getParticipantMax();
                    if (residentMax == null) {
                        return R.fail("活动暂未对居民开放");
                    }
                    // 查询当前活动下参与居民
                    Integer residentCount = comActActSignDAO.selectCount(new QueryWrapper<ComActActSignDO>().lambda()
                            .eq(ComActActSignDO::getActivityId, activityId).eq(ComActActSignDO::getSignIdentity, 1).eq(ComActActSignDO::getStatus, 1));
                    if (residentMax != -1 && residentMax <= residentCount) {
                        return R.fail("报名人数已满");
                    }
                } else if (signIdentity == 2) {
                    //以党员身份参与活动
                    Integer partyMemberMax = actActivityDO.getPartyMemberMax();
                    if (partyMemberMax == null) {
                        return R.fail("活动暂未对党员开放");
                    }
                    ComActActivityInvite activityInvite = comActActivityInviteService.getBaseMapper().selectOne(new LambdaQueryWrapper<ComActActivityInvite>()
                            .eq(ComActActivityInvite::getActivityId, activityId).eq(ComActActivityInvite::getUserId, userId));
                    if (isNull(activityInvite)) {
                        int count = pbMemberDAO.checkIsPbMember(userId);
                        if (count < 1) {
                            return R.fail(HttpStatus.NOT_ACCEPTABLE, "您还不是党员");
                        }
                        // 查询当前活动下参与志愿者
                        Integer partyMemberCount = comActActSignDAO.selectCount(new QueryWrapper<ComActActSignDO>().lambda()
                                .eq(ComActActSignDO::getActivityId, activityId).eq(ComActActSignDO::getSignIdentity, 2)
                                .eq(ComActActSignDO::getStatus, 1).eq(ComActActSignDO::getIsInvite, false));
                        if (partyMemberMax != -1 && partyMemberMax <= partyMemberCount) {
                            return R.fail("报名人数已满");
                        }
                    } else {
                        isInvite = true;
                    }
                } else {
                    //以志愿者身份参与活动
                    Integer volunteerMax = actActivityDO.getVolunteerMax();
                    if (volunteerMax == null) {
                        return R.fail("活动暂未对志愿者开放");
                    }
                    int count = pbMemberDAO.checkIsVolunteer(userId);
                    if (count < 1) {
                        return R.fail(HttpStatus.NOT_ACCEPTABLE, "您还不是志愿者");
                    }
                    // 查询当前活动下参与志愿者
                    Integer volunteerCount = comActActSignDAO.selectCount(new QueryWrapper<ComActActSignDO>().lambda()
                            .eq(ComActActSignDO::getActivityId, activityId).eq(ComActActSignDO::getSignIdentity, 3).eq(ComActActSignDO::getStatus, 1));
                    if (volunteerMax != -1 && volunteerMax <= volunteerCount) {
                        return R.fail("报名人数已满");
                    }
                }
            }

            ComActActSignDO comActActSignDO=new ComActActSignDO();
            comActActSignDO.setActivityId(activityId);
            comActActSignDO.setUserId(userId);
            comActActSignDO.setIsVolunteer(isVolunteer);
            try {
            if (nonNull(comActActSignDO)) {
                comActActSignDO.setStatus(1);
                comActActSignDO.setCreateAt(new Date());
                comActActSignDO.setReason(null);
                comActActSignDO.setSignIdentity(signIdentity);
                comActActSignDO.setTimes(comActActSignDO.getTimes()+1);
                comActActSignDO.setIsInvite(isInvite);
                comActActSignDO.setCheckUnitId(signactivityVO.getCheckUnitId());
                num = comActActSignDAO.updateById(comActActSignDO);
            } else {
                comActActSignDO = new ComActActSignDO();
                comActActSignDO.setActivityId(activityId);
                comActActSignDO.setUserId(userId);
                comActActSignDO.setSignIdentity(signIdentity);
                comActActSignDO.setTimes(1);
                comActActSignDO.setIsInvite(isInvite);
                comActActSignDO.setCheckUnitId(signactivityVO.getCheckUnitId());
                num = comActActSignDAO.insert(comActActSignDO);
            } catch (Exception e) {
                if (e.getMessage().contains("unique_activity_id_user_id")) {
                    return R.fail("已经报名过了，请勿重复提交");
                }
                log.error(e.getMessage());
            }
        } else {
            num = comActActSignDAO.delete(new QueryWrapper<ComActActSignDO>().lambda().eq(ComActActSignDO::getUserId, userId).eq(ComActActSignDO::getActivityId, activityId).eq(ComActActSignDO::getIsVolunteer, isVolunteer));
            Integer regTimes = comActActRegistDAO.selectCount(new QueryWrapper<ComActActRegistDO>().lambda()
                    .eq(ComActActRegistDO::getActivityId, activityId).eq(ComActActRegistDO::getUserId, userId).eq(ComActActRegistDO::getType, 1));
            Integer canCancel = actActivityDO.getCanCancel();
            if (nonNull(canCancel) && canCancel.equals(2)) {
                return R.fail("该活动暂不支持取消");
            }
            if (regTimes > 0) {
                return R.fail("您已参与活动，不可取消");
            }
            if (isNull(signactivityVO.getReason())) {
                return R.fail("缺少取消原因");
            }
            if (isNull(comActActSignDO)) {
                return R.fail("未报名");
            }
            comActActSignDO.setStatus(0);
            comActActSignDO.setReason(signactivityVO.getReason());
            num = comActActSignDAO.updateById(comActActSignDO);
            if (num > 0) {
                AddComActIntegralUserDTO addComActIntegralUserDTO = new AddComActIntegralUserDTO();
                addComActIntegralUserDTO.setUserId(userId);
                addComActIntegralUserDTO.setIntegralType(8);
                addComActIntegralUserDTO.setIntegral(actActivityDO.getCancelDeduct());
                addComActIntegralUserDTO.setSignIdentity(comActActSignDO.getSignIdentity());
                addComActIntegralUserDTO.setCommunityId(actActivityDO.getCommunityId());
                addComActIntegralUserDTO.setServiceId(activityId);
                addComActIntegralUserDTO.setRemark(actActivityDO.getType().intValue() == 5 ? "单位党员活动-取消报名" : "社区活动-取消报名");
                comActIntegralUserTradeService.addIntegralTradeAdmin(addComActIntegralUserDTO);
            }
        }
        if (num>0) {
            return R.ok();
        if (num > 0) {
            return R.ok(isVolunteer);
        }
        return R.fail();
    }
@@ -339,48 +711,75 @@
    /**
     * 用户参加的所有社区活动
     *
     * @param userId 用户id
     * @param userId
     *            用户id
     * @param status
     * @return 活动列表
     */
    @Override
    public R listActivity(Long userId) {
        List<ComActActSignDO> comActActSignDOS = comActActSignDAO.selectList(new QueryWrapper<ComActActSignDO>().lambda().eq(ComActActSignDO::getUserId, userId));
        if (ObjectUtils.isEmpty(comActActSignDOS)) {
            return R.fail();
    public R listActivity(Long userId, Integer status,Integer type) {
        List<ActivitySignVO> activitySignVOList = comActActSignDAO.selectList(userId);
        if (ObjectUtils.isEmpty(activitySignVOList)) {
            return R.ok();
        }
        List<Long> longs = comActActSignDOS.stream().map(comActActSignDO -> comActActSignDO.getActivityId()).collect(Collectors.toList());
        List<Long> longs = activitySignVOList.stream().map(activitySignVO -> activitySignVO.getActivityId())
            .collect(Collectors.toList());
        List<ComActActivityDO> comActActivityDOS = comActActivityDAO.selectBatchIds(longs);
        List<ComActActivityVO>comActActivityVOS=new ArrayList<>();
        comActActivityDOS.forEach(comActActivityDO -> {
            ComActActivityVO comActActivityVO=new ComActActivityVO();
            BeanUtils.copyProperties(comActActivityDO,comActActivityVO);
            List<ComActActSignDO> collect = comActActSignDOS.stream().filter(comActActSignDO -> comActActSignDO.getActivityId().equals(comActActivityVO.getId())).limit(1).collect(Collectors.toList());
            ComActActSignDO comActActSignDO = collect.get(0);
            Integer isVolunteer = comActActSignDO.getIsVolunteer();
            if (isVolunteer.intValue()==1) {
                comActActivityVO.setType(1);
        List<ComActActivityVO> comActActivityVOS = new ArrayList<>();
        if (nonNull(status)) {
            if(status.equals(4)){
                comActActivityDOS = comActActivityDOS.stream()
                        .filter(activityDO -> activityDO.getStatus().equals(3)||activityDO.getStatus().equals(4)).collect(Collectors.toList());
            }else{
                comActActivityVO.setType(2);
                comActActivityDOS = comActActivityDOS.stream()
                        .filter(activityDO -> activityDO.getStatus().equals(status)).collect(Collectors.toList());
            }
            Integer status = comActActivityVO.getStatus();
            if (status.intValue()==3) {
                comActActivityVO.setStatus(4);
            }
            comActActivityVO.setSingDate(comActActSignDOS.stream().filter(comActActSignDO1 -> comActActSignDO1.getActivityId().equals(comActActivityVO.getId())).collect(Collectors.toList()).get(0).getCreateAt());
            comActActivityVOS.add(comActActivityVO);
        });
        }
        if(!isNull(type)){
            comActActivityDOS=comActActivityDOS.stream().filter(comActActivityDO -> comActActivityDO.getType().equals(type)).collect(Collectors.toList());
        }
        if (!comActActivityDOS.isEmpty()) {
            comActActivityDOS.forEach(comActActivityDO -> {
                ComActActivityVO comActActivityVO = new ComActActivityVO();
                BeanUtils.copyProperties(comActActivityDO, comActActivityVO);
                List<ActivitySignVO> collect = activitySignVOList.stream()
                        .filter(activitySignVO -> activitySignVO.getActivityId().equals(comActActivityVO.getId()))
                        .collect(Collectors.toList());
                comActActivityVO.setSignCount(collect.size());
                comActActivityVO.setIsComment(0);
                comActActivityVO.setIsRegist(0);
                ActivitySignVO activitySignVO = collect.get(0);
                Integer activityStatus = comActActivityVO.getStatus();
                if (activityStatus.intValue() == 3) {
                    comActActivityVO.setStatus(4);
                }
                Date createAt = null;
                try {
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    createAt = simpleDateFormat.parse(activitySignVO.getCreateAt());
                } catch (ParseException e) {
                    log.error("时间转换异常【{}】", e.getMessage());
                }
                comActActivityVO.setSingDate(createAt);
                Integer totalAward = comActActRegistDAO.selectTotalAwardWithRegist(activitySignVO.getActivityId(), userId);
                comActActivityVO.setAward(totalAward);
                comActActivityVO.setActivitySignVOList(collect);
                comActActivityVOS.add(comActActivityVO);
            });
        }
        return R.ok(comActActivityVOS);
    }

    /**
     * 查询志愿者参与的所有已经完成的活动
     *
     * @param phone 用户手机号
     * @param phone
     *            用户手机号
     * @return 所有活动集合
     */
    @Override
    public List<ComActActivityVO> listActivityByPhone(String phone) {
        List<ComActActivityVO> comActActivityVOS=comActActivityDAO.listActivityByPhone(phone);
        List<ComActActivityVO> comActActivityVOS = comActActivityDAO.listActivityByPhone(phone);
        return comActActivityVOS;
    }

@@ -391,32 +790,34 @@
     */
    @Override
    public R timedTaskActActivity() {
        List<Long>longs=comActActivityDAO.selectTimedTaskActActivity();
        if (ObjectUtils.isEmpty(longs)) {
            return R.fail("没有需要取消的社区活动");
        }
        List<ComActActivityDO> comActActivityDOS = comActActivityDAO.selectBatchIds(longs);
        List<ComActActivityVO>comActActivityVOS=new ArrayList<>();
        if (!ObjectUtils.isEmpty(comActActivityDOS)) {
            comActActivityDOS.forEach(comActActivityDO -> {
                ComActActivityVO comActActivityVO=new ComActActivityVO();
                BeanUtils.copyProperties(comActActivityDO,comActActivityVO);
                List<ComActActSignDO> comActActSignDOS = comActActSignDAO.selectList(new QueryWrapper<ComActActSignDO>().lambda().eq(ComActActSignDO::getActivityId, comActActivityDO.getId()));
                if (!ObjectUtils.isEmpty(comActActSignDOS)) {
                    List<ActivitySignVO> activitySignVOList=new ArrayList<>();
                    comActActSignDOS.forEach(comActActSignDO -> {
                        ActivitySignVO activitySignVO=new ActivitySignVO();
                        BeanUtils.copyProperties(comActActSignDO,activitySignVO);
                        activitySignVOList.add(activitySignVO);
                        comActActivityVO.setActivitySignVOList(activitySignVOList);
                    });
                }
                comActActivityVOS.add(comActActivityVO);
            });
            int num=comActActivityDAO.updateIdBatch(longs);
            log.info("定时任务--一共取消社区活动数量【{}】",num);
        }
        return R.ok(comActActivityVOS);
//        List<Long> longs = comActActivityDAO.selectTimedTaskActActivity();
//        if (ObjectUtils.isEmpty(longs)) {
//            return R.fail("没有需要取消的社区活动");
//        }
//        List<ComActActivityDO> comActActivityDOS = comActActivityDAO.selectBatchIds(longs);
//        List<ComActActivityVO> comActActivityVOS = new ArrayList<>();
//        if (!ObjectUtils.isEmpty(comActActivityDOS)) {
//            comActActivityDOS.forEach(comActActivityDO -> {
//                ComActActivityVO comActActivityVO = new ComActActivityVO();
//                BeanUtils.copyProperties(comActActivityDO, comActActivityVO);
//                List<ComActActSignDO> comActActSignDOS = comActActSignDAO.selectList(new QueryWrapper<ComActActSignDO>()
//                    .lambda().eq(ComActActSignDO::getActivityId, comActActivityDO.getId()));
//                if (!ObjectUtils.isEmpty(comActActSignDOS)) {
//                    List<ActivitySignVO> activitySignVOList = new ArrayList<>();
//                    comActActSignDOS.forEach(comActActSignDO -> {
//                        ActivitySignVO activitySignVO = new ActivitySignVO();
//                        BeanUtils.copyProperties(comActActSignDO, activitySignVO);
//                        activitySignVOList.add(activitySignVO);
//                        comActActivityVO.setActivitySignVOList(activitySignVOList);
//                    });
//                }
//                comActActivityVOS.add(comActActivityVO);
//            });
//            int num = comActActivityDAO.updateIdBatch(longs);
//            log.info("定时任务--一共取消社区活动数量【{}】", num);
//        }
//        return R.ok(comActActivityVOS);
        return R.ok();
    }

    /**
@@ -426,26 +827,61 @@
     */
    @Override
    public R timedTaskActActivityAll() {
//        修改发布状态 变为未开始
        int num=comActActivityDAO.updateStatusToNotBegin();
        log.info("定时任务--修改社区活动发布状态活动数量【{}】",num);
//        修改报名状态 变为报名中
        int num1=comActActivityDAO.updateStatusToBeginSign();
        log.info("定时任务--修改社区活动报名状态活动数量【{}】",num1);
        //查询已经结束的活动，需要计算积分
        List<Long> activityEndIds = comActActivityDAO.getActivityEndIds();
//        修改进行状态 变为进行中或者已结束
        int num2=comActActivityDAO.updateStatusToBeginActiveOrEnd();
        log.info("定时任务--修改社区活动进行状态活动数量【{}】",num2);
        int num3=comActActivityDAO.updateStatusToBeginAfterSingEnd();
        log.info("定时任务--报名结束修改社区活动进行状态活动数量【{}】",num3);
        // 修改发布状态 变为未开始
        int num = comActActivityDAO.updateStatusToNotBegin();
        log.info("定时任务--修改社区活动发布状态活动数量【{}】", num);
        // 修改报名状态 变为报名中
//        int num1 = comActActivityDAO.updateStatusToBeginSign();
//        log.info("定时任务--修改社区活动报名状态活动数量【{}】", num1);
        // 查询已经结束的活动，需要计算积分
        List<Long> activityEndIds = comActActivityDAO.selectBeginIds();
        WxMaService maService = wxMaConfiguration.getMaService("wx118de8a734d269f0");
        if(!CollectionUtils.isEmpty(activityEndIds)){
            activityEndIds.forEach(activityId->{
                List<String> openIds=comActActivityDAO.selectOpenIdByActivityId(activityId);
                if(!CollectionUtils.isEmpty(openIds)){
                    openIds.forEach(op->{
                        WxXCXTempSend wxXCXTempSend=new WxXCXTempSend();
                        try {
                            WxUtil.sendLongTimeTemplate(op,maService.getAccessToken(),"活动开始提醒","您参加的活动已开始","packageC/pages/activity/communityActivityDetails/communityActivityDetails?id="+activityId);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    });
                }
            });
        }
        int num3 = comActActivityDAO.updateStatusToBeginAfterSingEnd();
        log.info("定时任务--报名结束修改社区活动进行状态活动数量【{}】", num3);
        // 修改进行状态 变为进行中或者已结束
        List<Long> ids = comActActivityDAO.getActivityEndIds();
        if(!CollectionUtils.isEmpty(ids)){
            int num2 = comActActivityDAO.updateStatusToBeginActiveOrEnd();
            log.info("定时任务--修改社区活动进行状态活动数量【{}】", num2);
            ids.forEach(id ->{
                List<String> openIds=comActActivityDAO.selectOpenIdByActivityId(id);
                if(!CollectionUtils.isEmpty(openIds)){
                    openIds.forEach(op->{
                        WxXCXTempSend wxXCXTempSend=new WxXCXTempSend();
                        try {
                            WxUtil.sendLongTimeTemplate(op,maService.getAccessToken(),"活动结束提醒","您参加的活动已结束","packageC/pages/activity/communityActivityDetails/communityActivityDetails?id="+id);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    });
                }
            });
        }


        return R.ok(activityEndIds);
    }

    /**
     * 社区后台分页查询社区活动
     *
     * @param comActActivityVO 查询参数
     * @param comActActivityVO
     *            查询参数
     * @return 返回结果
     */
    @Override
@@ -453,36 +889,66 @@
        Page page = new Page<>();
        Long pageNum = comActActivityVO.getPageNum();
        Long pageSize = comActActivityVO.getPageSize();
        if (null==pageNum||0==pageNum) {
        if (null == pageNum || 0 == pageNum) {
            pageNum = 1l;
        }
        if (null==pageSize||0==pageSize) {
        if (null == pageSize || 0 == pageSize) {
            pageSize = 10l;
        }
        page.setSize(pageSize);
        page.setCurrent(pageNum);
        Long communityId = comActActivityVO.getCommunityId();
        if (null != communityId){
            List<Long> communityIds = comActDAO.selectIds(communityId);
            if (CollUtil.isEmpty(communityIds)) {
                communityIds = new ArrayList<>();
                communityIds.add(communityId);
            }
            comActActivityVO.setCommunityIds(communityIds);
        }
        IPage<ComActActivityVO> iPage = comActActivityDAO.pageActivityCommunityBack(page, comActActivityVO);
        iPage.getRecords().forEach(vo ->{
            List<ComActActEvaluateDO> comActActEvaluateDOList = comActActEvaluateDAO
                    .selectList(new QueryWrapper<ComActActEvaluateDO>().lambda().eq(ComActActEvaluateDO::getActivityId, vo.getId()));
            if (comActActEvaluateDOList != null && comActActEvaluateDOList.size() > 0) {
                BigDecimal starNum = BigDecimal.ZERO;
                //总星级
                for (ComActActEvaluateDO evaluateDO:comActActEvaluateDOList) {
                    starNum = starNum.add(BigDecimal.valueOf(evaluateDO.getStarLevel()==null?0:evaluateDO.getStarLevel()));
                }
                //评分星级(如果无评分默认5分)=总星级/总评价人数
                if(starNum.compareTo(BigDecimal.ZERO) == 0){
                    vo.setEvaluateLevel(BigDecimal.valueOf(5));
                }else{
                    vo.setEvaluateLevel(starNum.divide(BigDecimal.valueOf(comActActEvaluateDOList.size()),2, RoundingMode.HALF_UP));
                }
            }else{
                vo.setEvaluateLevel(BigDecimal.valueOf(5));
            }
        });
        return R.ok(iPage);
    }

    /**
     * 首页图表数据汇总
     *
     * @param communityId 社区id
     * @param communityId
     *            社区id
     * @return 图表数据 IndexDataVO
     */
    @Override
    public R indexDataCommunityBackstageEchart(Long communityId) {
        IndexDataVO indexDataVO=new IndexDataVO();
        CommunityGovernanceTrendsVO communityGovernanceTrendsVO=new CommunityGovernanceTrendsVO();
        List<CommunityActivitiesVO> communityActivitiesVOS=new ArrayList<>();
        List<Date>dates=this.getServenDays();
        String s=comActActivityDAO.selectCommunityGovernanceTrendsVO(communityId);
        List<String>y= Arrays.asList(s.split(","));
        IndexDataVO indexDataVO = new IndexDataVO();
        CommunityGovernanceTrendsVO communityGovernanceTrendsVO = new CommunityGovernanceTrendsVO();
        List<CommunityActivitiesVO> communityActivitiesVOS = new ArrayList<>();
        List<Date> dates = this.getServenDays();
        String s = comActActivityDAO.selectCommunityGovernanceTrendsVO(communityId);
        List<String> y = Arrays.asList(s.split(","));
        communityGovernanceTrendsVO.setY(y);
        communityGovernanceTrendsVO.setX(Arrays.asList(new String[]{"一起议","微心愿","随手拍","社区活动"}));
        communityGovernanceTrendsVO.setX(Arrays.asList("一起议", "微心愿", "随手拍", "社区活动"));
        dates.forEach(date -> {
            CommunityActivitiesVO communityActivitiesVO=comActActivityDAO.selectCommunityActivitiesVO(communityId,date);
            CommunityActivitiesVO communityActivitiesVO =
                comActActivityDAO.selectCommunityActivitiesVO(communityId, date);
            communityActivitiesVO.setDate(date);
            communityActivitiesVOS.add(communityActivitiesVO);
        });
@@ -493,13 +959,14 @@
    }

    @Override
    public R getScreenActActivityList(ScreenActActivityListDTO actActivityListDTO){
    public R getScreenActActivityList(ScreenActActivityListDTO actActivityListDTO) {
        IPage<ActActivityListVO> actActivityListVOIPage = comActActivityDAO.getScreenActActivityList(
                new Page(actActivityListDTO.getPageNum(),actActivityListDTO.getPageSize()),actActivityListDTO);
        if(!actActivityListVOIPage.getRecords().isEmpty()){
            new Page(actActivityListDTO.getPageNum(), actActivityListDTO.getPageSize()), actActivityListDTO);
        if (!actActivityListVOIPage.getRecords().isEmpty()) {
            actActivityListVOIPage.getRecords().forEach(actActivityListVO -> {
                ActActivityListVO activityListVO = comActActivityDAO.getScreenActActivityPeopleCount(actActivityListVO.getId());
                if(activityListVO != null){
                ActActivityListVO activityListVO =
                    comActActivityDAO.getScreenActActivityPeopleCount(actActivityListVO.getId());
                if (activityListVO != null) {
                    actActivityListVO.setParticipantCount(activityListVO.getParticipantCount());
                    actActivityListVO.setVolunteerCount(activityListVO.getVolunteerCount());
                }
@@ -509,62 +976,331 @@
    }

    @Override
    public R getActActivityPeopleList(ScreenActActivityPeopleListDTO activityPeopleListDTO){
        return R.ok(comActActSignDAO.getActActivityPeopleList(new Page(activityPeopleListDTO.getPageNum(),activityPeopleListDTO.getPageSize()),activityPeopleListDTO));
    public R getActActivityPeopleList(ScreenActActivityPeopleListDTO activityPeopleListDTO) {
        return R.ok(comActActSignDAO.getActActivityPeopleList(
            new Page(activityPeopleListDTO.getPageNum(), activityPeopleListDTO.getPageSize()), activityPeopleListDTO));
    }

    /**
     * 获取最近七天的时间
     * 
     * @return
     */
    private List<Date> getServenDays() {
        List<Date> dates=new ArrayList<>();
        Date date=new Date();
        for(int i=6;i>=0;i--){
            Date date1= DateUtils.addDays(date,-i);
        List<Date> dates = new ArrayList<>();
        Date date = new Date();
        for (int i = 6; i >= 0; i--) {
            Date date1 = DateUtils.addDays(date, -i);
            dates.add(date1);
        }
        return dates;
    }


    /**
     * 定时任务检测即将开始的社区活动，并使用订阅消息通知用户
     */
    @Override
    public R timedTaskActivityNotice(){
        //查询所有即将开始的活动
        List<ComActActivityDO> actActivityList = comActActivityDAO.selectList(new QueryWrapper<ComActActivityDO>().lambda()
                .le(ComActActivityDO::getBeginAt, DateUtils.addDays(new Date(),1))
                .ge(ComActActivityDO::getBeginAt,new Date()));
        if(!actActivityList.isEmpty()){
            WxXCXTempSend util = new WxXCXTempSend();
    public R timedTaskActivityNotice() {
        // 查询所有即将开始的活动
        List<ComActActivityDO> actActivityList = comActActivityDAO.selectList(new QueryWrapper<ComActActivityDO>()
            .lambda().le(ComActActivityDO::getBeginAt, DateUtils.addDays(new Date(), 1))
            .ge(ComActActivityDO::getBeginAt, new Date()).notIn(ComActActivityDO::getStatus,5,6));
        if (!actActivityList.isEmpty()) {
            WxMaService maService = wxMaConfiguration.getMaService("wx118de8a734d269f0");
            try {
                String accessToken = util.getAppAccessToken();
                String accessToken = maService.getAccessToken();
                actActivityList.forEach(actActivity -> {
                    //查询报名活动人员列表
                    List<ComActActSignDO> actSignList = comActActSignDAO.selectList(new QueryWrapper<ComActActSignDO>().lambda()
                            .eq(ComActActSignDO::getActivityId,actActivity.getId()));
                    ComActDO comActDO=comActDAO.selectById(actActivity.getCommunityId());
                    R<SysTemplateConfigVO> r=userService.selectTemplate(comActDO.getAreaCode(),9);
                    // 查询报名活动人员列表
                    List<ComActActSignDO> actSignList = comActActSignDAO.selectList(new QueryWrapper<ComActActSignDO>()
                        .lambda().eq(ComActActSignDO::getActivityId, actActivity.getId()));
                    actSignList.forEach(actSign -> {
                        //查询用户openId
                        Map<String,String> map = comActActSignDAO.getUserOpenId(actSign.getUserId());
                        if(map != null){
                        // 查询用户openId
                        Map<String, String> map = comActActSignDAO.getUserOpenId(actSign.getUserId());
                        if (map != null) {

                            String openid = map.get("openid");
                            //推送消息
                            WxUtil.sendSubscribeHDJJKS(openid,accessToken,actActivity.getActivityName()
                                    , com.panzhihua.common.utlis.DateUtils.format(actActivity.getBeginAt()
                                            ,com.panzhihua.common.utlis.DateUtils.ymdhms_format),actActivity.getActivityAddr()
                                    ,actSignList.size()+"");
                            // 推送消息
                            WxUtil.sendSubscribeHDJJKS(openid, accessToken, actActivity.getActivityName(),
                                com.panzhihua.common.utlis.DateUtils.format(actActivity.getBeginAt(),
                                    com.panzhihua.common.utlis.DateUtils.ymdhms_format),
                                actActivity.getActivityAddr(), actSignList.size() + "",r.getData().getTemplateId());
                        }

                    });

                });
            }catch (Exception e){
            } catch (Exception e) {
                log.error("推送失败，错误原因：" + e.getMessage());
            }
        }
        return R.ok();
    }

    private String getPersent(int x, int y){
        if (y == 0) {
            return "";
        }
        if (x == 0) {
            return "0.00%";
        }
        double d1 = x * 1.0;
        double d2 = y * 1.0;
        DecimalFormat decimalFormat = new DecimalFormat("##.00%");
        return decimalFormat.format(d1 / d2);
    }

    /**
     * 用户签到
     *
     * @param comActActRegistVO 签到参数
     * @return 签到结果
     */
    @Override
    public R activitySignIn(ComActActRegistVO comActActRegistVO) {
        Long activityId = comActActRegistVO.getActivityId();
        Long userId = comActActRegistVO.getUserId();
        if (isNull(activityId)) {
            return R.fail("签到所属活动id不能为空！");
        }
        ComActActivityDO comActActivityDO = comActActivityDAO.selectById(activityId);
        if (isNull(comActActivityDO)) {
            return R.fail("活动不存在！");
        }

        ComActActSignDO comActActSignDO = comActActSignDAO
            .selectOne(new QueryWrapper<ComActActSignDO>().lambda().eq(ComActActSignDO::getActivityId, activityId)
                .eq(ComActActSignDO::getUserId, userId).eq(ComActActSignDO::getStatus, 1));
        if (isNull(comActActSignDO)) {
            return R.fail("活动未报名");
        }

        Date beginAt = comActActivityDO.getBeginAt();
        Date endAt = comActActivityDO.getEndAt();
        Date nowDate = new Date();
        if (nowDate.before(beginAt) || nowDate.after(endAt)) {
            return R.fail("不在活动时间范围内");
        }
        Integer rewardWay = null;
        Integer rewardIntegral = 0;
        Integer integralType = null;
        String remark = "";
        switch (comActActSignDO.getSignIdentity()) {
            case 1:
                rewardWay = comActActivityDO.getParticipantRewardWay();
                rewardIntegral = comActActivityDO.getParticipantRewardIntegral();
                integralType = 4;
                remark = "社区活动-居民身份成功参与";
                break;
            case 2:
                rewardWay = comActActivityDO.getPbRewardWay();
                rewardIntegral = comActActivityDO.getPbRewardIntegral();
                integralType = 5;
                remark = "社区活动-党员身份成功参与";
                break;
            case 3:
                rewardWay = comActActivityDO.getVolunteerRewardWay();
                rewardIntegral = comActActivityDO.getVolunteerRewardIntegral();
                integralType = 6;
                remark = "社区活动-志愿者身份成功参与";
                break;
            default:
                break;
        }
        if (comActActivityDO.getType().intValue() == 5) {
            integralType = 9;
            remark = "单位党员活动-成功参与";
        }
        boolean isHave = rewardIntegral > 0;
        ComActActRegistDO comActActRegistDO = new ComActActRegistDO();
        if (comActActRegistVO.getSignType() != null && comActActRegistVO.getSignType() == 2) {
            ComActActRegistDO comActActActRegistDO = comActActRegistDAO.selectOne(new QueryWrapper<ComActActRegistDO>()
                .lambda().eq(ComActActRegistDO::getActivityId, activityId).eq(ComActActRegistDO::getUserId, userId)
                .eq(ComActActRegistDO::getCodeId, comActActRegistVO.getCodeId()));
            if (comActActActRegistDO == null) {
                return R.fail("未签到无法签退");
            }
            if (comActActActRegistDO.getEndTime() != null) {
                return R.fail("无法重复签退");
            }
            int hours = com.panzhihua.common.utlis.DateUtils.getHour(comActActActRegistDO.getStartTime(), nowDate);
            int retrieveIntegral = rewardWay == 1 ? rewardIntegral : rewardIntegral * hours;
            comActActRegistDO.setId(comActActActRegistDO.getId());
            comActActRegistDO.setEndTime(nowDate);
            comActActRegistDO.setAward(retrieveIntegral);
            int result = comActActRegistDAO.updateById(comActActRegistDO);
            if (result > 0) {
                if (isHave) {
                    AddComActIntegralUserDTO addComActIntegralUserDTO = new AddComActIntegralUserDTO();
                    addComActIntegralUserDTO.setUserId(userId);
                    addComActIntegralUserDTO.setIntegralType(integralType);
                    addComActIntegralUserDTO.setIntegral(retrieveIntegral);
                    addComActIntegralUserDTO.setSignIdentity(comActActSignDO.getSignIdentity());
                    addComActIntegralUserDTO.setCommunityId(comActActivityDO.getCommunityId());
                    addComActIntegralUserDTO.setServiceId(activityId);
                    addComActIntegralUserDTO.setRemark(remark);
                    comActIntegralUserTradeService.addIntegralTradeAdmin(addComActIntegralUserDTO);
                    return R.ok(retrieveIntegral);
                } else {
                    return R.ok();
                }
            }
        } else {
            int signDayCount = comActActRegistDAO.selectCount(new QueryWrapper<ComActActRegistDO>().lambda()
                .eq(ComActActRegistDO::getActivityId, activityId).eq(ComActActRegistDO::getUserId, userId)
                .eq(ComActActRegistDO::getCodeId, comActActRegistVO.getCodeId()));
            int signAllCount = comActActRegistDAO.selectCount(new QueryWrapper<ComActActRegistDO>().lambda()
                .eq(ComActActRegistDO::getActivityId, activityId).eq(ComActActRegistDO::getUserId, userId));
            if (signDayCount > 0) {
                return R.fail("请扫描新的签到码");
            }
            if (isHave) {
                int limit = comActActivityDO.getLimit().intValue();
                if (limit != -1 && signAllCount >= limit) {
                    return R.fail("签到次数上限");
                }
            }
            comActActRegistDO.setActivityId(activityId);
            comActActRegistDO.setStartTime(new Date());
            comActActRegistDO.setType(comActActivityDO.getType());
            comActActRegistDO.setUserId(userId);
            comActActRegistDO.setSignIdentity(comActActSignDO.getSignIdentity());
            comActActRegistDO.setCreateAt(nowDate);
            comActActRegistDO.setCodeId(comActActRegistVO.getCodeId());
            comActActRegistDO.setAward(0);
            comActActRegistDO.setPosition(comActActRegistVO.getPosition());
            comActActRegistDO.setCheckUnitId(comActActSignDO.getCheckUnitId());
            comActActRegistDO.setTimes(signAllCount + 1);
            int result = comActActRegistDAO.insert(comActActRegistDO);
            if (result > 0) {
                return R.ok();
            }
        }
        return R.fail("网络错误，请重试");
    }

    /**
     *用户签到记录列表
     *
     * @param userId 用id
     * @return 用户签到列表
     */
    @Override
    public R listSignInActivity(Long userId) {
        List<ComActActRegistDO> comActActRegistDOS = comActActRegistDAO.selectList(new QueryWrapper<ComActActRegistDO>()
                .lambda().eq(ComActActRegistDO::getUserId, userId));
        ArrayList<ComActActRegistVO> comActActRegistVOS = new ArrayList<>();
        comActActRegistDOS.forEach(comActActRegistDO -> {
            ComActActRegistVO comActActRegistVO = new ComActActRegistVO();
            BeanUtils.copyProperties(comActActRegistDO, comActActRegistVO);
            comActActRegistVOS.add(comActActRegistVO);
        });
        return R.ok(comActActRegistVOS);
    }

    /**
     * 获取活动报名签到记录
     * @param id 活动主键id
     * @return
     */
    @Override
    public R listSignInRecord(Long id) {
        return R.ok(comActActSignDAO.listSignInRecord(id));
    }

    /**
     * 活动签到记录
     * @param id 活动主键
     * @param userId 用户id
     * @return
     */
    @Override
    public R listRegistRecord(Long id, Long userId) {
        return R.ok(comActActRegistDAO.listRegistRecord(id, userId));
    }

    /**
     * 获取活动类型（目前只有志愿者活动需要获取）
     * @param communityId
     * @param type
     * @return
     */
    @Override
    public R listActivityType(Long communityId, Integer type) {
        return R.ok(this.baseMapper.listActivityType(communityId, type));
    }

    /**
     * 添加活动类型
     * @param comActActivityTypeVO
     * @return
     */
    @Override
    public R addActivityType(ComActActivityTypeVO comActActivityTypeVO) {
        try {
            comActActivityTypeVO.setId(Snowflake.getId());
            this.baseMapper.addActivityType(comActActivityTypeVO);
        } catch (Exception e) {
            log.error("添加活动类型错误【{}】", e.getMessage());
            return R.fail("活动类型已存在");
        }
        return R.ok();
    }

    @Override
    public String getActBelongRegionCode(Long communityId) {
        return baseMapper.getActBelongRegionCode(communityId);
    }

    @Override
    public R partyMemberCount(Long communityId, String year) {

        List<Long> communityIds = comActDAO.selectIds(communityId);
        if (CollUtil.isEmpty(communityIds)){
            communityIds = new ArrayList<>();
            communityIds.add(communityId);
        }
        PartyActivityStatics partyActivityStatics=this.comActActivityDAO.selectActivityStatics(communityIds);
        List<PartyActivityTypeChart> partyActivityTypeChart=this.comActActivityDAO.selectActivityChart(communityIds);
        if(partyActivityStatics.getActivityCount()!=null&&partyActivityStatics.getActivityCount()>0){
            if(!CollectionUtils.isEmpty(partyActivityTypeChart)){
                partyActivityTypeChart.forEach(partyActivityTypeChart1 -> {
                    partyActivityTypeChart1.setPercent(partyActivityTypeChart1.getCount()/partyActivityStatics.getActivityCount());
                });
            }
        }
        partyActivityStatics.setPartyActivityTypeChartList(partyActivityTypeChart);
        partyActivityStatics.setPartyActivityLines(getPoints(communityIds,year));
        return R.ok(partyActivityStatics);
    }

    @Override
    public R partyMemberDetail(CommonPage commonPage) {
        return R.ok(comActActivityDAO.partyMemberDetail(new Page<>(commonPage.getPage(),commonPage.getSize()),commonPage));
    }

    @Override
    public R exportPartyMemberDetail(CommonPage commonPage) {
        return R.ok(comActActivityDAO.exportPartyMemberDetail(commonPage));
    }

    public List<PartyActivityLine> getPoints(List<Long> communityIds,String year){
        List<PartyActivityLine> partyActivityLines=new ArrayList<>();
        for(int i=1;i<=12;i++){
            String x="";
            if(i<10){
                x="0"+i;
            }
            else {
                x=i+"";
            }
            PartyActivityLine partyActivityLine=new PartyActivityLine();
            partyActivityLine.setX(i+"月");
            Integer y=this.comActActivityDAO.selectActivityLine(communityIds,year,x);
            partyActivityLine.setY(y);
            partyActivityLines.add(partyActivityLine);
        }
        return partyActivityLines;
    }
}