yujian
2019-03-12 4a05f1c9c508ab7f10c5eae22a5c716f5454ca02
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
package com.yeshi.fanli.service.impl.user;
 
import java.util.Date;
import java.util.List;
 
import javax.annotation.Resource;
 
import org.springframework.stereotype.Service;
 
import com.yeshi.fanli.dao.mybatis.user.ForbiddenUserIdentifyCodeMapper;
import com.yeshi.fanli.entity.bus.user.ForbiddenUserIdentifyCode;
import com.yeshi.fanli.entity.bus.user.ForbiddenUserIdentifyCode.ForbiddenUserIdentifyCodeTypeEnum;
import com.yeshi.fanli.exception.user.ForbiddenUserIdentifyCodeException;
import com.yeshi.fanli.service.inter.user.ForbiddenUserIdentifyCodeService;
import com.yeshi.fanli.util.StringUtil;
import com.yeshi.fanli.vo.user.ForbiddenUserIdentifyCodeVO;
 
@Service
public class ForbiddenUserIdentifyCodeServiceImpl implements ForbiddenUserIdentifyCodeService {
 
    @Resource
    private ForbiddenUserIdentifyCodeMapper forbiddenUserIdentifyCodeMapper;
 
    @Override
    public void addIdentifyCode(ForbiddenUserIdentifyCode identifyCode) throws ForbiddenUserIdentifyCodeException {
        if (identifyCode == null || identifyCode.getType() == null
                || StringUtil.isNullOrEmpty(identifyCode.getIdentifyCode()))
            throw new ForbiddenUserIdentifyCodeException(1, "信息不完整");
 
        ForbiddenUserIdentifyCode old = listByTypeAndIdentifyCode(identifyCode.getType(),
                identifyCode.getIdentifyCode());
        if (old != null)
            throw new ForbiddenUserIdentifyCodeException(2, "信息已存在");
 
        identifyCode.setCreateTime(new Date());
        identifyCode.setEffective(true);
        forbiddenUserIdentifyCodeMapper.insertSelective(identifyCode);
    }
 
    @Override
    public ForbiddenUserIdentifyCode listByTypeAndIdentifyCode(ForbiddenUserIdentifyCodeTypeEnum type,
            String identifyCode) {
        List<ForbiddenUserIdentifyCode> list = forbiddenUserIdentifyCodeMapper.listByTypeAndIdentifyCode(type,
                identifyCode);
        if (list != null && list.size() > 0)
            return list.get(0);
        else
            return null;
    }
 
    @Override
    public void update(ForbiddenUserIdentifyCode identifyCode) {
        if (identifyCode == null)
            return;
        identifyCode.setUpdateTime(new Date());
        forbiddenUserIdentifyCodeMapper.updateByPrimaryKeySelective(identifyCode);
    }
 
    @Override
    public void delete(ForbiddenUserIdentifyCode identifyCode) {
        if (identifyCode == null || identifyCode.getId() == null)
            return;
        forbiddenUserIdentifyCodeMapper.deleteByPrimaryKey(identifyCode.getId());
    }
 
    
    @Override
    public List<ForbiddenUserIdentifyCodeVO> listQuery(long start, int count, String key, Integer type) {
        
        List<ForbiddenUserIdentifyCodeVO> list = forbiddenUserIdentifyCodeMapper.listQuery(start, count, key, type);
        if (list == null || list.size() == 0) {
            return list;
        }
        
        for (ForbiddenUserIdentifyCodeVO forbiddenUserIdentifyCodeVO: list) {
            
            String f_alipayAccount = forbiddenUserIdentifyCodeVO.getF_alipayAccount();
            if (f_alipayAccount != null && f_alipayAccount.trim().length() > 0) {
                forbiddenUserIdentifyCodeVO.setAlipayAccountState(1);
            }
            
            String f_phone = forbiddenUserIdentifyCodeVO.getF_phone();
            if (f_phone != null && f_phone.trim().length() > 0) {
                forbiddenUserIdentifyCodeVO.setPhoneState(1);
            }
            
            String f_taobaoUid = forbiddenUserIdentifyCodeVO.getF_taobaoUid();
            if (f_taobaoUid != null && f_taobaoUid.trim().length() > 0) {
                forbiddenUserIdentifyCodeVO.setTaobaoUidState(1);
            }
            
            String f_wxUnionId = forbiddenUserIdentifyCodeVO.getF_wxUnionId();
            if (f_wxUnionId != null && f_wxUnionId.trim().length() > 0) {
                forbiddenUserIdentifyCodeVO.setWxUnionIdState(1);
            }
        }
        
        return list;
        
    }
    
    @Override
    public long countQuery(String key,  Integer type) {
        return forbiddenUserIdentifyCodeMapper.countQuery(key, type);
    }
 
    
    @Override
    public void saveForbiddenInfo(String identifyCode, Integer type, boolean state) throws ForbiddenUserIdentifyCodeException{
        
        ForbiddenUserIdentifyCodeTypeEnum typeEnum = null;
        
        switch(type) {
            case 1: // 微信账号
                typeEnum = ForbiddenUserIdentifyCodeTypeEnum.wxUnionId;
                break;
            case 2: // 淘宝账号
                typeEnum = ForbiddenUserIdentifyCodeTypeEnum.taobaoUid;
                break;
            case 3: // 电话号码
                typeEnum = ForbiddenUserIdentifyCodeTypeEnum.phone;
                break;
            case 4: // 支付宝账号
                typeEnum = ForbiddenUserIdentifyCodeTypeEnum.alipayAccount;
                break;
            default:
                break;
        }
        
        if (typeEnum == null) {
            throw new ForbiddenUserIdentifyCodeException(1, "类型不匹配");
        }
        
        ForbiddenUserIdentifyCode codeObject = listByTypeAndIdentifyCode(typeEnum ,identifyCode);
        if (codeObject == null) {
            // 封禁账户
            if (state) {
                codeObject = new ForbiddenUserIdentifyCode();
                codeObject.setType(typeEnum);
                codeObject.setIdentifyCode(identifyCode);
                codeObject.setEffective(state);
                codeObject.setCreateTime(new Date());
                codeObject.setUpdateTime(new Date());
                
                forbiddenUserIdentifyCodeMapper.insertSelective(codeObject);
            } else {
                throw new ForbiddenUserIdentifyCodeException(1, "未找到可解封号码");
            }
        } else {
            codeObject.setEffective(state);
            codeObject.setUpdateTime(new Date());
            forbiddenUserIdentifyCodeMapper.updateByPrimaryKeySelective(codeObject);
        }
    }
    
}