liurunyu
2023-12-08 9ef652b092427bcfb306fa5d90fab1eeebe974bc
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
package com.dy.pipIrrSell.activeCard;
 
import com.dy.common.aop.SsoAop;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.common.webUtil.QueryResultVo;
import com.dy.common.webUtil.ResultCodeMsg;
import com.dy.pipIrrGlobal.pojoSe.*;
import com.dy.pipIrrSell.activeCardHistory.ActiveCardHistorySv;
import com.dy.pipIrrSell.clientCard.ClientCardSv;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;
 
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
 
/**
 * @author ZhuBaoMin
 * @date 2023/12/5 20:06
 * @LastEditTime 2023/12/5 20:06
 * @Description
 */
 
@Slf4j
@Tag(name = "开卡管理", description = "开卡操作")
@RestController
@RequestMapping(path="activecard")
@RequiredArgsConstructor
public class ActiveCardCtrl {
    private final ActiveCardSv activeCardSv;
    private final ClientCardSv clientCardSv;
    private final ActiveCardHistorySv activeCardHistorySv;
 
    @Operation(summary = "获得一页开卡记录", description = "返回一页开卡数据")
    @ApiResponses(value = {
            @ApiResponse(
                    responseCode = ResultCodeMsg.RsCode.SUCCESS_CODE,
                    description = "返回一页开卡数据(BaseResponse.content:QueryResultVo[{}])",
                    content = {@Content(mediaType = MediaType.APPLICATION_JSON_VALUE,
                            schema = @Schema(implementation = VoActiveCard.class))}
            )
    })
    @GetMapping(path = "/getActiveCards", consumes = MediaType.APPLICATION_JSON_VALUE)
    @SsoAop("-1")
    public BaseResponse<QueryResultVo<List<VoActiveCard>>> getActiveCards(@RequestBody @Parameter(description = "查询form表单json数据", required = true) QueryVo vo){
        try {
            QueryResultVo<List<VoActiveCard>> res = activeCardSv.getActiveCards(vo);
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("获取开卡记录异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
        }
    }
 
    @Operation(summary = "开卡", description = "新开农户卡")
    @ApiResponses(value = {
            @ApiResponse(
                    responseCode = ResultCodeMsg.RsCode.SUCCESS_CODE,
                    description = "操作结果:true:成功,false:失败(BaseResponse.content)",
                    content = {@Content(mediaType = MediaType.APPLICATION_JSON_VALUE,
                            schema = @Schema(implementation = Boolean.class))}
            )
    })
    @PostMapping(path = "add_active", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop("-1")//@SsoAop(power = "-1")
    public BaseResponse<Boolean> add_active(@RequestBody @Parameter(description = "form表单json数据", required = true) @Valid PO_ActiveCard po, @Parameter(hidden = true) BindingResult bindingResult){
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }
 
        /**
         * cardId           水卡编号(插入记录后生成)
         * cardAddr         水卡地址
         * clientId         农户编号
         * cardCost         卡片费用
         * reissueAmount    补卡金额,补卡时使用
         * paymentId        支付方式编号
         * operator         操作人编号
         * activeTime       开卡时间
         */
        Long cardId = 0L;
        String cardAddr = po.getCardAddr();
        Long clientId = po.getClientId();
        Integer cardCost = po.getCardCost();
        Long paymentId = po.getPaymentId();
        Long operator = po.getOperator();
        Date activeTime = new Date();
        //LocalDateTime activeTime = LocalDateTime.parse(dtf.format(LocalDateTime.now()), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
 
        /**
         * 添加农户卡记录
         */
        SeClientCard clientCard = new SeClientCard();
        clientCard.setCardaddr(cardAddr);
        clientCard.setClientid(clientId);
        clientCard.setMoney(0.0);
        clientCard.setState((byte) 1);
        clientCard.setCreatedt(activeTime);
        clientCard.setLastoper((byte) 1);
 
        cardId = Optional.ofNullable(clientCardSv.add(clientCard)).orElse(0L) ;
        if(cardId == 0) {
            return BaseResponseUtils.buildFail("开卡失败-农户卡写入异常");
        }
 
        /**
         * 添加开卡记录
         */
        SeActiveCard activeCard = new SeActiveCard();
        activeCard.setCardid(cardId);
        activeCard.setCardcost(cardCost);
        activeCard.setPaymentid(paymentId);
        activeCard.setOperatetype((byte)1);
        activeCard.setOperator(operator);
        activeCard.setOperatedt(activeTime);
        Long rec = Optional.ofNullable(activeCardSv.add(activeCard)).orElse(0L);
        if(rec == 0) {
            return BaseResponseUtils.buildFail("开卡失败-开卡记录写入异常");
        }
 
        /**
         * 添加开卡历史记录
         */
        SeActiveCardHistory activeCardHistory = new SeActiveCardHistory();
        activeCardHistory.setCardid(cardId);
        activeCardHistory.setCardcost(cardCost);
        activeCardHistory.setPaymentid(paymentId);
        activeCardHistory.setOperatetype((byte)1);
        activeCardHistory.setOperator(operator);
        activeCardHistory.setOperatedt(activeTime);
        Long rec_history = Optional.ofNullable(activeCardHistorySv.add(activeCardHistory)).orElse(0L);
        if(rec_history == 0) {
            return BaseResponseUtils.buildFail("开卡失败-开卡历史记录写入异常");
        }
 
        return BaseResponseUtils.buildSuccess(true) ;
    }
 
    @Operation(summary = "补卡", description = "补卡")
    @ApiResponses(value = {
            @ApiResponse(
                    responseCode = ResultCodeMsg.RsCode.SUCCESS_CODE,
                    description = "操作结果:true:成功,false:失败(BaseResponse.content)",
                    content = {@Content(mediaType = MediaType.APPLICATION_JSON_VALUE,
                            schema = @Schema(implementation = Boolean.class))}
            )
    })
    @PostMapping(path = "add_reissue", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop("-1")//@SsoAop(power = "-1")
    public BaseResponse<Boolean> add_reissue(@RequestBody @Parameter(description = "form表单json数据", required = true) @Valid PO_ActiveCard po, @Parameter(hidden = true) BindingResult bindingResult){
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }
 
        /**
         * cardId           水卡编号(非传入参数,由cardAddr反查)
         * cardAddr         水卡地址
         * cardCost         卡片费用
         * reissueAmount    补卡金额,补卡时使用
         * paymentId        支付方式编号
         * operator         操作人编号
         * activeTime       补卡时间
         */
        Long cardId = 0L;
        String cardAddr = po.getCardAddr();
        Integer cardCost = po.getCardCost();
        Double reissueAmount = po.getReissueAmount();
        Long paymentId = po.getPaymentId();
        Long operator = po.getOperator();
        Date activeTime = new Date();
 
        /**
         * 依据水卡地址获取水卡编号(主键)
         */
        cardId = Optional.ofNullable(clientCardSv.getCardIdByAddr(cardAddr)).orElse(0L);
        if(cardId == 0) {
            return BaseResponseUtils.buildFail("卡号错误,该卡不存在");
        }
 
        /**
         * 修改农户卡信息:
         *      补卡时间
         *      最后操作类型-2
         */
        SeClientCard seClientCard = new SeClientCard();
        seClientCard.setId(cardId);
        seClientCard.setReplacedt(activeTime);
        seClientCard.setLastoper((byte)2);
        Integer rec_updateClientCard = Optional.ofNullable(clientCardSv.UpdateClientCard(seClientCard)).orElse(0);
        if(rec_updateClientCard == 0) {
            return BaseResponseUtils.buildFail("补卡失败-农户卡修改异常");
        }
 
        /**
         * 删除开卡/补卡表该卡的补卡记录
         */
        Integer rec_deleteActiveCard = Optional.ofNullable(activeCardSv.deleteByIdAndOperateType(cardId, (byte)2)).orElse(0);
        /**
         * 添加补卡记录
         */
        SeActiveCard activeCard = new SeActiveCard();
        activeCard.setCardid(cardId);
        activeCard.setCardcost(cardCost);
        activeCard.setPaymentid(paymentId);
        activeCard.setReissueamount(reissueAmount);
        activeCard.setOperatetype((byte)2);
        activeCard.setOperator(operator);
        activeCard.setOperatedt(activeTime);
        Long rec = Optional.ofNullable(activeCardSv.add(activeCard)).orElse(0L);
        if(rec == 0) {
            return BaseResponseUtils.buildFail("补卡失败-补卡记录写入异常");
        }
 
        /**
         * 添加补卡历史记录
         */
        SeActiveCardHistory activeCardHistory = new SeActiveCardHistory();
        activeCardHistory.setCardid(cardId);
        activeCardHistory.setCardcost(cardCost);
        activeCardHistory.setPaymentid(paymentId);
        activeCard.setReissueamount(reissueAmount);
        activeCardHistory.setOperatetype((byte)2);
        activeCardHistory.setOperator(operator);
        activeCardHistory.setOperatedt(activeTime);
        Long rec_history = Optional.ofNullable(activeCardHistorySv.add(activeCardHistory)).orElse(0L);
        if(rec_history == 0) {
            return BaseResponseUtils.buildFail("补卡失败-补卡历史记录写入异常");
        }
 
        return BaseResponseUtils.buildSuccess(true) ;
    }
}