mitao
2025-02-21 31573d6180d15ef65ed0df9c2732495f40b12663
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package com.panzhihua.timejob.jobhandler;
 
import java.util.Date;
import java.util.List;
 
import javax.annotation.Resource;
 
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
 
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.panzhihua.common.model.dtos.community.integral.admin.AddComActIntegralUserDTO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.integral.admin.ComActActivityPeopleVO;
import com.panzhihua.common.model.vos.partybuilding.PartyBuildingActivityVO;
import com.panzhihua.common.model.vos.user.SysUserNoticeVO;
import com.panzhihua.common.service.community.CommunityService;
import com.panzhihua.common.service.partybuilding.PartyBuildingService;
import com.panzhihua.common.service.user.UserService;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.annotation.XxlJob;
 
import lombok.extern.slf4j.Slf4j;
 
/**
 * @program: springcloud_k8s_panzhihuazhihuishequ
 * @description: 党建相关
 * @author: huang.hongfa weixin hhf9596 qq 959656820
 * @create: 2021-01-14 16:09
 **/
@Slf4j
@Component
public class PartyBuildingJobHandler {
 
    @Resource
    private PartyBuildingService partyBuildingService;
    @Resource
    private UserService userService;
    @Resource
    private CommunityService communityService;
 
    /**
     * 定时任务刷新党建动态发布状态
     * 
     * @return 刷新个数
     * @throws Exception
     *             出现的异常
     */
    @XxlJob("timedtaskpartybuildingstatusJobHandler")
    public ReturnT<String> timedtaskpartybuildingstatusJobHandler(String param) throws Exception {
        log.info("定时任务刷新党建动态发布状态");
        R r = partyBuildingService.timedTaskPartyBuildingStatus();
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }
 
    /**
     * 定时任务取消党建活动
     * 
     * @return 取消个数
     * @throws Exception
     *             出现的异常
     */
    @XxlJob("timedTaskPartyBuildingActivityJobHandler")
    public ReturnT<String> timedTaskPartyBuildingActivityJobHandler(String param) throws Exception {
        log.info("定时任务取消党建活动");
        R r = partyBuildingService.timedTaskPartyBuildingActivity();
        if (R.isOk(r)) {
            Object data = r.getData();
            if (!ObjectUtils.isEmpty(data)) {
                List<PartyBuildingActivityVO> partyBuildingActivityVOS =
                    JSONArray.parseArray(JSONArray.toJSONString(data), PartyBuildingActivityVO.class);
                if (!ObjectUtils.isEmpty(partyBuildingActivityVOS)) {
                    partyBuildingActivityVOS.forEach(partyBuildingActivityVO -> {
                        List<Long> userIds = partyBuildingActivityVO.getUserIds();
                        if (!ObjectUtils.isEmpty(userIds)) {
                            userIds.forEach(aLong -> {
                                SysUserNoticeVO sysUserNoticeVO = new SysUserNoticeVO();
                                sysUserNoticeVO.setUserId(aLong);
                                sysUserNoticeVO.setType(1);
                                sysUserNoticeVO.setBusinessType(2);
                                sysUserNoticeVO.setBusinessTitle(partyBuildingActivityVO.getName());
                                sysUserNoticeVO.setBusinessTime(new Date());
                                sysUserNoticeVO.setBusinessId(partyBuildingActivityVO.getId());
                                sysUserNoticeVO.setStatus(0);
                                sysUserNoticeVO.setTitle("活动因故取消");
                                sysUserNoticeVO.setBusinessContent("报名人数不足活动自动取消");
                                sysUserNoticeVO.setBusinessStatus(1);
                                R r2 = userService.addNotice(sysUserNoticeVO);
                                if (R.isOk(r2)) {
                                    log.info("新增党建活动取消通知成功【{}】", JSONObject.toJSONString(sysUserNoticeVO));
                                }
                            });
                        }
                    });
                }
            }
        }
 
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }
 
    /**
     * 定时任务刷新党建活动的各个状态 除取消外
     * 
     * @return 刷新个数
     * @throws Exception
     *             出现的异常
     */
    @XxlJob("timedTaskPartyBuildingActivityAllJobHandler")
    public ReturnT<String> timedTaskPartyBuildingActivityAllJobHandler(String param) throws Exception {
        log.info("定时任务刷新党建活动的各个状态 除取消外");
        R r = partyBuildingService.timedTaskPartyBuildingActivityAll();
        if (R.isOk(r)) {
            // 获取待结束的活动列表
            List<Long> activityList = JSONArray.parseArray(JSONArray.toJSONString(r.getData()), Long.class);
            if (!activityList.isEmpty()) {
                log.info("党员活动结束计算积分");
                activityList.forEach(activityId -> {
                    R r1 = partyBuildingService.getTaskPbActivityPeopleList(activityId);
                    if (R.isOk(r1)) {
                        List<ComActActivityPeopleVO> peopleList =
                            JSONArray.parseArray(JSONArray.toJSONString(r1.getData()), ComActActivityPeopleVO.class);
                        if (!peopleList.isEmpty()) {
                            peopleList.forEach(people -> {
                                communityService.addIntegralTradeAdmin(new AddComActIntegralUserDTO(
                                    people.getActivityId(), AddComActIntegralUserDTO.integralType.cydyhd,
                                    people.getCommunityId(), people.getUserId()));
                            });
                        }
                    }
                });
            }
        }
        log.info("执行结果【{}】", r.toString());
        return ReturnT.SUCCESS;
    }
}