Skip to content

向汉 / uc-consumer

Go to a project
Toggle navigation
Toggle navigation pinning
Commit 7c0a2e66 7c0a2e66498ce13ba50288a5afcf420a5d25606a by xianghan
Options

1.优化日志信息 

2.清理无用的文件
1 parent 6856ef82
Inline Side-by-side
Showing 32 changed files with 516 additions and 1269 deletions
1 package com.topdraw.business.process.domian;
2
3 import lombok.AllArgsConstructor;
4 import lombok.Data;
5 import lombok.NoArgsConstructor;
6
7 import javax.persistence.Transient;
8 import java.sql.Timestamp;
9
10 /**
11 * 权益-非持久化数据
12 */
13 @Data
14 @AllArgsConstructor
15 @NoArgsConstructor
16 public class TempCoupon extends TempRights {
17
18 @Transient
19 protected String code;
20
21 @Transient
22 protected Integer useStatus;
23
24 @Transient
25 protected Timestamp useTime;
26
27 /**领取时间*/
28 @Transient
29 protected Timestamp receiveTime;
30
31 @Transient
32 protected String userNickname;
33
34 }
1 package com.topdraw.business.process.domian;
2
3 import lombok.AllArgsConstructor;
4 import lombok.Data;
5 import lombok.NoArgsConstructor;
6
7 import javax.persistence.Transient;
8
9 /**
10 * 权益-非持久化数据
11 */
12 @Data
13 @AllArgsConstructor
14 @NoArgsConstructor
15 public class TempExp extends TempRights {
16
17 // 获得成长值
18 @Transient
19 protected Long rewardExp;
20
21
22 }
1 package com.topdraw.business.process.domian;
2
3 import lombok.AllArgsConstructor;
4 import lombok.Data;
5 import lombok.NoArgsConstructor;
6
7 import javax.persistence.Transient;
8
9 @Data
10 @AllArgsConstructor
11 @NoArgsConstructor
12 public class TempIptvUser {
13
14 // 账户
15 @Transient
16 private String platformAccount;
17
18 // 分数
19 @Transient
20 private Long points;
21
22
23
24 }
1 package com.topdraw.business.process.domian;
2
3 import lombok.AllArgsConstructor;
4 import lombok.Data;
5 import lombok.NoArgsConstructor;
6 import lombok.ToString;
7
8 import javax.persistence.Transient;
9 import javax.validation.constraints.NotNull;
10
11 /**
12 * 权益-非持久化数据
13 */
14 @Data
15 @AllArgsConstructor
16 @NoArgsConstructor
17 @ToString
18 public class TempPoints extends TempRights {
19
20 // 获得积分
21 @Transient
22 @NotNull(message = "【points】积分数值不得为空!!")
23 protected Long points;
24
25 // 积分类型 0:通用
26 @Transient
27 protected Integer pointsType;
28
29 @Transient
30 protected Long rewardPointsExpireTime;
31
32 }
1 package com.topdraw.business.process.domian;
2
3 import lombok.AllArgsConstructor;
4 import lombok.Data;
5 import lombok.NoArgsConstructor;
6
7 import javax.persistence.Transient;
8 import javax.validation.constraints.NotNull;
9 import java.time.LocalDateTime;
10
11 /**
12 * 权益-非持久化数据
13 */
14 @Data
15 @AllArgsConstructor
16 @NoArgsConstructor
17 public class TempRights {
18
19 /** 主键 */
20 @Transient
21 protected Long id;
22
23 /** 编号 */
24 @Transient
25 protected String code;
26
27 /** 权益名称 */
28 @Transient
29 protected String name;
30
31 /** 会员ID */
32 @Transient
33 protected Long memberId;
34
35 /** 会员编号 */
36 @Transient
37 protected String memberCode;
38
39 /** 账号id */
40 @Transient
41 protected Long userId;
42
43 /** 发放策略 */
44 @Transient
45 protected Integer rightsSendStrategy;
46
47 /** 账号id */
48 @Transient
49 private Long accountId;
50
51 /** 过期时间 */
52 @Transient
53 protected LocalDateTime expireTime;
54
55
56 /** 设备类型 1：大屏；2：小屏（微信）3.小屏（xx） */
57 @Transient
58 @NotNull(message = "设备类型不得为空")
59 protected Integer deviceType;
60
61 /** 应用code(表示当前用户对应应用的标识) */
62 @Transient
63 protected String appCode;
64
65 /** 订单id */
66 @Transient
67 protected Long orderId;
68
69 /** 节目id（针对观影操作） */
70 @Transient
71 protected Long mediaId;
72
73 /** 活动id（针对参与活动） */
74 @Transient
75 protected Long activityId;
76
77 /** 商品id */
78 @Transient
79 protected Long itemId;
80
81 /** 积分变化描述，用于管理侧显示 */
82 @Transient
83 protected String description;
84
85 /** 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；98：系统操作；99：其他 */
86 @Transient
87 protected Integer evtType;
88
89 /** 数量 */
90 @Transient
91 protected Integer rightsAmount;
92
93 }
1 package com.topdraw.business.process.domian.weixin;
2
3
4 import com.alibaba.fastjson.annotation.JSONField;
5 import com.topdraw.annotation.Query;
6 import lombok.Data;
7
8 import java.sql.Timestamp;
9
10 @Data
11 public class UserCollectionMq {
12
13 // 应用ID
14 @JSONField(name = "app_id")
15 private Long appId;
16
17 @JSONField(name = "userId")
18 private Long userId;
19
20 // 收藏夹类型：1-收藏 2-播放记录 3-播放列表 4-评分 5-点赞/关注/订阅
21 private Integer type;
22
23 // 收藏夹名称
24 private String name;
25
26 // 数量
27 private Integer count;
28
29 private String images;
30
31 // 收藏夹ID
32 @JSONField(name = "user_collection_id")
33 @Query
34 private Long userCollectionId;
35
36 // 自定义收藏内容的类型CODE，默认：DEFAULT
37 @JSONField(name = "detail_folder_code")
38 @Query
39 private String detailFolderCode;
40
41 // 收藏内容的类型：MEDIA|EPISODE|CATEGORY|SUBJECT|ARTICLE|ARTIST|SCHOOL
42 @JSONField(name = "detail_type")
43 @Query
44 private String detailType;
45
46 // 收藏内容的ID
47 @JSONField(name = "detail_id")
48 @Query
49 private Long detailId;
50
51 // 收藏内容的CODE
52 @JSONField(name = "detail_code")
53 @Query
54 private String detailCode;
55
56 // 收藏内容的剧集ID
57 @JSONField(name = "detail_episode_id")
58 @Query
59 private Long detailEpisodeId;
60
61 // 收藏内容的剧集CODE
62 @JSONField(name = "detail_episode_code")
63 @Query
64 private String detailEpisodeCode;
65
66 // 收藏内容的名称
67 @JSONField(name = "detail_name")
68 @Query
69 private String detailName;
70
71 // 收藏内容的标记
72 @JSONField(name = "detail_mark")
73 @Query
74 private Integer detailMark;
75
76 // 收藏内容的图片
77 @JSONField(name = "detail_img")
78 private String detailImg;
79
80 // 收藏内容的剧集序号
81 @JSONField(name = "detail_index")
82 @Query
83 private Integer detailIndex;
84
85 // 收藏内容的剧集总数
86 @JSONField(name = "detail_total_index")
87 @Query
88 private Integer detailTotalIndex;
89
90 // 收藏内容的播放时间
91 @JSONField(name = "detail_play_time")
92 @Query
93 private Integer detailPlayTime;
94
95 // 收藏内容的总时间
96 @JSONField(name = "detail_total_time")
97 @Query
98 private Integer detailTotalTime;
99
100 // 收藏内容在同一folder中的顺序
101 @JSONField(name = "detail_sequence")
102 @Query
103 private Integer detailSequence;
104
105 // 收藏内容的评分
106 @JSONField(name = "detail_score")
107 @Query
108 private Float detailScore;
109
110 // 收藏内容（根据文件夹和类型的不同）的点赞/关注/订阅
111 @JSONField(name = "detail_like")
112 @Query
113 private Integer detailLike;
114
115 // 收藏内容的扩展数据
116 @JSONField(name = "detail_ext_data")
117 @Query
118 private String detailExtData;
119
120 // 创建时间
121 @JSONField(name = "create_time")
122 @Query
123 private Timestamp createTime;
124
125 // 更新时间
126 @JSONField(name = "update_time")
127 private Timestamp updateTime;
128 }
1 package com.topdraw.business.process.service; 1 package com.topdraw.business.process.service;
2 2
3 import com.topdraw.business.process.domian.TempExp;
4
5 import java.util.List;
6 3
7 /** 4 /**
8 * @description 权益操作接口 5 * @description 权益操作接口
......
1 package com.topdraw.business.process.service.domian;
2
3 public enum RightType {
4 /**积分*/
5 POINTS,
6 /**成长值*/
7 EXP,
8 /**优惠券券*/
9 COUPON,
10 /**权益统称*/
11 RIGHTS
12
13 }
1 package com.topdraw.business.process.service.domian;
2
3 import com.topdraw.business.process.domian.TempRights;
4 import lombok.AllArgsConstructor;
5 import lombok.Data;
6 import lombok.NoArgsConstructor;
7
8 import javax.persistence.Transient;
9 import java.sql.Timestamp;
10
11 /**
12 * 权益-非持久化数据
13 */
14 @Data
15 @AllArgsConstructor
16 @NoArgsConstructor
17 public class TempCoupon extends TempRights {
18
19 @Transient
20 protected String code;
21
22 @Transient
23 protected Integer useStatus;
24
25 @Transient
26 protected Timestamp useTime;
27
28 /**领取时间*/
29 @Transient
30 protected Timestamp receiveTime;
31
32 @Transient
33 protected String userNickname;
34
35 }
1 package com.topdraw.business.process.service.domian;
2
3 import com.topdraw.business.process.domian.TempIptvUser;
4 import lombok.AllArgsConstructor;
5 import lombok.Data;
6 import lombok.NoArgsConstructor;
7
8 import javax.persistence.Transient;
9 import javax.validation.constraints.NotNull;
10
11 @Data
12 @AllArgsConstructor
13 @NoArgsConstructor
14 public class TempCustomPointBean extends TempIptvUser {
15
16 /** 设备类型 1：大屏；2：小屏（微信）3.小屏（xx） */
17 @Transient
18 @NotNull(message = "设备类型不得为空")
19 protected Integer deviceType;
20
21 /** 订单id */
22 @Transient
23 protected Long orderId;
24
25 /** 节目id（针对观影操作） */
26 @Transient
27 protected Long mediaId;
28
29 /** 活动id（针对参与活动） */
30 @Transient
31 protected Long activityId;
32
33 /** 商品id */
34 @Transient
35 protected Long itemId;
36
37 /** 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；98：系统操作；99：其他 */
38 @Transient
39 protected Integer evtType;
40
41 }
1 package com.topdraw.business.process.service.domian;
2
3 import com.topdraw.business.process.domian.TempRights;
4 import lombok.AllArgsConstructor;
5 import lombok.Data;
6 import lombok.NoArgsConstructor;
7
8 import javax.persistence.Transient;
9
10 /**
11 * 权益-非持久化数据
12 */
13 @Data
14 @AllArgsConstructor
15 @NoArgsConstructor
16 public class TempExp extends TempRights {
17
18 // 获得成长值
19 @Transient
20 protected Long rewardExp;
21
22
23 }
1 package com.topdraw.business.process.service.domian;
2
3 import lombok.AllArgsConstructor;
4 import lombok.Data;
5 import lombok.NoArgsConstructor;
6
7 import javax.persistence.Transient;
8 import java.sql.Timestamp;
9
10 @Data
11 @AllArgsConstructor
12 @NoArgsConstructor
13 public class TempIptvUser {
14
15 private String unionid;
16
17 // 账户
18 @Transient
19 private String platformAccount;
20
21 // 分数
22 @Transient
23 private Long points;
24
25
26 // ID
27 private Long id;
28
29 // 人ID
30 private Long personId;
31
32 // 运营商平台
33 private String platform;
34
35 // 手机号
36 private String cellphone;
37
38 // 用户名
39 private String username;
40
41 // 密码 MD5
42 private String password;
43
44 // 昵称 Base64
45 private String nickname;
46
47 // 头像
48 private String image;
49
50 // 登录天数（总天数）
51 private Integer loginDays;
52
53 // 连续登录天数
54 private Integer continueDays;
55
56 // 活跃时间
57 private Timestamp activeTime;
58
59 // 分组 分组ID用逗号分隔
60 private String groups;
61
62 // 标签 标签用逗号分隔
63 private String tags;
64
65 // 登录类型 1-运营商隐式登录 2-手机验证登录 3-微信登录 4-QQ登录 5-微博登录 6-苹果登录
66 private Integer loginType;
67
68 // 状态 0-下线 1-上线
69 private Integer status;
70
71 // 描述
72 private String description;
73
74 // 创建者
75 private String createBy;
76
77 // 创建时间
78 private Timestamp createTime;
79
80 // 更新者
81 private String updateBy;
82
83 // 更新时间
84 private Timestamp updateTime;
85
86 // 会员id
87 private Long memberId;
88
89 private String memberCode;
90
91
92 }
1 package com.topdraw.business.process.service.domian;
2
3 import com.topdraw.business.process.domian.TempRights;
4 import lombok.AllArgsConstructor;
5 import lombok.Data;
6 import lombok.NoArgsConstructor;
7 import lombok.ToString;
8
9 import javax.persistence.Transient;
10 import javax.validation.constraints.NotNull;
11
12 /**
13 * 权益-非持久化数据
14 */
15 @Data
16 @AllArgsConstructor
17 @NoArgsConstructor
18 @ToString
19 public class TempPoints extends TempRights {
20
21 // 获得积分
22 @Transient
23 @NotNull(message = "【points】积分数值不得为空!!")
24 protected Long points;
25
26 // 积分类型 0:通用
27 @Transient
28 protected Integer pointsType;
29
30 @Transient
31 protected Long rewardPointsExpireTime;
32
33 }
1 package com.topdraw.business.process.service.domian;
2
3 import lombok.AllArgsConstructor;
4 import lombok.Data;
5 import lombok.NoArgsConstructor;
6
7 import javax.persistence.Transient;
8 import javax.validation.constraints.NotNull;
9 import java.time.LocalDateTime;
10
11 /**
12 * 权益-非持久化数据
13 */
14 @Data
15 @AllArgsConstructor
16 @NoArgsConstructor
17 public class TempRights {
18
19 /** 主键 */
20 @Transient
21 protected Long id;
22
23 /** 编号 */
24 @Transient
25 protected String code;
26
27 /** 权益名称 */
28 @Transient
29 protected String name;
30
31 /** 会员ID */
32 @Transient
33 protected Long memberId;
34
35 /** 会员编号 */
36 @Transient
37 protected String memberCode;
38
39 /** 账号id */
40 @Transient
41 protected Long userId;
42
43 /** 发放策略 */
44 @Transient
45 protected Integer rightsSendStrategy;
46
47 /** 账号id */
48 @Transient
49 protected Long accountId;
50
51 /** 过期时间 */
52 @Transient
53 protected LocalDateTime expireTime;
54
55
56 /** 设备类型 1：大屏；2：小屏（微信）3.小屏（xx） */
57 @Transient
58 @NotNull(message = "设备类型不得为空")
59 protected Integer deviceType;
60
61 /** 应用code(表示当前用户对应应用的标识) */
62 @Transient
63 protected String appCode;
64
65 /** 订单id */
66 @Transient
67 protected Long orderId;
68
69 /** 节目id（针对观影操作） */
70 @Transient
71 protected Long mediaId;
72
73 /** 活动id（针对参与活动） */
74 @Transient
75 protected Long activityId;
76
77 /** 商品id */
78 @Transient
79 protected Long itemId;
80
81 /** 积分变化描述，用于管理侧显示 */
82 @Transient
83 protected String description;
84
85 /** 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；98：系统操作；99：其他 */
86 @Transient
87 protected Integer evtType;
88
89 /** 数量 */
90 @Transient
91 protected Integer rightsAmount;
92
93 }
1 package com.topdraw.business.process.service.domian;
2
3 public interface UnbindGroup {
4 }
1 package com.topdraw.business.process.service.domian.result;
2
3
4 import lombok.AllArgsConstructor;
5 import lombok.Data;
6 import lombok.NoArgsConstructor;
7
8 @Data
9 @AllArgsConstructor
10 @NoArgsConstructor
11 public class CustomPointsResult {
12 private boolean result;
13 private Long point;
14 }
1 package com.topdraw.business.process.service.domian.result;
2
3 public interface TaskTemplateType {
4
5 int TYPE_1 = 1;
6 int TYPE_2 = 2;
7 int TYPE_3 = 3;
8 int TYPE_4 = 4;
9
10 }
1 package com.topdraw.business.process.service.domian.weixin;
2
3
4 import lombok.Data;
5
6 @Data
7 public class BindBean extends WeiXinUserBean {
8
9 private Long platformUserId;
10
11 private String platformAccount;
12 }
1 package com.topdraw.business.process.service.domian.weixin;
2
3 import com.fasterxml.jackson.annotation.JsonFormat;
4 import lombok.Data;
5
6 import java.time.LocalDateTime;
7
8 /**
9 * 微信账户信息
10 * @author XiangHan
11 * @date 2021-01-18
12 */
13 @Data
14 public class BuyVipBean extends WeiXinUserBean {
15
16 private Integer vip;
17
18 @JsonFormat(shape = JsonFormat.Shape.STRING,pattern = "yyyy-MM-dd HH:mm:ss")
19 private LocalDateTime vipExpireTime;
20
21
22 }
1 package com.topdraw.business.process.service.domian.weixin;
2
3
4 import com.alibaba.fastjson.JSONObject;
5 import lombok.Data;
6
7 @Data
8 public class SubscribeBean extends WeiXinUserBean {
9
10 private JSONObject userInfoJson;
11
12 private JSONObject iptvUserInfo;
13
14 private String msgType;
15
16 private String event;
17
18
19 /** */
20 private String openId;
21
22 /** */
23 private String appId;
24
25 /** */
26 private String eventKey;
27
28 private String unionid;
29 private String nickname;
30 private String headimgurl;
31
32 }
1 package com.topdraw.business.process.service.domian.weixin;
2
3 import lombok.AllArgsConstructor;
4 import lombok.Data;
5 import lombok.NoArgsConstructor;
6
7 import javax.validation.constraints.NotNull;
8
9 @Data
10 @AllArgsConstructor
11 @NoArgsConstructor
12 public class SubscribeBeanEvent {
13
14 @NotNull(message = "【content】 not be null !!!")
15 private String content;
16
17 }
1 package com.topdraw.business.process.service.domian.weixin;
2
3
4 import com.alibaba.fastjson.annotation.JSONField;
5 import com.topdraw.annotation.Query;
6 import lombok.Data;
7
8 import java.sql.Timestamp;
9
10 @Data
11 public class UserCollectionMq {
12
13 // 应用ID
14 @JSONField(name = "app_id")
15 private Long appId;
16
17 @JSONField(name = "userId")
18 private Long userId;
19
20 // 收藏夹类型：1-收藏 2-播放记录 3-播放列表 4-评分 5-点赞/关注/订阅
21 private Integer type;
22
23 // 收藏夹名称
24 private String name;
25
26 // 数量
27 private Integer count;
28
29 private String images;
30
31 // 收藏夹ID
32 @JSONField(name = "user_collection_id")
33 @Query
34 private Long userCollectionId;
35
36 // 自定义收藏内容的类型CODE，默认：DEFAULT
37 @JSONField(name = "detail_folder_code")
38 @Query
39 private String detailFolderCode;
40
41 // 收藏内容的类型：MEDIA|EPISODE|CATEGORY|SUBJECT|ARTICLE|ARTIST|SCHOOL
42 @JSONField(name = "detail_type")
43 @Query
44 private String detailType;
45
46 // 收藏内容的ID
47 @JSONField(name = "detail_id")
48 @Query
49 private Long detailId;
50
51 // 收藏内容的CODE
52 @JSONField(name = "detail_code")
53 @Query
54 private String detailCode;
55
56 // 收藏内容的剧集ID
57 @JSONField(name = "detail_episode_id")
58 @Query
59 private Long detailEpisodeId;
60
61 // 收藏内容的剧集CODE
62 @JSONField(name = "detail_episode_code")
63 @Query
64 private String detailEpisodeCode;
65
66 // 收藏内容的名称
67 @JSONField(name = "detail_name")
68 @Query
69 private String detailName;
70
71 // 收藏内容的标记
72 @JSONField(name = "detail_mark")
73 @Query
74 private Integer detailMark;
75
76 // 收藏内容的图片
77 @JSONField(name = "detail_img")
78 private String detailImg;
79
80 // 收藏内容的剧集序号
81 @JSONField(name = "detail_index")
82 @Query
83 private Integer detailIndex;
84
85 // 收藏内容的剧集总数
86 @JSONField(name = "detail_total_index")
87 @Query
88 private Integer detailTotalIndex;
89
90 // 收藏内容的播放时间
91 @JSONField(name = "detail_play_time")
92 @Query
93 private Integer detailPlayTime;
94
95 // 收藏内容的总时间
96 @JSONField(name = "detail_total_time")
97 @Query
98 private Integer detailTotalTime;
99
100 // 收藏内容在同一folder中的顺序
101 @JSONField(name = "detail_sequence")
102 @Query
103 private Integer detailSequence;
104
105 // 收藏内容的评分
106 @JSONField(name = "detail_score")
107 @Query
108 private Float detailScore;
109
110 // 收藏内容（根据文件夹和类型的不同）的点赞/关注/订阅
111 @JSONField(name = "detail_like")
112 @Query
113 private Integer detailLike;
114
115 // 收藏内容的扩展数据
116 @JSONField(name = "detail_ext_data")
117 @Query
118 private String detailExtData;
119
120 // 创建时间
121 @JSONField(name = "create_time")
122 @Query
123 private Timestamp createTime;
124
125 // 更新时间
126 @JSONField(name = "update_time")
127 private Timestamp updateTime;
128 }
1 package com.topdraw.business.process.service.domian.weixin;
2
3
4 import lombok.Data;
5
6 /**
7 * 微信账户信息
8 * @author XiangHan
9 * @date 2021-01-18
10 */
11 @Data
12 public class WeiXinUserBean {
13
14 private Long id;
15
16 private String unionid;
17
18 /** */
19 private String openid;
20
21 /** */
22 private String appid;
23
24 /** 加密后的appId，参数 */
25 private String wxAppid;
26
27 /** 加密后的code，参数 */
28 private String wxCode;
29
30 /** */
31 private String userInfo;
32
33 /** 会员id */
34 private Long memberId;
35
36 /** 加密信息 */
37 private String encryptedData;
38
39 /** 解析用户电话号码时使用，参数 */
40 private String iv;
41
42 /** 资源id */
43 private String sourceId;
44
45 /** 资源类型 */
46 private String sourceType;
47
48 /** 资源描述，用来表示从哪个地方链接进来的 */
49 private String sourceDesc;
50
51 /** 资源实例 */
52 private String sourceEntity;
53
54 /** 推荐者id */
55 private Long sourceUser;
56
57 private String nikename;
58
59 private String headimgurl;
60 }
1 package com.topdraw.business.process.service.impl;
2
3 import com.topdraw.business.module.member.service.dto.MemberDTO;
4 import com.topdraw.business.module.task.domain.Task;
5
6 import java.util.List;
7
8 @FunctionalInterface
9 public interface CompareTaskCondition {
10
11 boolean compareCondition(MemberDTO memberDTO, List<Task> taskList);
12
13 }
...@@ -17,8 +17,6 @@ public class CouponOperationServiceImpl implements CouponOperationService { ...@@ -17,8 +17,6 @@ public class CouponOperationServiceImpl implements CouponOperationService {
17 @Autowired 17 @Autowired
18 private CouponHistoryService couponHistoryService; 18 private CouponHistoryService couponHistoryService;
19 @Autowired 19 @Autowired
20 private MemberOperationService memberOperationService;
21 @Autowired
22 private MemberService memberService; 20 private MemberService memberService;
23 21
24 public void asyncMemberCoupon(Member member) { 22 public void asyncMemberCoupon(Member member) {
......
...@@ -3,43 +3,66 @@ package com.topdraw.business.process.service.impl; ...@@ -3,43 +3,66 @@ package com.topdraw.business.process.service.impl;
3 import com.topdraw.business.module.exp.detail.domain.ExpDetail; 3 import com.topdraw.business.module.exp.detail.domain.ExpDetail;
4 import com.topdraw.business.module.exp.detail.service.ExpDetailService; 4 import com.topdraw.business.module.exp.detail.service.ExpDetailService;
5 import com.topdraw.business.module.member.domain.Member; 5 import com.topdraw.business.module.member.domain.Member;
6 import com.topdraw.business.module.member.level.service.MemberLevelService;
7 import com.topdraw.business.module.member.service.MemberService; 6 import com.topdraw.business.module.member.service.MemberService;
8 import com.topdraw.business.module.member.service.dto.MemberDTO; 7 import com.topdraw.business.module.member.service.dto.MemberDTO;
9 import com.topdraw.business.process.service.ExpOperationService; 8 import com.topdraw.business.process.service.ExpOperationService;
10 import com.topdraw.business.process.service.member.MemberOperationService; 9 import com.topdraw.utils.StringUtils;
10 import lombok.extern.slf4j.Slf4j;
11 import org.springframework.beans.factory.annotation.Autowired; 11 import org.springframework.beans.factory.annotation.Autowired;
12 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
13 import org.springframework.stereotype.Service; 12 import org.springframework.stereotype.Service;
14 13
15 import java.util.Objects; 14 import java.util.Objects;
16 15
17 /** 16
18 *
19 */
20 @Service 17 @Service
18 @Slf4j
21 public class ExpOperationServiceImpl implements ExpOperationService { 19 public class ExpOperationServiceImpl implements ExpOperationService {
22 20
23 @Autowired 21 @Autowired
24 private ExpDetailService expDetailService;
25 @Autowired
26 private MemberService memberService; 22 private MemberService memberService;
23 @Autowired
24 private ExpDetailService expDetailService;
25
26
27 public void asyncMemberExpAndLevel(Member resource) {
28 log.info("同步会员成长值和等级，参数 asyncMemberExpAndLevel# resource ==>> {}", resource);
29
30 String code = resource.getCode();
31 if (StringUtils.isBlank(code)) {
32 log.error("同步会员成长值和等级异常，asyncMemberExpAndLevel# message ==>> 会员code不得为空");
33 return;
34 }
27 35
28 public void asyncMemberExpAndLevel(Member member) {
29 String code = member.getCode();
30 MemberDTO memberDTO = this.memberService.findByCode(code); 36 MemberDTO memberDTO = this.memberService.findByCode(code);
31 member.setId(memberDTO.getId()); 37 log.info("同步会员成长值和等级，asyncMemberExpAndLevel# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", code, memberDTO);
38
39 resource.setId(memberDTO.getId());
40
41 log.info("同步会员成长值和等级，asyncMemberExpAndLevel# 入库参数，resource ==>> {}", resource);
42 this.memberService.doUpdateMemberExpAndLevel(resource);
43 }
32 44
33 this.memberService.doUpdateMemberExpAndLevel(member); 45 public void asyncExpDetail(ExpDetail resource) {
46 log.info("同步会员成长值详情，参数 asyncExpDetail# resource ==>> {}", resource);
47
48 String code = resource.getMemberCode();
49 if (StringUtils.isBlank(code)) {
50 log.error("同步会员成长值和等级异常，asyncExpDetail# message ==>> 会员code不得为空");
51 return;
34 } 52 }
35 53
36 public void asyncExpDetail(ExpDetail expDetail) {
37 String code = expDetail.getMemberCode();
38 MemberDTO memberDTO = this.memberService.findByCode(code); 54 MemberDTO memberDTO = this.memberService.findByCode(code);
39 if (Objects.nonNull(memberDTO.getId())) { 55 log.info("同步会员成长值详情，asyncExpDetail# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", code, memberDTO);
40 expDetail.setMemberId(memberDTO.getId()); 56
41 this.expDetailService.create(expDetail); 57 if (Objects.isNull(memberDTO.getId())) {
58 log.error("同步会员成长值详情，asyncExpDetail# message ==>> 会员");
59 return;
42 } 60 }
43 61
62 resource.setMemberId(memberDTO.getId());
63
64 log.info("同步会员成长值详情，asyncExpDetail# 入库参数，resource ==>> {}", resource);
65 this.expDetailService.create(resource);
66
44 } 67 }
45 } 68 }
......
...@@ -13,7 +13,6 @@ import com.topdraw.business.process.service.PointsOperationService; ...@@ -13,7 +13,6 @@ import com.topdraw.business.process.service.PointsOperationService;
13 import com.topdraw.utils.StringUtils; 13 import com.topdraw.utils.StringUtils;
14 import lombok.extern.slf4j.Slf4j; 14 import lombok.extern.slf4j.Slf4j;
15 import org.springframework.beans.factory.annotation.Autowired; 15 import org.springframework.beans.factory.annotation.Autowired;
16 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
17 import org.springframework.stereotype.Service; 16 import org.springframework.stereotype.Service;
18 import org.springframework.transaction.annotation.Propagation; 17 import org.springframework.transaction.annotation.Propagation;
19 import org.springframework.transaction.annotation.Transactional; 18 import org.springframework.transaction.annotation.Transactional;
...@@ -29,49 +28,92 @@ import java.util.*; ...@@ -29,49 +28,92 @@ import java.util.*;
29 public class PointsOperationServiceImpl implements PointsOperationService { 28 public class PointsOperationServiceImpl implements PointsOperationService {
30 29
31 @Autowired 30 @Autowired
31 private MemberService memberService;
32 @Autowired
32 private PointsDetailService pointsDetailService; 33 private PointsDetailService pointsDetailService;
33 @Autowired 34 @Autowired
34 private PointsAvailableService pointsAvailableService; 35 private PointsAvailableService pointsAvailableService;
35 @Autowired
36 private MemberService memberService;
37 @Autowired
38 ThreadPoolTaskExecutor threadPoolTaskExecutor;
39 36
40 public void asyncMemberPoint(Member member) { 37
41 log.info("修改会员积分,参数 =>> {}", member); 38 public void asyncMemberPoint(Member resource) {
42 String code = member.getCode(); 39 log.info("同步会员积分，参数 asyncMemberPoint# resource ==>> {}", resource);
40
41 String code = resource.getCode();
43 if (StringUtils.isBlank(code)) { 42 if (StringUtils.isBlank(code)) {
44 log.error("修改会员积分失败，参数错误，会员code为空"); 43 log.error("同步会员积分异常，asyncMemberPoint# message ==>> 会员code不得为空");
45 return; 44 return;
46 } 45 }
46
47 MemberDTO memberDTO = this.memberService.findByCode(code); 47 MemberDTO memberDTO = this.memberService.findByCode(code);
48 if (Objects.nonNull(memberDTO.getId())) { 48 log.info("同步会员积分，asyncMemberPoint# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", code, memberDTO);
49 member.setId(memberDTO.getId()); 49 if (Objects.isNull(memberDTO.getId())) {
50 this.memberService.doUpdateMemberPoints(member); 50 log.error("同步会员积分异常，asyncMemberPoint# message ==>> 会员信息不存在");
51 return;
52 }
53
54 resource.setId(memberDTO.getId());
55
56 log.info("同步会员积分，asyncMemberPoint# 入库参数， resource ==>> {}", resource);
57 this.memberService.doUpdateMemberPoints(resource);
51 } 58 }
59
60 public void asyncPointsAvailable(PointsAvailable resource) {
61 log.info("同步会员可用积分，参数 asyncPointsAvailable# resource ==>> {}", resource);
62
63 String memberCode = resource.getMemberCode();
64 if (StringUtils.isBlank(memberCode)) {
65 log.error("同步会员可用积分异常，asyncPointsAvailable# message ==>> 会员code不得为空");
66 return;
52 } 67 }
53 68
54 public void asyncPointsAvailable(PointsAvailable pointsAvailable) {
55 String memberCode = pointsAvailable.getMemberCode();
56 MemberDTO memberDTO = this.memberService.findByCode(memberCode); 69 MemberDTO memberDTO = this.memberService.findByCode(memberCode);
57 if (Objects.nonNull(memberDTO.getId())) { 70 log.info("同步会员可用积分，asyncPointsAvailable# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", memberCode, memberDTO);
58 pointsAvailable.setMemberId(memberDTO.getId()); 71 if (Objects.isNull(memberDTO.getId())) {
59 this.pointsAvailableService.create4Custom(pointsAvailable); 72 log.error("同步会员可用积分异常，asyncPointsAvailable# message ==>> 会员信息不存在 || code ==>> {}", memberCode);
73 return;
74 }
75
76 resource.setMemberId(memberDTO.getId());
77
78 log.info("同步会员可用积分，asyncPointsAvailable# 入库参数， resource ==>> {}", resource);
79 this.pointsAvailableService.create4Custom(resource);
60 } 80 }
81
82 public void asyncPointsDetail(PointsDetail resource) {
83 log.info("同步会员积分流水，参数 asyncPointsDetail# resource ==>> {}", resource);
84
85 String memberCode = resource.getMemberCode();
86 if (StringUtils.isBlank(memberCode)) {
87 log.error("同步会员积分流水异常，asyncPointsDetail# message ==>> 会员code不得为空");
88 return;
61 } 89 }
62 90
63 public void asyncPointsDetail(PointsDetail pointsDetail) {
64 String memberCode = pointsDetail.getMemberCode();
65 MemberDTO memberDTO = this.memberService.findByCode(memberCode); 91 MemberDTO memberDTO = this.memberService.findByCode(memberCode);
92 log.info("同步会员积分流水，asyncPointsDetail# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", memberCode, memberDTO);
66 if (Objects.nonNull(memberDTO.getId())) { 93 if (Objects.nonNull(memberDTO.getId())) {
67 pointsDetail.setMemberId(memberDTO.getId()); 94 log.error("同步会员积分流水异常，asyncPointsDetail# message ==>> 会员信息不存在 || code ==>> {}", memberCode);
68 this.pointsDetailService.create4Custom(pointsDetail); 95 return;
69 } 96 }
97
98 resource.setMemberId(memberDTO.getId());
99
100 log.info("同步会员积分流水，asyncPointsDetail# 入库参数， resource ==>> {}", resource);
101 this.pointsDetailService.create4Custom(resource);
102 }
103
104 public void asyncDeletePointsAvailable(PointsAvailable resource) {
105 log.info("同步删除会员可用积分，参数 asyncDeletePointsAvailable# resource ==>> {}", resource);
106
107 String code = resource.getCode();
108 if (StringUtils.isBlank(code)) {
109 log.error("同步删除会员可用积分异常，asyncDeletePointsAvailable# message ==>> 可用积分code不得为空");
110 return;
70 } 111 }
71 112
72 public void asyncDeletePointsAvailable(PointsAvailable pointsAvailable) {
73 String code = pointsAvailable.getCode();
74 PointsAvailableDTO pointsAvailableDTO = this.pointsAvailableService.getByCode(code); 113 PointsAvailableDTO pointsAvailableDTO = this.pointsAvailableService.getByCode(code);
114 log.info("同步会员积分流水，asyncPointsDetail# 通过code ==>> {}，查询会员可用积分，结果集，pointsAvailableDTO ==>> {}", code, pointsAvailableDTO);
115
116 log.info("同步会员积分流水，asyncPointsDetail# 删除可用积分，入库参数，pointsAvailableDTO ==>> {}", pointsAvailableDTO);
75 this.pointsAvailableService.delete(pointsAvailableDTO.getId()); 117 this.pointsAvailableService.delete(pointsAvailableDTO.getId());
76 } 118 }
77 } 119 }
......
1 package com.topdraw.business.process.service.impl; 1 package com.topdraw.business.process.service.impl;
2 2
3 import com.alibaba.fastjson.JSONObject;
4 import com.topdraw.business.module.task.attribute.domain.TaskAttr; 3 import com.topdraw.business.module.task.attribute.domain.TaskAttr;
5 import com.topdraw.business.module.task.attribute.service.TaskAttrService; 4 import com.topdraw.business.module.task.attribute.service.TaskAttrService;
6 import com.topdraw.business.module.task.attribute.service.dto.TaskAttrDTO; 5 import com.topdraw.business.module.task.attribute.service.dto.TaskAttrDTO;
......
...@@ -5,7 +5,6 @@ import com.topdraw.business.module.task.template.service.TaskTemplateService; ...@@ -5,7 +5,6 @@ import com.topdraw.business.module.task.template.service.TaskTemplateService;
5 import com.topdraw.business.module.task.template.service.dto.TaskTemplateDTO; 5 import com.topdraw.business.module.task.template.service.dto.TaskTemplateDTO;
6 import com.topdraw.business.process.service.TaskTemplateOperationService; 6 import com.topdraw.business.process.service.TaskTemplateOperationService;
7 import lombok.extern.slf4j.Slf4j; 7 import lombok.extern.slf4j.Slf4j;
8 import org.springframework.beans.BeanUtils;
9 import org.springframework.beans.factory.annotation.Autowired; 8 import org.springframework.beans.factory.annotation.Autowired;
10 import org.springframework.stereotype.Service; 9 import org.springframework.stereotype.Service;
11 10
...@@ -29,27 +28,14 @@ public class TaskTemplateOperationServiceImpl implements TaskTemplateOperationSe ...@@ -29,27 +28,14 @@ public class TaskTemplateOperationServiceImpl implements TaskTemplateOperationSe
29 private TaskTemplateService taskTemplateService; 28 private TaskTemplateService taskTemplateService;
30 29
31 public void asyncCreate(TaskTemplate resources) { 30 public void asyncCreate(TaskTemplate resources) {
32 this.create(resources);
33 }
34
35 public void asyncUpdate(TaskTemplate resources) {
36 this.update(resources);
37 }
38
39 public void asyncDelete(TaskTemplate resources) {
40 this.delete(resources);
41 }
42
43 private void create(TaskTemplate resources) {
44 String code = resources.getCode(); 31 String code = resources.getCode();
45 TaskTemplateDTO taskTemplateDTO = this.findByCode(code); 32 TaskTemplateDTO taskTemplateDTO = this.findByCode(code);
46 if (Objects.isNull(taskTemplateDTO.getId())) { 33 if (Objects.isNull(taskTemplateDTO.getId())) {
47 this.taskTemplateService.create(resources); 34 this.taskTemplateService.create(resources);
48 } 35 }
49
50 } 36 }
51 37
52 private void update(TaskTemplate resources) { 38 public void asyncUpdate(TaskTemplate resources) {
53 String code = resources.getCode(); 39 String code = resources.getCode();
54 TaskTemplateDTO taskTemplateDTO = this.findByCode(code); 40 TaskTemplateDTO taskTemplateDTO = this.findByCode(code);
55 if (Objects.nonNull(taskTemplateDTO.getId())) { 41 if (Objects.nonNull(taskTemplateDTO.getId())) {
...@@ -59,7 +45,7 @@ public class TaskTemplateOperationServiceImpl implements TaskTemplateOperationSe ...@@ -59,7 +45,7 @@ public class TaskTemplateOperationServiceImpl implements TaskTemplateOperationSe
59 } 45 }
60 } 46 }
61 47
62 private void delete(TaskTemplate resources) { 48 public void asyncDelete(TaskTemplate resources) {
63 String code = resources.getCode(); 49 String code = resources.getCode();
64 TaskTemplateDTO taskTemplateDTO = this.findByCode(code); 50 TaskTemplateDTO taskTemplateDTO = this.findByCode(code);
65 if (Objects.nonNull(taskTemplateDTO.getId())) { 51 if (Objects.nonNull(taskTemplateDTO.getId())) {
...@@ -68,21 +54,11 @@ public class TaskTemplateOperationServiceImpl implements TaskTemplateOperationSe ...@@ -68,21 +54,11 @@ public class TaskTemplateOperationServiceImpl implements TaskTemplateOperationSe
68 } 54 }
69 } 55 }
70 56
71 private void delete(Long id) {
72 TaskTemplateDTO taskTemplateDTO = this.findById(id);
73 this.taskTemplateService.delete(id);
74
75 TaskTemplate taskTemplate = new TaskTemplate();
76 BeanUtils.copyProperties(taskTemplateDTO, taskTemplate);
77 taskTemplate.setDeleteMark(1);
78 }
79
80 @Override 57 @Override
81 public TaskTemplateDTO findByCode(String code) { 58 public TaskTemplateDTO findByCode(String code) {
82 return this.taskTemplateService.findByCode(code); 59 return this.taskTemplateService.findByCode(code);
83 } 60 }
84 61
85
86 private TaskTemplateDTO findById(Long id) { 62 private TaskTemplateDTO findById(Long id) {
87 return this.taskTemplateService.findById(id); 63 return this.taskTemplateService.findById(id);
88 } 64 }
......
...@@ -2,23 +2,17 @@ package com.topdraw.business.process.service.impl; ...@@ -2,23 +2,17 @@ package com.topdraw.business.process.service.impl;
2 2
3 3
4 import com.topdraw.business.module.member.domain.Member; 4 import com.topdraw.business.module.member.domain.Member;
5 import com.topdraw.business.module.member.domain.MemberBuilder;
6 import com.topdraw.business.module.member.domain.MemberTypeConstant;
7 import com.topdraw.business.module.member.profile.domain.MemberProfile;
8 import com.topdraw.business.module.member.profile.service.MemberProfileService; 5 import com.topdraw.business.module.member.profile.service.MemberProfileService;
9 import com.topdraw.business.module.member.profile.service.dto.MemberProfileDTO; 6 import com.topdraw.business.module.member.profile.service.dto.MemberProfileDTO;
10 import com.topdraw.business.module.member.service.MemberService; 7 import com.topdraw.business.module.member.service.MemberService;
11 import com.topdraw.business.module.member.service.dto.MemberDTO; 8 import com.topdraw.business.module.member.service.dto.MemberDTO;
12 import com.topdraw.business.module.user.app.domain.UserApp; 9 import com.topdraw.business.module.user.app.domain.UserApp;
13 import com.topdraw.business.module.user.app.domain.UserAppBind;
14 import com.topdraw.business.module.user.app.domain.UserAppBindBuilder;
15 import com.topdraw.business.module.user.app.domain.UserAppBuilder; 10 import com.topdraw.business.module.user.app.domain.UserAppBuilder;
16 import com.topdraw.business.module.user.app.service.UserAppBindService; 11 import com.topdraw.business.module.user.app.service.UserAppBindService;
17 import com.topdraw.business.module.user.app.service.UserAppService; 12 import com.topdraw.business.module.user.app.service.UserAppService;
18 import com.topdraw.business.module.user.app.service.dto.AppRegisterDTO; 13 import com.topdraw.business.module.user.app.service.dto.AppRegisterDTO;
19 import com.topdraw.business.module.user.app.service.dto.UserAppBindDTO; 14 import com.topdraw.business.module.user.app.service.dto.UserAppBindDTO;
20 import com.topdraw.business.module.user.app.service.dto.UserAppDTO; 15 import com.topdraw.business.module.user.app.service.dto.UserAppDTO;
21 import com.topdraw.business.module.user.app.service.dto.UserAppSimpleDTO;
22 import com.topdraw.business.module.user.iptv.domain.UserTv; 16 import com.topdraw.business.module.user.iptv.domain.UserTv;
23 import com.topdraw.business.module.user.iptv.growreport.domain.GrowthReport; 17 import com.topdraw.business.module.user.iptv.growreport.domain.GrowthReport;
24 import com.topdraw.business.module.user.iptv.growreport.service.GrowthReportService; 18 import com.topdraw.business.module.user.iptv.growreport.service.GrowthReportService;
...@@ -33,10 +27,8 @@ import com.topdraw.business.process.service.dto.MemberAndUserTvDTO; ...@@ -33,10 +27,8 @@ import com.topdraw.business.process.service.dto.MemberAndUserTvDTO;
33 import com.topdraw.business.process.service.dto.MemberAndWeixinUserDTO; 27 import com.topdraw.business.process.service.dto.MemberAndWeixinUserDTO;
34 import com.topdraw.exception.EntityNotFoundException; 28 import com.topdraw.exception.EntityNotFoundException;
35 import com.topdraw.exception.GlobeExceptionMsg; 29 import com.topdraw.exception.GlobeExceptionMsg;
36 import com.topdraw.util.TimestampUtil;
37 import lombok.extern.slf4j.Slf4j; 30 import lombok.extern.slf4j.Slf4j;
38 import org.apache.commons.lang3.StringUtils; 31 import org.apache.commons.lang3.StringUtils;
39 import org.springframework.aop.framework.AopContext;
40 import org.springframework.beans.BeanUtils; 32 import org.springframework.beans.BeanUtils;
41 import org.springframework.beans.factory.annotation.Autowired; 33 import org.springframework.beans.factory.annotation.Autowired;
42 import org.springframework.stereotype.Service; 34 import org.springframework.stereotype.Service;
...@@ -56,95 +48,162 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -56,95 +48,162 @@ public class UserOperationServiceImpl implements UserOperationService {
56 @Autowired 48 @Autowired
57 private UserTvService userTvService; 49 private UserTvService userTvService;
58 @Autowired 50 @Autowired
51 private UserAppService userAppService;
52 @Autowired
59 private UserWeixinService userWeixinService; 53 private UserWeixinService userWeixinService;
60 @Autowired 54 @Autowired
61 private MemberProfileService memberProfileService; 55 private UserAppBindService userAppBindService;
62 @Autowired 56 @Autowired
63 private GrowthReportService growthReportService; 57 private GrowthReportService growthReportService;
64 @Autowired 58 @Autowired
65 private UserAppService userAppService; 59 private MemberProfileService memberProfileService;
66 @Autowired 60
67 private UserAppBindService userAppBindService;
68 61
69 public void asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg(UserAppDTO resources) { 62 public void asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg(UserAppDTO resources) {
63 log.info("修改app昵称、头像和最后活跃时间，参数 asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# resources ==>> {}", resources);
64
65 if (StringUtils.isBlank(resources.getUsername())) {
66 log.error("修改app昵称、头像和最后活跃时间异常，asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# message ==>> username不得为空");
67 return;
68 }
69
70 UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername()); 70 UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername());
71 log.info("修改app昵称、头像和最后活跃时间，通过账号获取app账号信息结果，asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# userAppDTO ==>> {}", userAppDTO);
72
71 if (Objects.isNull(userAppDTO.getId())) { 73 if (Objects.isNull(userAppDTO.getId())) {
74 log.error("修改app昵称、头像和最后活跃时间异常，asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# message ==>> app账号信息不存在 || username ==>> {}", resources.getUsername());
75 return;
76 }
72 77
73 UserApp userApp = new UserApp(); 78 UserApp userApp = new UserApp();
74 userApp.setId(userAppDTO.getId()); 79 userApp.setId(userAppDTO.getId());
75 userApp.setUsername(userAppDTO.getUsername()); 80 userApp.setUsername(userAppDTO.getUsername());
76 userApp.setNickname(resources.getNickname()); 81 userApp.setNickname(resources.getNickname());
77 userApp.setHeadimgurl(resources.getHeadimgurl()); 82 userApp.setHeadimgurl(resources.getHeadimgurl());
83
84 log.info("修改app昵称、头像和最后活跃时间，入库参数，asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# userApp ==>> {}", userApp);
78 this.userAppService.updateAppLastActiveTimeAndNicknameAndHeadImg(userApp); 85 this.userAppService.updateAppLastActiveTimeAndNicknameAndHeadImg(userApp);
79 } 86 }
80 }
81 87
82 public void asyncCancelUserAppBind(UserAppBindDTO resources) { 88 public void asyncCancelUserAppBind(UserAppBindDTO resources) {
83 89 // TODO 取消关联第三方账号，暂不用同步至大屏
84 } 90 }
85 91
86 public void asyncUpdatePasswordByUsername(UserAppDTO resources) { 92 public void asyncUpdatePasswordByUsername(UserAppDTO resources) {
93 log.info("修改app密码，参数 asyncUpdatePasswordByUsername# resources ==>> {}", resources);
94
95 if (StringUtils.isBlank(resources.getUsername())) {
96 log.error("修改app密码异常，asyncUpdatePasswordByUsername# message ==>> username不得为空");
97 return;
98 }
99
87 UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername()); 100 UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername());
101 log.info("修改app密码，通过账号获取app账号信息结果，asyncUpdatePasswordByUsername# userAppDTO ==>> {}", userAppDTO);
102
88 if (Objects.isNull(userAppDTO.getId())) { 103 if (Objects.isNull(userAppDTO.getId())) {
104 log.error("修改app密码异常，asyncUpdatePasswordByUsername# message ==>> app账号信息不存在 || username ==>> {}", resources.getUsername());
105 return;
106 }
107
89 UserApp userApp = new UserApp(); 108 UserApp userApp = new UserApp();
90 userApp.setId(userAppDTO.getId()); 109 userApp.setId(userAppDTO.getId());
91 userApp.setPassword(resources.getPassword()); 110 userApp.setPassword(resources.getPassword());
111
112 log.info("修改app密码，入库参数，asyncUpdatePasswordByUsername# userApp ==>> {}", userApp);
92 this.userAppService.updatePasswordById(userApp); 113 this.userAppService.updatePasswordById(userApp);
93 } 114 }
94 }
95 115
96 public void asyncUpdateAppInfo(UserAppDTO resources) { 116 public void asyncUpdateAppInfo(UserAppDTO resources) {
117 log.info("修改app账号信息，参数 asyncUpdateAppInfo# resources ==>> {}", resources);
118
119 if (StringUtils.isBlank(resources.getUsername())) {
120 log.error("修改app账号信息异常，asyncUpdateAppInfo# message ==>> username不得为空");
121 return;
122 }
123
97 UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername()); 124 UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername());
98 if (Objects.nonNull(userAppDTO.getId())) { 125 log.info("修改app账号信息，通过账号获取app账号信息结果，asyncUpdateAppInfo# userAppDTO ==>> {}", userAppDTO);
126
127 if (Objects.isNull(userAppDTO.getId())) {
128 log.error("修改app账号信息异常，asyncUpdateAppInfo# message ==>> app账号信息不存在 || username ==>> {}", resources.getUsername());
129 return;
130 }
131
99 UserApp userApp = new UserApp(); 132 UserApp userApp = new UserApp();
100 BeanUtils.copyProperties(resources, userApp); 133 BeanUtils.copyProperties(resources, userApp);
101 userApp.setId(userAppDTO.getId()); 134 userApp.setId(userAppDTO.getId());
135
136 log.info("修改app账号信息，入库参数，asyncUpdateAppInfo# userApp ==>> {}", userApp);
102 this.userAppService.updateAppInfo(userApp); 137 this.userAppService.updateAppInfo(userApp);
103 } 138 }
104 }
105 139
106 public void asyncAppCancellation(UserAppDTO resources) { 140 public void asyncAppCancellation(UserAppDTO resources) {
141 log.info("注销app账号，参数 asyncAppCancellation# resources ==>> {}", resources);
142
143 if (StringUtils.isBlank(resources.getUsername())) {
144 log.error("注销app账号异常，asyncAppCancellation# message ==>> username不得为空");
145 return;
146 }
147
107 UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername()); 148 UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername());
108 if (Objects.nonNull(userAppDTO.getId())) { 149 log.info("注销app账号信息，通过账号获取app账号信息结果，asyncAppCancellation# userAppDTO ==>> {}", userAppDTO);
109 this.userAppService.appCancellation(userAppDTO.getId()); 150
151 if (Objects.isNull(userAppDTO.getId())) {
152 log.error("注销app账号信息异常，asyncAppCancellation# message ==>> app账号信息不存在 || username ==>> {}", resources.getUsername());
153 return;
110 } 154 }
155
156 log.info("注销app账号信息，入库参数，asyncAppCancellation# userAppDTO ==>> {}", userAppDTO);
157 this.userAppService.appCancellation(userAppDTO.getId());
111 } 158 }
112 159
113 public void asyncAppRegister(AppRegisterDTO appRegisterDTO) { 160 public void asyncAppRegister(AppRegisterDTO resources) {
114 UserAppDTO userAppDTOResources = appRegisterDTO.getUserAppDTO(); 161 log.info("注册app账号，参数 asyncAppRegister# resources ==>> {}", resources);
115 MemberDTO memberDTOResources = appRegisterDTO.getMemberDTO(); 162
163 UserAppDTO userAppDTOResources = resources.getUserAppDTO();
164 MemberDTO memberDTOResources = resources.getMemberDTO();
165
166 if (StringUtils.isBlank(userAppDTOResources.getUsername())) {
167 log.error("注册app账号异常，asyncAppRegister# message ==>> username不得为空");
168 return;
169 }
116 170
117 UserAppDTO userAppDTO = this.userAppService.findByUsername(userAppDTOResources.getUsername()); 171 UserAppDTO userAppDTO = this.userAppService.findByUsername(userAppDTOResources.getUsername());
118 if (Objects.isNull(userAppDTO.getId())) { 172 log.info("注册app账号，通过账号获取app账号信息结果，asyncAppRegister# userAppDTO ==>> {}", userAppDTO);
173
174 if (Objects.nonNull(userAppDTO.getId())) {
175 log.error("注册app账号异常，asyncAppRegister# message ==>> app账号已存在 || userAppDTO ==>> {}", userAppDTO);
176 return;
177 }
119 178
120 // 先创建会员
121 // Member member = MemberBuilder.build(MemberTypeConstant.app, userAppDTOResources.getHeadimgurl(), userAppDTOResources.getNickname(), 0);
122 Member member = new Member(); 179 Member member = new Member();
123 BeanUtils.copyProperties(memberDTOResources, member); 180 BeanUtils.copyProperties(memberDTOResources, member);
124 member.setId(null); 181 member.setId(null);
125 MemberDTO _memberDTO = this.memberService.create(member); 182 MemberDTO _memberDTO = this.memberService.create(member);
183 log.info("注册app账号，app账号不存在，保存会员信息结果，asyncAppRegister# memberDTO ==>> {}", _memberDTO);
126 184
127 if (Objects.nonNull(_memberDTO.getId())) { 185 if (Objects.nonNull(_memberDTO.getId())) {
128 186
129 UserApp userApp = new UserApp(); 187 UserApp userApp = new UserApp();
130 BeanUtils.copyProperties(userAppDTOResources, userApp); 188 BeanUtils.copyProperties(userAppDTOResources, userApp);
131 userApp.setId(null); 189 userApp.setId(null);
190
132 // 保存app账号 191 // 保存app账号
133 UserAppDTO _userAppDTO = this.userAppService.create(UserAppBuilder.build(_memberDTO.getId(), userApp)); 192 UserAppDTO _userAppDTO = this.userAppService.create(UserAppBuilder.build(_memberDTO.getId(), userApp));
193 log.info("注册app账号，app账号不存在，保存会员信息之后保存app账号信息结果，asyncAppRegister# _userAppDTO ==>> {}", _userAppDTO);
134 194
135 if (Objects.nonNull(_userAppDTO.getId()) && StringUtils.isNotBlank(userAppDTO.getAccount())) { 195 /*if (Objects.nonNull(_userAppDTO.getId()) && StringUtils.isNotBlank(userAppDTO.getAccount())) {
136 UserAppBindDTO userAppBindDTO = this.userAppBindService.findFirstByAccount(userAppDTO.getAccount()); 196 UserAppBindDTO userAppBindDTO = this.userAppBindService.findFirstByAccount(userAppDTO.getAccount());
137 if (Objects.isNull(userAppBindDTO.getId())) { 197 if (Objects.isNull(userAppBindDTO.getId())) {
138 // 保存绑定关系 198 // 保存绑定关系
139 UserAppBind userAppBind = UserAppBindBuilder.build(_userAppDTO.getId(), userAppDTO.getAccount(), userAppDTO.getAccountType()); 199 UserAppBind userAppBind = UserAppBindBuilder.build(_userAppDTO.getId(), userAppDTO.getAccount(), userAppDTO.getAccountType());
140 this.userAppBindService.create(userAppBind); 200 this.userAppBindService.create(userAppBind);
141 } 201 }
142 } 202 }*/
143 203
144 } 204 }
145 205
146 } 206 }
147 }
148 207
149 public void asyncsaveGrowthReport(GrowthReport growthReport) { 208 public void asyncsaveGrowthReport(GrowthReport growthReport) {
150 String platformAccount = growthReport.getPlatformAccount(); 209 String platformAccount = growthReport.getPlatformAccount();
...@@ -178,44 +237,48 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -178,44 +237,48 @@ public class UserOperationServiceImpl implements UserOperationService {
178 } 237 }
179 238
180 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 239 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
181 public void asyncMemberAndUserWeixin4Iptv(MemberAndWeixinUserDTO memberAndWeixinUserDTO) { 240 public void asyncMemberAndUserWeixin4Iptv(MemberAndWeixinUserDTO resource) {
182 log.info("保存微信账号并同时创建会员信息 ==>> {}", memberAndWeixinUserDTO); 241 log.info("保存微信账号并同时创建会员信息，参数 asyncMemberAndUserWeixin4Iptv# ==>> {}", resource);
183 242
184 UserWeixinDTO userWeixinDTO = memberAndWeixinUserDTO.getUserWeixinDTO(); 243 UserWeixinDTO userWeixinDTO = resource.getUserWeixinDTO();
185 String openid = userWeixinDTO.getOpenid(); 244 String openid = userWeixinDTO.getOpenid();
186 String unionid = userWeixinDTO.getUnionid(); 245 String unionid = userWeixinDTO.getUnionid();
187 String appid = userWeixinDTO.getAppid(); 246 String appid = userWeixinDTO.getAppid();
188 247
189 UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByAppIdAndOpenId(appid, openid); 248 UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByAppIdAndOpenId(appid, openid);
190 log.info("通过appid ==>> {} 和openId ==>> {}，检查微信账号是否存在 ==>> {}",appid, openid, _userWeixinDTO); 249 log.info("保存微信账号并同时创建会员信息，asyncMemberAndUserWeixin4Iptv# 通过appid ==>> {}||openId ==>> {} ||结果集 ==>> {}",appid, openid, _userWeixinDTO);
191 // 无账号 250
251 // 当前微信账号不存在
192 if (Objects.isNull(_userWeixinDTO.getId())) { 252 if (Objects.isNull(_userWeixinDTO.getId())) {
193 253
194 // 其他账号 254 // 其他账号
195 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid); 255 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid);
196 log.info("账号不存在通过unionid ==>> {}，检查其他微信账号是否存在 ==>> {}",unionid, userWeixinDTO1); 256 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 无此微信账号，通过unionid ==>> {}，检查其他微信账号是否存在 ==>> {}",unionid, userWeixinDTO1);
197 257
258 // 有其他账号，需要共用一个会员信息
198 if (Objects.nonNull(userWeixinDTO1.getId())) { 259 if (Objects.nonNull(userWeixinDTO1.getId())) {
199 260
200 Long memberId = userWeixinDTO1.getMemberId(); 261 Long memberId = userWeixinDTO1.getMemberId();
262
201 if (Objects.nonNull(memberId)) { 263 if (Objects.nonNull(memberId)) {
202 userWeixinDTO.setMemberId(memberId); 264 userWeixinDTO.setMemberId(memberId);
203 MemberDTO memberDTO = this.memberService.findById(memberId); 265 MemberDTO memberDTO = this.memberService.findById(memberId);
204 log.info("其他账号的会员信息 ==>> {}，memberId ==>> {}",memberDTO, memberId); 266 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 其他账号的会员信息 ==>> {}", memberDTO);
205 if (Objects.nonNull(memberDTO.getId())) { 267 if (Objects.nonNull(memberDTO.getId())) {
206 MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO(); 268 userWeixinDTO.setMemberId(memberDTO.getId());
207 this.updateMember(memberDTO, memberDTO1);
208 } 269 }
209 270
210 } else { 271 } else {
211 272
212 MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO(); 273 MemberDTO memberDTO1 = resource.getMemberDTO();
213 log.info("其他账号的无会员信息，创建会员 memberDTO1 ==>> {}",memberDTO1);
214 String memberCode = memberDTO1.getCode(); 274 String memberCode = memberDTO1.getCode();
215 if (StringUtils.isNotBlank(memberCode)) { 275 if (StringUtils.isNotBlank(memberCode)) {
216 Member member = new Member(); 276 Member member = new Member();
217 member.setCode(memberCode); 277 member.setCode(memberCode);
278 log.warn("保存微信账号，asyncMemberAndUserWeixin4Iptv# 有其他账号但其他账号无会员信息，创建会员入库参数 member ==>> {}", member);
218 MemberDTO _memberDTO1 = this.memberService.create(member); 279 MemberDTO _memberDTO1 = this.memberService.create(member);
280
281 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 其他账号无会员信息，创建会员结果 _memberDTO1 ==>> {}", _memberDTO1);
219 userWeixinDTO.setMemberId(_memberDTO1.getId()); 282 userWeixinDTO.setMemberId(_memberDTO1.getId());
220 } 283 }
221 284
...@@ -224,59 +287,91 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -224,59 +287,91 @@ public class UserOperationServiceImpl implements UserOperationService {
224 // 无其他账号 287 // 无其他账号
225 } else { 288 } else {
226 289
227 MemberDTO memberDTO = memberAndWeixinUserDTO.getMemberDTO(); 290 MemberDTO memberDTO = resource.getMemberDTO();
228 log.info("无其他账号的无会员信息，创建会员 memberDTO ==>> {}",memberDTO); 291
229 Member member = new Member(); 292 Member member = new Member();
230 BeanUtils.copyProperties(memberDTO, member); 293 BeanUtils.copyProperties(memberDTO, member);
231 member.setId(null); 294 member.setId(null);
295
296 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 无其他账号，创建会员入库参数 member ==>> {}", member);
232 MemberDTO memberDTO1 = this.memberService.create(member); 297 MemberDTO memberDTO1 = this.memberService.create(member);
298
233 userWeixinDTO.setMemberId(memberDTO1.getId()); 299 userWeixinDTO.setMemberId(memberDTO1.getId());
234 } 300 }
235 301
236 userWeixinDTO.setId(null); 302 userWeixinDTO.setId(null);
237 log.info("保存微信账号，userWeixinDTO ==>> {}",userWeixinDTO); 303
304 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 入库信息 userWeixinDTO ==>> {}", userWeixinDTO);
238 this.createWeixin(userWeixinDTO); 305 this.createWeixin(userWeixinDTO);
239 306
307 // 当前微信账号存在
240 } else { 308 } else {
241 // 账号存在，会员也存在 309
242 // 会员存在 310 // 会员存在
243 if(Objects.nonNull(_userWeixinDTO.getMemberId())) { 311 if(Objects.nonNull(_userWeixinDTO.getMemberId())) {
244 // 账号存在，修改账号和会员 312 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在且会员信息也存在更新账号信息，入库信息 userWeixinDTO ==>> {}", userWeixinDTO);
245 this.updateWeixin(_userWeixinDTO, userWeixinDTO); 313 this.updateWeixin(_userWeixinDTO, userWeixinDTO);
314
246 MemberDTO _memberDTO = this.memberService.findById(_userWeixinDTO.getMemberId()); 315 MemberDTO _memberDTO = this.memberService.findById(_userWeixinDTO.getMemberId());
247 if (Objects.nonNull(_memberDTO.getId())){ 316 if (Objects.nonNull(_memberDTO.getId())){
248 MemberDTO memberDTO = memberAndWeixinUserDTO.getMemberDTO(); 317 MemberDTO memberDTO = resource.getMemberDTO();
318
319 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在且会员信息也存在更新会员信息，入库信息 memberDTO ==>> {}", memberDTO);
249 this.updateMember(_memberDTO, memberDTO); 320 this.updateMember(_memberDTO, memberDTO);
250 } 321 }
251 // 有账号无会员 322
323 // 无会员
252 } else { 324 } else {
253 325
254 // 是否存在会员 326 // 其他微信账号
255 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid); 327 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid);
328 log.warn("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在但无会员信息，通过unionid ==>> {}，获取任意微信账号信息，结果集 ==>> {}", unionid, userWeixinDTO1);
256 329
257 // 有其他账号 330 // 有其他微信账号
258 if (Objects.nonNull(userWeixinDTO1.getId())) { 331 if (Objects.nonNull(userWeixinDTO1.getId())) {
259 332
260 Long memberId = userWeixinDTO1.getMemberId(); 333 Long memberId = userWeixinDTO1.getMemberId();
261 if (Objects.nonNull(memberId)) { 334 if (Objects.nonNull(memberId)) {
262 335
263 userWeixinDTO.setMemberId(memberId); 336 userWeixinDTO.setMemberId(memberId);
337
264 MemberDTO memberDTO = this.memberService.findById(memberId); 338 MemberDTO memberDTO = this.memberService.findById(memberId);
265 MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO(); 339 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在但无会员信息，通过unionid获取其他账号对应的会员信息，结果集 memberDTO ==>>{}", memberDTO);
340
341 MemberDTO memberDTO1 = resource.getMemberDTO();
342 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在但无会员信息，更新会员信息 memberDTO1 ==>>{}", memberDTO1);
266 this.updateMember(memberDTO, memberDTO1); 343 this.updateMember(memberDTO, memberDTO1);
267 344
268 } else { 345 } else {
269 346
270 MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO(); 347 MemberDTO memberDTO1 = resource.getMemberDTO();
348
271 Member member = new Member(); 349 Member member = new Member();
272 BeanUtils.copyProperties(memberDTO1, member); 350 BeanUtils.copyProperties(memberDTO1, member);
273 member.setId(null); 351 member.setId(null);
352
353 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 其他微信账号信息存在但无会员信息，创建会员，入库参数 member ==>> {}", member);
274 MemberDTO _memberDTO1 = this.memberService.create(member); 354 MemberDTO _memberDTO1 = this.memberService.create(member);
355
275 userWeixinDTO.setMemberId(_memberDTO1.getId()); 356 userWeixinDTO.setMemberId(_memberDTO1.getId());
276 357
277 } 358 }
359
360 // 无其他微信账号
361 } else {
362
363 MemberDTO memberDTO1 = resource.getMemberDTO();
364 Member member = new Member();
365 BeanUtils.copyProperties(memberDTO1, member);
366 member.setId(null);
367
368 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 其他微信账号信息存在但无会员信息，创建会员，入库参数 member ==>> {}", member);
369 MemberDTO _memberDTO1 = this.memberService.create(member);
370
371 userWeixinDTO.setMemberId(_memberDTO1.getId());
278 } 372 }
279 373
374 log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 更新微信账号信息，入库信息 userWeixinDTO ==>>{}", userWeixinDTO);
280 this.updateWeixin(_userWeixinDTO, userWeixinDTO); 375 this.updateWeixin(_userWeixinDTO, userWeixinDTO);
281 376
282 } 377 }
...@@ -286,37 +381,46 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -286,37 +381,46 @@ public class UserOperationServiceImpl implements UserOperationService {
286 } 381 }
287 382
288 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 383 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
289 public void asyncMemberAndUserTv4Iptv(MemberAndUserTvDTO memberAndUserTvDTO) { 384 public void asyncMemberAndUserTv4Iptv(MemberAndUserTvDTO resource) {
290 log.info("同步小屏侧过来的大屏账号和会员, memberAndUserTvDTO ==>> {}", memberAndUserTvDTO); 385 log.info("保存大屏账号和会员，参数 asyncMemberAndUserTv4Iptv# ==>> {}", resource);
291 386
292 UserTvDTO userTvDTO = memberAndUserTvDTO.getUserTvDTO(); 387 UserTvDTO userTvDTO = resource.getUserTvDTO();
293 MemberDTO memberDTO = memberAndUserTvDTO.getMemberDTO(); 388 MemberDTO memberDTO = resource.getMemberDTO();
294 389
295 String platformAccount = userTvDTO.getPlatformAccount(); 390 String platformAccount = userTvDTO.getPlatformAccount();
296 log.info("同步小屏侧过来的大屏账号, platformAccount ==>> {}", platformAccount); 391 if (StringUtils.isBlank(platformAccount)) {
392 log.error("保存大屏账号和会员异常，asyncMemberAndUserTv4Iptv# message ==>> 大屏账号不得为空");
393 return;
394 }
395
297 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount); 396 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
298 // log.info("查询数据对应的大屏账号信息, _userTvDTO ==>> {}", _userTvDTO); 397 log.info("保存大屏账号和会员，asyncMemberAndUserTv4Iptv# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
299 398
399 // 大屏账号不存在
300 if (Objects.isNull(_userTvDTO)) { 400 if (Objects.isNull(_userTvDTO)) {
301 log.info("大屏账号不存在, 创建会员并新增账号"); 401
302 memberDTO.setId(null); 402 memberDTO.setId(null);
303 // 创建大屏会员 403 // 创建大屏会员
304 MemberDTO _memberDTO = this.createMember(memberDTO); 404 MemberDTO _memberDTO = this.createMember(memberDTO);
305 userTvDTO.setMemberId(_memberDTO.getId()); 405 userTvDTO.setMemberId(_memberDTO.getId());
406
306 // 创建大屏账号 407 // 创建大屏账号
307 this.createUserTv(userTvDTO); 408 log.info("保存大屏账号和会员，asyncMemberAndUserTv4Iptv# 保存大屏账号信息，入库参数， _userTvDTO ==>> {}", _userTvDTO);
409 UserTv userTv = new UserTv();
410 BeanUtils.copyProperties(userTvDTO, userTv);
411 this.userTvService.create(userTv);
308 412
413 // 大屏账号存在
309 } else { 414 } else {
310 415
311 Long memberId = _userTvDTO.getMemberId(); 416 Long memberId = _userTvDTO.getMemberId();
312 if (Objects.isNull(memberId)) { 417 if (Objects.isNull(memberId)) {
313 memberDTO.setId(null); 418 memberDTO.setId(null);
314 // 创建大屏会员 419 // 创建大屏会员
420 log.info("保存大屏账号和会员，asyncMemberAndUserTv4Iptv# 大屏账号存在但无会员信息，创建会员信息，入库参数，memberDTO ==>> {}", memberDTO);
315 MemberDTO _memberDTO = this.createMember(memberDTO); 421 MemberDTO _memberDTO = this.createMember(memberDTO);
316 userTvDTO.setMemberId(_memberDTO.getId());
317 422
318 log.info("大屏账号存在, 但无会员信息,新增会员信息并修改大屏账号"); 423 userTvDTO.setMemberId(_memberDTO.getId());
319 // this.userTvService.updateMemberId(platformAccount, _memberDTO.getId());
320 424
321 } else { 425 } else {
322 426
...@@ -330,9 +434,10 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -330,9 +434,10 @@ public class UserOperationServiceImpl implements UserOperationService {
330 434
331 } 435 }
332 436
333
334 UserTv userTv = new UserTv(); 437 UserTv userTv = new UserTv();
335 BeanUtils.copyProperties(_userTvDTO, userTv); 438 BeanUtils.copyProperties(_userTvDTO, userTv);
439
440 log.info("保存大屏账号和会员，asyncMemberAndUserTv4Iptv# 通过大屏账号修改大屏账号信息，入库参数，userTv ==>> {}", userTv);
336 this.userTvService.updateUserTvByPlatformAccount(userTv); 441 this.userTvService.updateUserTvByPlatformAccount(userTv);
337 442
338 } 443 }
...@@ -340,21 +445,24 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -340,21 +445,24 @@ public class UserOperationServiceImpl implements UserOperationService {
340 445
341 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 446 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
342 public void asyncMinaBind(MemberAndUserTvDTO memberAndUserTvDTO) { 447 public void asyncMinaBind(MemberAndUserTvDTO memberAndUserTvDTO) {
343 log.info("asyncAppletBind ==>> 小程序绑定大屏，参数 memberAndUserTvDTO ==>> {}", memberAndUserTvDTO); 448 log.info("小程序绑定大屏，参数 asyncMinaBind ==>> {}", memberAndUserTvDTO);
344 UserTvDTO userTvDTO = memberAndUserTvDTO.getUserTvDTO(); 449 UserTvDTO userTvDTO = memberAndUserTvDTO.getUserTvDTO();
345 MemberDTO memberDTO = memberAndUserTvDTO.getMemberDTO(); 450 MemberDTO memberDTO = memberAndUserTvDTO.getMemberDTO();
346 451
347 String platformAccount = userTvDTO.getPlatformAccount(); 452 String platformAccount = userTvDTO.getPlatformAccount();
453 if (StringUtils.isBlank(platformAccount)) {
454 log.error("小程序绑定大屏异常，asyncMinaBind# message ==>> 大屏账号不得为空");
455 return;
456 }
457
348 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount); 458 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
349 if (Objects.nonNull(_userTvDTO.getId())) { 459 log.info("小程序绑定大屏，asyncMinaBind# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
350 460
351 // 461 if (Objects.nonNull(_userTvDTO.getId())) {
352 // userTvDTO.getPriorityMemberCode();
353 // this.updateUserTv(_userTvDTO, userTvDTO);
354 // 修改大屏账号的主会员 462 // 修改大屏账号的主会员
355 String priorityMemberCode = userTvDTO.getPriorityMemberCode(); 463 String priorityMemberCode = userTvDTO.getPriorityMemberCode();
356 log.info("修改大屏账号的主会员, 主会员priorityMemberCode ==>> {}", priorityMemberCode); 464 if (StringUtils.isBlank(priorityMemberCode)) {
357 if (StringUtils.isNotBlank(priorityMemberCode)) { 465 log.info("小程序绑定大屏，asyncMinaBind# 设置主会员 priorityMemberCode ==>> {}", priorityMemberCode);
358 this.userTvService.updatePriorityMemberCode(platformAccount, priorityMemberCode); 466 this.userTvService.updatePriorityMemberCode(platformAccount, priorityMemberCode);
359 } 467 }
360 468
...@@ -362,111 +470,161 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -362,111 +470,161 @@ public class UserOperationServiceImpl implements UserOperationService {
362 MemberDTO _memberDTO = this.memberService.findByCode(code); 470 MemberDTO _memberDTO = this.memberService.findByCode(code);
363 471
364 memberDTO.setUserIptvId(_userTvDTO.getId()); 472 memberDTO.setUserIptvId(_userTvDTO.getId());
365 log.info("修改会员对应绑定的大屏账号id, memberId ==>> {} || userTvId ==>> {}", _memberDTO.getId(), _userTvDTO.getId()); 473 log.info("小程序绑定大屏，asyncMinaBind# 修改会员绑定的大屏id，入库参数，memberId ==>> {} || userTvId ==>> {}", _memberDTO.getId(), _userTvDTO.getId());
366 this.memberService.updateUserIptvIdById(_memberDTO.getId(), _userTvDTO.getId(), LocalDateTime.now()); 474 this.memberService.updateUserIptvIdById(_memberDTO.getId(), _userTvDTO.getId(), LocalDateTime.now());
367 475
368 } else {
369
370 log.error("asyncAppletBind ==>> 小程序绑定大屏异常，大屏账号不存在, platformAccount ==>> {}", platformAccount);
371
372 } 476 }
373 477
374 } 478 }
375 479
376 480
377 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 481 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
378 public void asyncUnbind(MemberAndUserTvDTO memberAndUserTvDTO) { 482 public void asyncUnbind(MemberAndUserTvDTO resource) {
379 UserTvDTO userTvDTO = memberAndUserTvDTO.getUserTvDTO(); 483 log.info("解绑，参数 asyncMinaBind# ==>> {}", resource);
380 MemberDTO memberDTO = memberAndUserTvDTO.getMemberDTO(); 484
485 UserTvDTO userTvDTO = resource.getUserTvDTO();
486 MemberDTO memberDTO = resource.getMemberDTO();
381 487
382 String platformAccount = userTvDTO.getPlatformAccount(); 488 String platformAccount = userTvDTO.getPlatformAccount();
489 if (StringUtils.isBlank(platformAccount)) {
490 log.error("解绑，asyncUnbind# message ==>> 大屏账号不得为空");
491 return;
492 }
493
383 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount); 494 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
495 log.info("解绑，asyncUnbind# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
496
384 if (Objects.nonNull(_userTvDTO.getId())) { 497 if (Objects.nonNull(_userTvDTO.getId())) {
385 // 498
386 UserTv userTv = new UserTv(); 499 UserTv userTv = new UserTv();
387 userTv.setPriorityMemberCode(userTvDTO.getPriorityMemberCode()); 500 userTv.setPriorityMemberCode(userTvDTO.getPriorityMemberCode());
388 userTv.setId(_userTvDTO.getId()); 501 userTv.setId(_userTvDTO.getId());
389 userTv.setPlatformAccount(_userTvDTO.getPlatformAccount()); 502 userTv.setPlatformAccount(_userTvDTO.getPlatformAccount());
503
504 log.info("解绑，asyncUnbind# 修改主会员code，入库参数， userTv ==>> {}", userTv);
390 this.userTvService.doUpdatePriorityMemberCode(userTv); 505 this.userTvService.doUpdatePriorityMemberCode(userTv);
391 } 506 }
392 507
393 String code = memberDTO.getCode(); 508 String code = memberDTO.getCode();
509 if (StringUtils.isBlank(code)) {
510 log.error("解绑，asyncUnbind# message ==>> 会员code不得为空");
511 return;
512 }
513
394 MemberDTO _memberDTO = this.memberService.findByCode(code); 514 MemberDTO _memberDTO = this.memberService.findByCode(code);
395 if (Objects.nonNull(_memberDTO.getId())) { 515 if (Objects.isNull(_memberDTO.getId())) {
516 log.error("解绑，asyncUnbind# message ==>> 会员信息不存在 || code ==>> {}", code);
517 return;
518 }
519
396 Member member = new Member(); 520 Member member = new Member();
397 member.setId(_memberDTO.getId()); 521 member.setId(_memberDTO.getId());
398 member.setUserIptvId(null); 522 member.setUserIptvId(null);
399 member.setBindIptvPlatformType(null); 523 member.setBindIptvPlatformType(null);
400 member.setBindIptvTime(null); 524 member.setBindIptvTime(null);
525
526 log.info("解绑，asyncUnbind# 修改会员的绑定关系，入库参数， member ==>> {}", member);
401 this.memberService.doUpdateMemberUserIptvIdAndBindPlatformTypeAndBingTime(member); 527 this.memberService.doUpdateMemberUserIptvIdAndBindPlatformTypeAndBingTime(member);
402 }
403 528
404 } 529 }
405 530
406 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 531 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
407 public void asyncWeixin(UserWeixinDTO userWeixinDTO) { 532 public void asyncWeixin(UserWeixinDTO resource) {
408 String openid = userWeixinDTO.getOpenid(); 533 log.info("更新微信信息，参数 asyncWeixin# resource ==>> {}", resource);
409 String unionid = userWeixinDTO.getUnionid(); 534
410 String appid = userWeixinDTO.getAppid(); 535 String openid = resource.getOpenid();
536 String unionid = resource.getUnionid();
537 String appid = resource.getAppid();
538
539 if (StringUtils.isBlank(appid) || StringUtils.isBlank(openid)) {
540 log.error("更新微信信息，asyncWeixin# message ==>> openid或者appid不得为空");
541 return;
542 }
543
411 UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByAppIdAndOpenId(appid, openid); 544 UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByAppIdAndOpenId(appid, openid);
412 if (Objects.nonNull(_userWeixinDTO.getId())) { 545 log.info("更新微信信息，参数 asyncWeixin# 通过appid和openid获取微信账号信息，结果集，_userWeixinDTO ==>> {}", _userWeixinDTO);
413 546
414 if(Objects.nonNull(_userWeixinDTO.getMemberId())) { 547 // 微信账号存在
548 if (Objects.nonNull(_userWeixinDTO.getId())) {
415 549
550 // unionid存在
416 if (StringUtils.isNotBlank(_userWeixinDTO.getUnionid())) { 551 if (StringUtils.isNotBlank(_userWeixinDTO.getUnionid())) {
417 552
553 // 会员不存在
554 if(Objects.isNull(_userWeixinDTO.getMemberId())) {
555
418 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(_userWeixinDTO.getUnionid()); 556 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(_userWeixinDTO.getUnionid());
419 if (Objects.nonNull(userWeixinDTO1)) { 557 log.info("更新微信信息，asyncWeixin# 账号存在但会员不存在，通过unionid获取其他微信账号信息，结果集， userWeixinDTO1 ==>> {}", userWeixinDTO1);
420 558
421 Long memberId = userWeixinDTO1.getMemberId(); 559 if (Objects.nonNull(userWeixinDTO1.getId())) {
422 if (Objects.nonNull(memberId)) {
423 560
424 userWeixinDTO.setMemberId(memberId); 561 Long memberId = userWeixinDTO1.getMemberId();
425 562
563 if (Objects.nonNull(memberId)) {
564 resource.setMemberId(memberId);
426 } else { 565 } else {
427 566
428 String memberCode = userWeixinDTO.getMemberCode(); 567 String memberCode = resource.getMemberCode();
429 if (StringUtils.isNotBlank(memberCode)) { 568 if (StringUtils.isNotBlank(memberCode)) {
430 Member member = new Member(); 569 Member member = new Member();
431 member.setCode(memberCode); 570 member.setCode(memberCode);
432 MemberDTO memberDTO1 = this.memberService.create(member);
433 userWeixinDTO.setMemberId(memberDTO1.getId());
434 }
435 571
572 log.info("更新微信信息，asyncWeixin# 账号存在但会员不存在，无其他微信账号，创建会员信息，入库信息，member ==>> {}", member);
573 MemberDTO memberDTO1 = this.memberService.create(member);
574 resource.setMemberId(memberDTO1.getId());
436 } 575 }
437 576
438 } 577 }
439 578
440 } else { 579 } else {
441 580
442 String memberCode = userWeixinDTO.getMemberCode(); 581
582 String memberCode = resource.getMemberCode();
443 if (StringUtils.isNotBlank(memberCode)) { 583 if (StringUtils.isNotBlank(memberCode)) {
444 Member member = new Member(); 584 Member member = new Member();
445 member.setCode(memberCode); 585 member.setCode(memberCode);
586
587 log.info("更新微信信息，asyncWeixin# 账号存在但会员不存在，创建会员信息，入库信息，member ==>> {}", member);
446 MemberDTO memberDTO1 = this.memberService.create(member); 588 MemberDTO memberDTO1 = this.memberService.create(member);
447 userWeixinDTO.setMemberId(memberDTO1.getId()); 589
590 resource.setMemberId(memberDTO1.getId());
591 }
592
448 } 593 }
449 594
450 } 595 }
451 596
597 // unionid不存在
452 } else { 598 } else {
453 599
454 String memberCode = userWeixinDTO.getMemberCode(); 600 // 会员存在
601 if(Objects.isNull(_userWeixinDTO.getMemberId())) {
602
603 String memberCode = resource.getMemberCode();
455 if (StringUtils.isNotBlank(memberCode)) { 604 if (StringUtils.isNotBlank(memberCode)) {
456 Member member = new Member(); 605 Member member = new Member();
457 member.setCode(memberCode); 606 member.setCode(memberCode);
458 MemberDTO memberDTO1 = this.memberService.create(member); 607 MemberDTO memberDTO1 = this.memberService.create(member);
459 userWeixinDTO.setMemberId(memberDTO1.getId()); 608
609 resource.setMemberId(memberDTO1.getId());
460 } 610 }
461 611
462 } 612 }
463 userWeixinDTO.setId(_userWeixinDTO.getId());
464 this.updateWeixin(_userWeixinDTO, userWeixinDTO);
465 613
614 resource.setUnionid(unionid);
615
616 }
617
618 resource.setId(_userWeixinDTO.getId());
619
620 log.info("更新微信信息，参数 asyncWeixin# 修改微信信息，入库参数，resource ==>> {}", resource);
621 this.updateWeixin(_userWeixinDTO, resource);
622
623 // 微信账号不存在
466 } else { 624 } else {
467 625
468 userWeixinDTO.setId(null); 626 resource.setId(null);
469 String memberCode = userWeixinDTO.getMemberCode(); 627 String memberCode = resource.getMemberCode();
470 Long memberId = null; 628 Long memberId = null;
471 if (StringUtils.isNotBlank(memberCode)) { 629 if (StringUtils.isNotBlank(memberCode)) {
472 MemberDTO memberDTO = this.memberService.findByCode(memberCode); 630 MemberDTO memberDTO = this.memberService.findByCode(memberCode);
...@@ -479,8 +637,10 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -479,8 +637,10 @@ public class UserOperationServiceImpl implements UserOperationService {
479 memberId = memberDTO.getId(); 637 memberId = memberDTO.getId();
480 } 638 }
481 639
482 userWeixinDTO.setMemberId(memberId); 640 resource.setMemberId(memberId);
483 this.createWeixin(userWeixinDTO); 641
642 log.info("更新微信信息，参数 asyncWeixin# 保存微信账号信息，入库参数，resource ==>> {}", resource);
643 this.createWeixin(resource);
484 } 644 }
485 645
486 } 646 }
...@@ -488,20 +648,26 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -488,20 +648,26 @@ public class UserOperationServiceImpl implements UserOperationService {
488 } 648 }
489 649
490 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 650 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
491 public void asyncUserTvChangeMainAccount(UserTvDTO userTvDTO) { 651 public void asyncUserTvChangeMainAccount(UserTvDTO resource) {
492 log.info("asyncUserTv ==>> userTvDTO ==>> {}", userTvDTO); 652 log.info("更新大屏的主会员，参数 asyncUserTvChangeMainAccount# resource ==>> {}", resource);
493 653
494 String priorityMemberCode = userTvDTO.getPriorityMemberCode(); 654 String priorityMemberCode = resource.getPriorityMemberCode();
495 if (StringUtils.isBlank(priorityMemberCode)) { 655 if (StringUtils.isBlank(priorityMemberCode)) {
496 log.error("大屏账号设置主会员异常，主会员code不存在"); 656 log.error("更新大屏的主会员异常，asyncUserTvChangeMainAccount# message ==>> 主会员code不得为空");
657 return;
658 }
659
660 String platformAccount = resource.getPlatformAccount();
661 if (StringUtils.isBlank(platformAccount)) {
662 log.error("更新大屏的主会员异常，asyncUserTvChangeMainAccount# message ==>> 大屏账号不得为空");
497 return; 663 return;
498 } 664 }
499 665
500 String platformAccount = userTvDTO.getPlatformAccount();
501 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount); 666 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
502 log.info("从数据库中获取大屏信息， _userTvDTO ==>> {}", _userTvDTO); 667 log.info("更新大屏的主会员，asyncUserTvChangeMainAccount# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
668
503 if (Objects.isNull(_userTvDTO.getId())) { 669 if (Objects.isNull(_userTvDTO.getId())) {
504 log.error("大屏账号设置主会员异常，大屏账号不存在"); 670 log.error("大屏账号设置主会员异常，asyncUserTvChangeMainAccount# message ==>> 大屏账号不存在");
505 return; 671 return;
506 } 672 }
507 673
...@@ -509,102 +675,131 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -509,102 +675,131 @@ public class UserOperationServiceImpl implements UserOperationService {
509 userTv.setId(_userTvDTO.getId()); 675 userTv.setId(_userTvDTO.getId());
510 userTv.setPlatformAccount(platformAccount); 676 userTv.setPlatformAccount(platformAccount);
511 userTv.setPriorityMemberCode(priorityMemberCode); 677 userTv.setPriorityMemberCode(priorityMemberCode);
512 log.info("开始修改大屏数据，userTv ==>>{}", userTv); 678
679 log.info("更新大屏的主会员，asyncUserTvChangeMainAccount# 修改大屏的主会员，入库参数，userTv ==>>{}", userTv);
513 this.userTvService.doUpdatePriorityMemberCode(userTv); 680 this.userTvService.doUpdatePriorityMemberCode(userTv);
514 } 681 }
515 682
516 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 683 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
517 public void asyncUserTv(UserTvDTO userTvDTO) { 684 public void asyncUserTv(UserTvDTO resource) {
518 log.info("asyncUserTv ==>> userTvDTO ==>> {}", userTvDTO); 685 log.info("更新大屏账号信息，参数 asyncUserTv# resource ==>> {}", resource);
519 String platformAccount = userTvDTO.getPlatformAccount(); 686
687 String platformAccount = resource.getPlatformAccount();
688 if (StringUtils.isBlank(platformAccount)) {
689 log.error("更新大屏账号信息异常，asyncUserTv# message ==>> 大屏账号不得为空");
690 return;
691 }
692
520 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount); 693 UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
521 log.info("db result ==>> _userTvDTO ==>> {}", _userTvDTO); 694 log.info("更新大屏账号信息，asyncUserTv# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
522 // this.updateUserTv(_userTvDTO, userTvDTO);
523 695
524 UserTv userTv = new UserTv(); 696 UserTv userTv = new UserTv();
525 BeanUtils.copyProperties(userTvDTO, userTv); 697 BeanUtils.copyProperties(resource, userTv);
698
699 log.info("更新大屏账号信息，asyncUserTv# 修改大屏账号信息，入库参数，userTv ==>>{}", userTv);
526 this.userTvService.updateUserTvByPlatformAccount(userTv); 700 this.userTvService.updateUserTvByPlatformAccount(userTv);
527 } 701 }
528 702
529 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 703 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
530 public void asyncMember(MemberDTO memberDTO) { 704 public void asyncMember(MemberDTO resource) {
531 String code = memberDTO.getCode(); 705 log.info("更新会员信息，参数 asyncMember# resource ==>> {}", resource);
532 if (StringUtils.isNotBlank(code)) { 706
533 MemberDTO _memberDTO = this.memberService.findByCode(code); 707 String code = resource.getCode();
534 if (Objects.nonNull(_memberDTO)) { 708 if (StringUtils.isBlank(code)) {
535 Long id = _memberDTO.getId(); 709 log.error("更新会员信息异常，asyncMember# message ==>> 会员code不得为空");
536 memberDTO.setId(id); 710 return;
537 this.updateMember(_memberDTO, memberDTO);
538 } 711 }
712
713 MemberDTO _memberDTO = this.memberService.findByCode(code);
714 if (Objects.isNull(_memberDTO.getId())) {
715 log.error("更新会员信息异常，asyncMember# message ==>> 会员信息不存在");
716 return;
539 } 717 }
718
719 Long id = _memberDTO.getId();
720 resource.setId(id);
721 this.updateMember(_memberDTO, resource);
540 } 722 }
541 723
542 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 724 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
543 public void asyncSubscribe(MemberAndWeixinUserDTO memberAndWeixinUserDTO) { 725 public void asyncSubscribe(MemberAndWeixinUserDTO resource) {
544 log.info("微信关注业务开始"); 726 log.info("微信关注，参数 asyncSubscribe# resource ==>> {}", resource);
545 UserWeixinDTO userWeixinDTO = memberAndWeixinUserDTO.getUserWeixinDTO(); 727
546 log.info("小屏侧传过来的微信账号信息 ==>> userWeixinDTO ==>> {}", userWeixinDTO); 728 UserWeixinDTO userWeixinDTO = resource.getUserWeixinDTO();
547 String openid = userWeixinDTO.getOpenid(); 729 String openid = userWeixinDTO.getOpenid();
548 String unionid = userWeixinDTO.getUnionid(); 730 String unionid = userWeixinDTO.getUnionid();
549 String appid = userWeixinDTO.getAppid(); 731 String appid = userWeixinDTO.getAppid();
550 MemberDTO memberDTO = memberAndWeixinUserDTO.getMemberDTO(); 732
551 log.info("小屏侧传过来的会员信息 ==>> memberDTO ==>> {}", memberDTO); 733 if (StringUtils.isBlank(appid) || StringUtils.isBlank(openid)) {
734 log.error("微信关异常，asyncSubscribe# message ==>> openid或者appid不得为空");
735 return;
736 }
737
738 MemberDTO memberDTO = resource.getMemberDTO();
552 739
553 UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByUnionIdAndAppIdAndOpenId(unionid, appid, openid); 740 UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByUnionIdAndAppIdAndOpenId(unionid, appid, openid);
741 log.info("微信关注，asyncSubscribe# 通过unionid ==>> {} || appid ==>> {} || openid ==>> {}，查询微信账号信息，结果集 ==>>{}", unionid, appid, openid, _userWeixinDTO);
742
554 // 有账号 743 // 有账号
555 if (Objects.nonNull(_userWeixinDTO.getId())) { 744 if (Objects.nonNull(_userWeixinDTO.getId())) {
556 log.info("账号存在，检查会员是否存在");
557 UserWeixinDTO _userWeixinDTO0 = this.userWeixinService.findFirstByAppIdAndOpenId(appid, openid);
558 // 会员存在 745 // 会员存在
559 if(Objects.nonNull(_userWeixinDTO0.getMemberId())) { 746 if(Objects.nonNull(_userWeixinDTO.getMemberId())) {
560 log.info("会员存在，修改账号的关注状态, 关注状态 status ==>> {}", userWeixinDTO.getStatus()); 747
561 // 账号存在，修改账号和会员 748 log.info("微信关注，asyncSubscribe# 修改微信信息，入库信息，userWeixinDTO ==>> {}", userWeixinDTO);
562 this.updateWeixin(_userWeixinDTO, userWeixinDTO); 749 this.updateWeixin(_userWeixinDTO, userWeixinDTO);
750
563 MemberDTO _memberDTO = this.memberService.findById(_userWeixinDTO.getMemberId()); 751 MemberDTO _memberDTO = this.memberService.findById(_userWeixinDTO.getMemberId());
564 752
565 MemberDTO memberDTO0 = memberAndWeixinUserDTO.getMemberDTO(); 753 MemberDTO memberDTO0 = resource.getMemberDTO();
566 memberDTO0.setUserIptvId(_memberDTO.getUserIptvId()); 754 memberDTO0.setUserIptvId(_memberDTO.getUserIptvId());
567 755
568 log.info("会员存在，修改会员的绑定和vip标识", userWeixinDTO.getStatus()); 756 log.info("微信关注，asyncSubscribe# 修改会员的绑定状态和vip标识，入库参数，userWeixinDTO ==>> {}", userWeixinDTO);
569 this.updateMember(_memberDTO, memberDTO0); 757 this.updateMember(_memberDTO, memberDTO0);
570 758
571 // 有账号无会员 759 // 无会员
572 } else { 760 } else {
573 761
574 log.info("当前账号会员不存在"); 762 // 其他微信账号
575 // 是否存在会员
576 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid); 763 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid);
577 log.info("检查是否有其他账号存在, 其他账号信息 ==>> {}", userWeixinDTO1); 764 log.info("微信关注，asyncSubscribe#，通过unionid==>> {}，检查是否有其他账号存在，结果集 ==>> {}", unionid, userWeixinDTO1);
765
578 // 有其他账号 766 // 有其他账号
579 if (Objects.nonNull(userWeixinDTO1.getId())) { 767 if (Objects.nonNull(userWeixinDTO1.getId())) {
580 log.info("存在其他账号，检查其他账号是否有会员"); 768
581 Long memberId = userWeixinDTO1.getMemberId(); 769 Long memberId = userWeixinDTO1.getMemberId();
582 if (Objects.nonNull(memberId)) { 770 if (Objects.nonNull(memberId)) {
583
584 userWeixinDTO.setMemberId(memberId); 771 userWeixinDTO.setMemberId(memberId);
585 MemberDTO memberDTO0 = this.memberService.findById(memberId);
586 log.info("其他账号有会员，会员信息 ==>> {}", memberDTO0);
587 772
588 MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO(); 773 MemberDTO memberDTO0 = this.memberService.findById(memberId);
589 774
590 log.info("开始同步会员信息"); 775 log.info("微信关注，asyncSubscribe# 微信账号存在但无会员，同步其他账号的会员信息，入库参数，memberDTO0 ==>> {}", memberDTO);
591 this.updateMember(memberDTO0, memberDTO1); 776 this.updateMember(memberDTO0, memberDTO);
592 777
593 } else { 778 } else {
594 log.info("其他账号无会员"); 779
595 MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
596 Member member = new Member(); 780 Member member = new Member();
597 BeanUtils.copyProperties(memberDTO1, member); 781 BeanUtils.copyProperties(memberDTO, member);
598 member.setId(null); 782 member.setId(null);
599 783
600 log.info("为当前账号创建会员，会员信息 ==>> {}", member); 784 log.info("微信关注，asyncSubscribe# 微信账号存在但无会员也其他账号也无会员，创建会员信息，入库参数，member ==>> {}", member);
601 MemberDTO _memberDTO1 = this.memberService.create(member); 785 MemberDTO _memberDTO1 = this.memberService.create(member);
602 userWeixinDTO.setMemberId(_memberDTO1.getId()); 786 userWeixinDTO.setMemberId(_memberDTO1.getId());
603 787
604 } 788 }
789
790 // 无其他账号
791 } else {
792
793 Member member = new Member();
794 BeanUtils.copyProperties(memberDTO, member);
795 member.setId(null);
796
797 log.info("微信关注，asyncSubscribe# 微信账号存在但无会员也无其他账号，创建会员信息，入库参数，member ==>> {}", member);
798 MemberDTO _memberDTO1 = this.memberService.create(member);
799 userWeixinDTO.setMemberId(_memberDTO1.getId());
605 } 800 }
606 801
607 log.info("开始修改账号信息"); 802 log.info("微信关注，asyncSubscribe# 更新微信账号信息，入库参数，userWeixinDTO ==>> {}", userWeixinDTO);
608 this.updateWeixin(_userWeixinDTO, userWeixinDTO); 803 this.updateWeixin(_userWeixinDTO, userWeixinDTO);
609 804
610 } 805 }
...@@ -612,36 +807,31 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -612,36 +807,31 @@ public class UserOperationServiceImpl implements UserOperationService {
612 // 无账号 807 // 无账号
613 } else { 808 } else {
614 809
615 log.info("当前账号不存在，检查其他账号是否存在");
616 // 是否存在会员 810 // 是否存在会员
617 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid); 811 UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid);
812 log.info("微信关注，asyncSubscribe#，通过unionid==>> {}，检查是否有其他账号存在，结果集 userWeixinDTO1 ==>> {}", unionid, userWeixinDTO1);
618 813
619 // 有其他账号 814 // 有其他账号
620 if (Objects.nonNull(userWeixinDTO1.getId())) { 815 if (Objects.nonNull(userWeixinDTO1.getId())) {
621 816
622 log.info("其他账号存在, 其他账号信息 ==>> {}", userWeixinDTO1);
623
624 log.info("检查其他账号是否有会员");
625 Long memberId = userWeixinDTO1.getMemberId(); 817 Long memberId = userWeixinDTO1.getMemberId();
626 if (Objects.nonNull(memberId)) { 818 if (Objects.nonNull(memberId)) {
627 819
628 userWeixinDTO.setMemberId(memberId); 820 userWeixinDTO.setMemberId(memberId);
629 MemberDTO memberDTO0 = this.memberService.findById(memberId);
630 log.info("其他账号有会员，会员信息 ==>> {}", memberDTO0);
631 821
632 MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO(); 822 MemberDTO memberDTO0 = this.memberService.findById(memberId);
823 log.info("微信关注，asyncSubscribe#，当前微信账号不存在，获取其他账号的会员信息，结果集 memberDTO0 ==>> {}", memberDTO0);
633 824
634 log.info("开始同步会员信息"); 825 log.info("微信关注，asyncSubscribe# 更新会员信息，入库参数 memberDTO ==>> {}", memberDTO);
635 this.updateMember(memberDTO0, memberDTO1); 826 this.updateMember(memberDTO0, memberDTO);
636 827
637 } else { 828 } else {
638 log.info("其他账号无会员"); 829
639 MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
640 Member member = new Member(); 830 Member member = new Member();
641 BeanUtils.copyProperties(memberDTO1, member); 831 BeanUtils.copyProperties(memberDTO, member);
642 member.setId(null); 832 member.setId(null);
643 833
644 log.info("为当前账号创建会员，会员信息 ==>> {}", member); 834 log.info("微信关注，asyncSubscribe# 微信账号存在但无会员其他账号也无会员信息，创建会员信息，入库参数，member ==>> {}", member);
645 MemberDTO _memberDTO1 = this.memberService.create(member); 835 MemberDTO _memberDTO1 = this.memberService.create(member);
646 userWeixinDTO.setMemberId(_memberDTO1.getId()); 836 userWeixinDTO.setMemberId(_memberDTO1.getId());
647 837
...@@ -649,53 +839,64 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -649,53 +839,64 @@ public class UserOperationServiceImpl implements UserOperationService {
649 839
650 } else { 840 } else {
651 841
652 log.info("无其他账号存在");
653 MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
654 Member member = new Member(); 842 Member member = new Member();
655 BeanUtils.copyProperties(memberDTO1, member); 843 BeanUtils.copyProperties(memberDTO, member);
656 member.setId(null); 844 member.setId(null);
657 845
658 log.info("为当前账号创建会员，会员信息 ==>> {}", member); 846 log.info("微信关注，asyncSubscribe# 微信账号存在但无会员也无其他账号，创建会员信息，入库参数，member ==>> {}", member);
659 MemberDTO _memberDTO1 = this.memberService.create(member); 847 MemberDTO _memberDTO1 = this.memberService.create(member);
660 userWeixinDTO.setMemberId(_memberDTO1.getId()); 848 userWeixinDTO.setMemberId(_memberDTO1.getId());
661 849
662 } 850 }
663 851
664 log.info("开始创建微信账号"); 852 log.info("微信关注，asyncSubscribe# 保存微信账号信息，入库参数，userWeixinDTO ==>> {}", userWeixinDTO);
665 this.createWeixin(userWeixinDTO); 853 this.createWeixin(userWeixinDTO);
666 854
667 } 855 }
668 } 856 }
669 857
670 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class) 858 @Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
671 public void asyncUnsubscribe(MemberAndWeixinUserDTO memberAndWeixinUserDTO) { 859 public void asyncUnsubscribe(MemberAndWeixinUserDTO resource) {
672 UserWeixinDTO userWeixinDTO = memberAndWeixinUserDTO.getUserWeixinDTO(); 860 log.info("微信取关，参数 asyncUnsubscribe# resource ==>> {}", resource);
861
862 UserWeixinDTO userWeixinDTO = resource.getUserWeixinDTO();
673 String openid = userWeixinDTO.getOpenid(); 863 String openid = userWeixinDTO.getOpenid();
674 String unionid = userWeixinDTO.getUnionid(); 864 String unionid = userWeixinDTO.getUnionid();
675 String appid = userWeixinDTO.getAppid(); 865 String appid = userWeixinDTO.getAppid();
676 MemberDTO memberDTO = memberAndWeixinUserDTO.getMemberDTO(); 866
867 if (StringUtils.isBlank(appid) || StringUtils.isBlank(openid)) {
868 log.error("微信取关异常，asyncUnsubscribe# message ==>> openid或者appid不得为空");
869 return;
870 }
871
872 MemberDTO memberDTO = resource.getMemberDTO();
677 873
678 UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByUnionIdAndAppIdAndOpenId(unionid, appid, openid); 874 UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByUnionIdAndAppIdAndOpenId(unionid, appid, openid);
679 if (Objects.nonNull(_userWeixinDTO)) { 875 log.info("微信取关，asyncUnsubscribe# 通过unionid ==>> {} || appid ==>> {} || openid ==>> {}，查询微信账号信息，结果集 ==>>{}", unionid, appid, openid, _userWeixinDTO);
876
877 if (Objects.nonNull(_userWeixinDTO.getId())) {
680 878
681 // 账号存在，修改账号和会员 879 // 账号存在，修改账号和会员
880 log.info("微信取关，asyncUnsubscribe# 更新微信账号信息，入库参数，userWeixinDTO ==>>{}", userWeixinDTO);
682 this.updateWeixin(_userWeixinDTO, userWeixinDTO); 881 this.updateWeixin(_userWeixinDTO, userWeixinDTO);
683 882
684 MemberDTO _memberDTO = this.memberService.findById(_userWeixinDTO.getMemberId()); 883 MemberDTO _memberDTO = this.memberService.findById(_userWeixinDTO.getMemberId());
685 if (Objects.nonNull(_memberDTO)) { 884 if (Objects.nonNull(_memberDTO.getId())) {
686 885
687 memberDTO.setUserIptvId(_memberDTO.getUserIptvId()); 886 memberDTO.setUserIptvId(_memberDTO.getUserIptvId());
887
888 log.info("微信取关，asyncUnsubscribe# 更新会员信息，入库参数，memberDTO ==>>{}", memberDTO);
688 this.updateMember(_memberDTO, memberDTO); 889 this.updateMember(_memberDTO, memberDTO);
689 890
690 } else { 891 } else {
691 892
692 throw new EntityNotFoundException(MemberDTO.class, "id", GlobeExceptionMsg.MEMBER_ID_IS_NULL); 893 log.error("微信取关异常，asyncUnsubscribe# message ==>> 会员信息不存在");
693 894
694 } 895 }
695 896
696 } else { 897 } else {
697 898
698 throw new EntityNotFoundException(UserWeixinDTO.class, "id", GlobeExceptionMsg.WEIXIN_IS_NULL); 899 log.error("微信取关异常，asyncUnsubscribe# message ==>> 微信账号不存在");
699 900
700 } 901 }
701 902
...@@ -707,15 +908,15 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -707,15 +908,15 @@ public class UserOperationServiceImpl implements UserOperationService {
707 return this.memberService.create(member); 908 return this.memberService.create(member);
708 } 909 }
709 910
710 private MemberDTO updateMember(MemberDTO _memberDTO, MemberDTO memberDTO){ 911 private void updateMember(MemberDTO _memberDTO, MemberDTO memberDTO){
711 912
712 memberDTO.setId(_memberDTO.getId()); 913 memberDTO.setId(_memberDTO.getId());
713 memberDTO.setCode(_memberDTO.getCode()); 914 memberDTO.setCode(_memberDTO.getCode());
714 915
715 Member member = new Member(); 916 Member member = new Member();
716 BeanUtils.copyProperties(memberDTO, member); 917 BeanUtils.copyProperties(memberDTO, member);
717 log.info("会员入库结果 ==>> member ==>> {}", member); 918
718 return this.memberService.update(member); 919 this.memberService.update(member);
719 } 920 }
720 921
721 private void createWeixin(UserWeixinDTO weixinDTO){ 922 private void createWeixin(UserWeixinDTO weixinDTO){
...@@ -745,10 +946,4 @@ public class UserOperationServiceImpl implements UserOperationService { ...@@ -745,10 +946,4 @@ public class UserOperationServiceImpl implements UserOperationService {
745 log.info("账号入库结果 ==>> userWeixin ==>> {}", userWeixin); 946 log.info("账号入库结果 ==>> userWeixin ==>> {}", userWeixin);
746 this.userWeixinService.update(userWeixin); 947 this.userWeixinService.update(userWeixin);
747 } 948 }
748
749 private void createUserTv(UserTvDTO userTvDTO){
750 UserTv userTv = new UserTv();
751 BeanUtils.copyProperties(userTvDTO, userTv);
752 this.userTvService.create(userTv);
753 }
754 } 949 }
......
...@@ -39,21 +39,25 @@ public class MemberProfileOperationServiceImpl implements MemberProfileOperation ...@@ -39,21 +39,25 @@ public class MemberProfileOperationServiceImpl implements MemberProfileOperation
39 * @param resource 39 * @param resource
40 */ 40 */
41 public void asyncCreateMemberProfileAndSyncMember(MemberProfileDTO resource) { 41 public void asyncCreateMemberProfileAndSyncMember(MemberProfileDTO resource) {
42 log.info("创建会员属性，参数 ==>> {}", resource); 42 log.info("保存会员以及会员属性，参数 asyncCreateMemberProfileAndSyncMember# resource ==>> {}", resource);
43
43 String memberCode = resource.getMemberCode(); 44 String memberCode = resource.getMemberCode();
44 if (StringUtils.isBlank(memberCode)) { 45 if (StringUtils.isBlank(memberCode)) {
45 log.error("创建会员属性失败，会员code不存在"); 46 log.error("保存会员以及会员属性异常，asyncCreateMemberProfileAndSyncMember# message ==>> 会员code不存在");
46 return; 47 return;
47 } 48 }
48 49
49 MemberDTO memberDTO = this.memberService.findByCode(memberCode); 50 MemberDTO memberDTO = this.memberService.findByCode(memberCode);
51 log.info("保存会员以及会员属性，asyncCreateMemberProfileAndSyncMember# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", memberCode, memberDTO);
52
50 if (Objects.isNull(memberDTO.getId())) { 53 if (Objects.isNull(memberDTO.getId())) {
51 log.error("创建会员属性失败，会员信息不存在 ==>> memberCode ==>> {}", memberCode); 54 log.error("保存会员以及会员属性失败，asyncCreateMemberProfileAndSyncMember# message ==>> 会员信息不存在 || memberCode ==>> {}", memberCode);
52 return; 55 return;
53 } 56 }
54 57
55 Long memberId = memberDTO.getId(); 58 Long memberId = memberDTO.getId();
56 MemberProfileDTO _memberProfileDTO = this.memberProfileService.findByMemberId(memberId); 59 MemberProfileDTO _memberProfileDTO = this.memberProfileService.findByMemberId(memberId);
60 log.info("保存会员以及会员属性，asyncCreateMemberProfileAndSyncMember# 通过会员id ==>> {}，查询会员属性信息，结果集，_memberProfileDTO ==>> {}", memberId, _memberProfileDTO);
57 61
58 if (Objects.isNull(_memberProfileDTO.getId())) { 62 if (Objects.isNull(_memberProfileDTO.getId())) {
59 63
...@@ -61,6 +65,8 @@ public class MemberProfileOperationServiceImpl implements MemberProfileOperation ...@@ -61,6 +65,8 @@ public class MemberProfileOperationServiceImpl implements MemberProfileOperation
61 BeanUtils.copyProperties(resource, memberProfile); 65 BeanUtils.copyProperties(resource, memberProfile);
62 memberProfile.setId(null); 66 memberProfile.setId(null);
63 memberProfile.setMemberId(memberId); 67 memberProfile.setMemberId(memberId);
68
69 log.info("保存会员以及会员属性，asyncCreateMemberProfileAndSyncMember# 保存会员属性，入库参数，memberProfile ==>> {}", memberProfile);
64 this.memberProfileService.createDefault(memberProfile); 70 this.memberProfileService.createDefault(memberProfile);
65 71
66 Member member = new Member(); 72 Member member = new Member();
...@@ -69,56 +75,60 @@ public class MemberProfileOperationServiceImpl implements MemberProfileOperation ...@@ -69,56 +75,60 @@ public class MemberProfileOperationServiceImpl implements MemberProfileOperation
69 member.setAvatarUrl(memberProfile.getAvatarUrl()); 75 member.setAvatarUrl(memberProfile.getAvatarUrl());
70 member.setNickname(memberProfile.getRealname()); 76 member.setNickname(memberProfile.getRealname());
71 member.setGender(memberProfile.getGender()); 77 member.setGender(memberProfile.getGender());
78
79 log.info("保存会员以及会员属性，asyncCreateMemberProfileAndSyncMember# 更新会员头像、昵称、性别，入库参数，member ==>> {}", member);
72 this.memberService.doUpdateMemberAvatarUrlAndNicknameAndGender(member); 80 this.memberService.doUpdateMemberAvatarUrlAndNicknameAndGender(member);
73 } 81 }
74 82
75 } 83 }
76 84
77 85
78 /**
79 *
80 * @param resources
81 */
82 public void asyncUpdateMemberProfileAndSyncMember(MemberProfileAndMemberDTO resources) { 86 public void asyncUpdateMemberProfileAndSyncMember(MemberProfileAndMemberDTO resources) {
83 log.info("修改会员属性，参数 ==>> {}", resources); 87 log.info("修改会员属性，参数 asyncUpdateMemberProfileAndSyncMember# resource ==>> {}", resources);
84 88
85 MemberProfileDTO memberProfileDTO = resources.getMemberProfileDTO(); 89 MemberProfileDTO memberProfileDTO = resources.getMemberProfileDTO();
86 if (Objects.isNull(memberProfileDTO)) { 90 if (Objects.isNull(memberProfileDTO)) {
87 log.error("修改会员属性异常, 会员属性参数为空"); 91 log.error("修改会员属性异常，asyncUpdateMemberProfileAndSyncMember# message ==>> 会员属性不得为空");
88 return; 92 return;
89 } 93 }
90 94
91 MemberDTO memberDTO = resources.getMemberDTO(); 95 MemberDTO memberDTO = resources.getMemberDTO();
92 if (Objects.isNull(memberDTO)) { 96 if (Objects.isNull(memberDTO)) {
93 log.error("修改会员属性异常, 会员信息为空"); 97 log.error("修改会员属性异常，asyncUpdateMemberProfileAndSyncMember# message ==>> 会员信息不得为空");
94 return; 98 return;
95 } 99 }
96 100
97 MemberProfileDTO _memberProfileDTO = this.asyncMemberProfile(memberProfileDTO); 101 MemberProfileDTO _memberProfileDTO = this.asyncMemberProfile(memberProfileDTO);
102 log.info("修改会员属性，asyncUpdateMemberProfileAndSyncMember# 结果集，_memberProfileDTO ==>> {}", _memberProfileDTO);
103
98 String code = memberDTO.getCode(); 104 String code = memberDTO.getCode();
99 if (!StringUtils.isEmpty(code)) { 105 if (!StringUtils.isEmpty(code)) {
100 MemberDTO memberDTO1 = this.memberService.findByCode(code); 106 MemberDTO memberDTO1 = this.memberService.findByCode(code);
107 log.info("修改会员属性，asyncUpdateMemberProfileAndSyncMember# 通过code ==>> {}，查询会员信息，结果集，memberDTO1 ==>> {}", code, memberDTO);
101 108
102 Member member = new Member(); 109 Member member = new Member();
103 member.setId(memberDTO1.getId()); 110 member.setId(memberDTO1.getId());
104 member.setNickname(_memberProfileDTO.getRealname()); 111 member.setNickname(_memberProfileDTO.getRealname());
105 member.setBirthday(_memberProfileDTO.getBirthday()); 112 member.setBirthday(_memberProfileDTO.getBirthday());
106 member.setGender(_memberProfileDTO.getGender()); 113 member.setGender(_memberProfileDTO.getGender());
114
115 log.info("修改会员属性，asyncUpdateMemberProfileAndSyncMember# 入库参数，member ==>> {}", member);
107 this.memberService.doUpdateMemberAvatarUrlAndNicknameAndGender(member); 116 this.memberService.doUpdateMemberAvatarUrlAndNicknameAndGender(member);
108 } 117 }
109 } 118 }
110 119
111 public MemberProfileDTO asyncMemberProfile(MemberProfileDTO memberProfileDTO){ 120 public MemberProfileDTO asyncMemberProfile(MemberProfileDTO resource){
112 String memberCode = memberProfileDTO.getMemberCode(); 121 log.info("修改会员属性，参数 asyncMemberProfile# resource ==>> {}", resource);
122 String memberCode = resource.getMemberCode();
113 MemberDTO memberDTO = this.memberService.findByCode(memberCode); 123 MemberDTO memberDTO = this.memberService.findByCode(memberCode);
114 Long memberId = memberDTO.getId(); 124 Long memberId = memberDTO.getId();
115 125
116 MemberProfileDTO _memberProfileDTO = this.memberProfileService.findByMemberId(memberId); 126 MemberProfileDTO _memberProfileDTO = this.memberProfileService.findByMemberId(memberId);
117 memberProfileDTO.setId(_memberProfileDTO.getId()); 127 resource.setId(_memberProfileDTO.getId());
118 memberProfileDTO.setMemberId(memberId); 128 resource.setMemberId(memberId);
119 129
120 MemberProfile memberProfile = new MemberProfile(); 130 MemberProfile memberProfile = new MemberProfile();
121 BeanUtils.copyProperties(memberProfileDTO, memberProfile); 131 BeanUtils.copyProperties(resource, memberProfile);
122 return this.memberProfileService.update(memberProfile); 132 return this.memberProfileService.update(memberProfile);
123 } 133 }
124 134
......
1 package com.topdraw.business.process.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.module.user.weixin.collection.domain.UserCollectionDetail;
5 import com.topdraw.business.process.domian.weixin.UserCollectionMq;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.Mapping;
8 import org.mapstruct.Mappings;
9 import org.mapstruct.ReportingPolicy;
10
11 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
12 public interface CollectionMq2DetailMapper extends BaseMapper<UserCollectionMq, UserCollectionDetail> {
13 @Override
14 @Mappings({
15 @Mapping(target = "detailImg", source = "images")
16 })
17 UserCollectionDetail toEntity(UserCollectionMq dto);
18 }