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
package com.topdraw.business.process.domian;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.Transient;
import java.sql.Timestamp;
/**
* 权益-非持久化数据
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TempCoupon extends TempRights {
@Transient
protected String code;
@Transient
protected Integer useStatus;
@Transient
protected Timestamp useTime;
/**领取时间*/
@Transient
protected Timestamp receiveTime;
@Transient
protected String userNickname;
}
package com.topdraw.business.process.domian;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.Transient;
/**
* 权益-非持久化数据
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TempExp extends TempRights {
// 获得成长值
@Transient
protected Long rewardExp;
}
package com.topdraw.business.process.domian;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.Transient;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TempIptvUser {
// 账户
@Transient
private String platformAccount;
// 分数
@Transient
private Long points;
}
package com.topdraw.business.process.domian;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
/**
* 权益-非持久化数据
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class TempPoints extends TempRights {
// 获得积分
@Transient
@NotNull(message = "【points】积分数值不得为空!!")
protected Long points;
// 积分类型 0:通用
@Transient
protected Integer pointsType;
@Transient
protected Long rewardPointsExpireTime;
}
package com.topdraw.business.process.domian;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
import java.time.LocalDateTime;
/**
* 权益-非持久化数据
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TempRights {
/** 主键 */
@Transient
protected Long id;
/** 编号 */
@Transient
protected String code;
/** 权益名称 */
@Transient
protected String name;
/** 会员ID */
@Transient
protected Long memberId;
/** 会员编号 */
@Transient
protected String memberCode;
/** 账号id */
@Transient
protected Long userId;
/** 发放策略 */
@Transient
protected Integer rightsSendStrategy;
/** 账号id */
@Transient
private Long accountId;
/** 过期时间 */
@Transient
protected LocalDateTime expireTime;
/** 设备类型 1：大屏；2：小屏（微信）3.小屏（xx） */
@Transient
@NotNull(message = "设备类型不得为空")
protected Integer deviceType;
/** 应用code(表示当前用户对应应用的标识) */
@Transient
protected String appCode;
/** 订单id */
@Transient
protected Long orderId;
/** 节目id（针对观影操作） */
@Transient
protected Long mediaId;
/** 活动id（针对参与活动） */
@Transient
protected Long activityId;
/** 商品id */
@Transient
protected Long itemId;
/** 积分变化描述，用于管理侧显示 */
@Transient
protected String description;
/** 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；98：系统操作；99：其他 */
@Transient
protected Integer evtType;
/** 数量 */
@Transient
protected Integer rightsAmount;
}
package com.topdraw.business.process.domian.weixin;
import com.alibaba.fastjson.annotation.JSONField;
import com.topdraw.annotation.Query;
import lombok.Data;
import java.sql.Timestamp;
@Data
public class UserCollectionMq {
// 应用ID
@JSONField(name = "app_id")
private Long appId;
@JSONField(name = "userId")
private Long userId;
// 收藏夹类型：1-收藏 2-播放记录 3-播放列表 4-评分 5-点赞/关注/订阅
private Integer type;
// 收藏夹名称
private String name;
// 数量
private Integer count;
private String images;
// 收藏夹ID
@JSONField(name = "user_collection_id")
@Query
private Long userCollectionId;
// 自定义收藏内容的类型CODE，默认：DEFAULT
@JSONField(name = "detail_folder_code")
@Query
private String detailFolderCode;
// 收藏内容的类型：MEDIA|EPISODE|CATEGORY|SUBJECT|ARTICLE|ARTIST|SCHOOL
@JSONField(name = "detail_type")
@Query
private String detailType;
// 收藏内容的ID
@JSONField(name = "detail_id")
@Query
private Long detailId;
// 收藏内容的CODE
@JSONField(name = "detail_code")
@Query
private String detailCode;
// 收藏内容的剧集ID
@JSONField(name = "detail_episode_id")
@Query
private Long detailEpisodeId;
// 收藏内容的剧集CODE
@JSONField(name = "detail_episode_code")
@Query
private String detailEpisodeCode;
// 收藏内容的名称
@JSONField(name = "detail_name")
@Query
private String detailName;
// 收藏内容的标记
@JSONField(name = "detail_mark")
@Query
private Integer detailMark;
// 收藏内容的图片
@JSONField(name = "detail_img")
private String detailImg;
// 收藏内容的剧集序号
@JSONField(name = "detail_index")
@Query
private Integer detailIndex;
// 收藏内容的剧集总数
@JSONField(name = "detail_total_index")
@Query
private Integer detailTotalIndex;
// 收藏内容的播放时间
@JSONField(name = "detail_play_time")
@Query
private Integer detailPlayTime;
// 收藏内容的总时间
@JSONField(name = "detail_total_time")
@Query
private Integer detailTotalTime;
// 收藏内容在同一folder中的顺序
@JSONField(name = "detail_sequence")
@Query
private Integer detailSequence;
// 收藏内容的评分
@JSONField(name = "detail_score")
@Query
private Float detailScore;
// 收藏内容（根据文件夹和类型的不同）的点赞/关注/订阅
@JSONField(name = "detail_like")
@Query
private Integer detailLike;
// 收藏内容的扩展数据
@JSONField(name = "detail_ext_data")
@Query
private String detailExtData;
// 创建时间
@JSONField(name = "create_time")
@Query
private Timestamp createTime;
// 更新时间
@JSONField(name = "update_time")
private Timestamp updateTime;
}
package com.topdraw.business.process.service;
import com.topdraw.business.process.domian.TempExp;
import java.util.List;
/**
* @description 权益操作接口
......
package com.topdraw.business.process.service.domian;
public enum RightType {
/**积分*/
POINTS,
/**成长值*/
EXP,
/**优惠券券*/
COUPON,
/**权益统称*/
RIGHTS
}
package com.topdraw.business.process.service.domian;
import com.topdraw.business.process.domian.TempRights;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.Transient;
import java.sql.Timestamp;
/**
* 权益-非持久化数据
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TempCoupon extends TempRights {
@Transient
protected String code;
@Transient
protected Integer useStatus;
@Transient
protected Timestamp useTime;
/**领取时间*/
@Transient
protected Timestamp receiveTime;
@Transient
protected String userNickname;
}
package com.topdraw.business.process.service.domian;
import com.topdraw.business.process.domian.TempIptvUser;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TempCustomPointBean extends TempIptvUser {
/** 设备类型 1：大屏；2：小屏（微信）3.小屏（xx） */
@Transient
@NotNull(message = "设备类型不得为空")
protected Integer deviceType;
/** 订单id */
@Transient
protected Long orderId;
/** 节目id（针对观影操作） */
@Transient
protected Long mediaId;
/** 活动id（针对参与活动） */
@Transient
protected Long activityId;
/** 商品id */
@Transient
protected Long itemId;
/** 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；98：系统操作；99：其他 */
@Transient
protected Integer evtType;
}
package com.topdraw.business.process.service.domian;
import com.topdraw.business.process.domian.TempRights;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.Transient;
/**
* 权益-非持久化数据
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TempExp extends TempRights {
// 获得成长值
@Transient
protected Long rewardExp;
}
package com.topdraw.business.process.service.domian;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.Transient;
import java.sql.Timestamp;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TempIptvUser {
private String unionid;
// 账户
@Transient
private String platformAccount;
// 分数
@Transient
private Long points;
// ID
private Long id;
// 人ID
private Long personId;
// 运营商平台
private String platform;
// 手机号
private String cellphone;
// 用户名
private String username;
// 密码 MD5
private String password;
// 昵称 Base64
private String nickname;
// 头像
private String image;
// 登录天数（总天数）
private Integer loginDays;
// 连续登录天数
private Integer continueDays;
// 活跃时间
private Timestamp activeTime;
// 分组 分组ID用逗号分隔
private String groups;
// 标签 标签用逗号分隔
private String tags;
// 登录类型 1-运营商隐式登录 2-手机验证登录 3-微信登录 4-QQ登录 5-微博登录 6-苹果登录
private Integer loginType;
// 状态 0-下线 1-上线
private Integer status;
// 描述
private String description;
// 创建者
private String createBy;
// 创建时间
private Timestamp createTime;
// 更新者
private String updateBy;
// 更新时间
private Timestamp updateTime;
// 会员id
private Long memberId;
private String memberCode;
}
package com.topdraw.business.process.service.domian;
import com.topdraw.business.process.domian.TempRights;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
/**
* 权益-非持久化数据
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class TempPoints extends TempRights {
// 获得积分
@Transient
@NotNull(message = "【points】积分数值不得为空!!")
protected Long points;
// 积分类型 0:通用
@Transient
protected Integer pointsType;
@Transient
protected Long rewardPointsExpireTime;
}
package com.topdraw.business.process.service.domian;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
import java.time.LocalDateTime;
/**
* 权益-非持久化数据
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TempRights {
/** 主键 */
@Transient
protected Long id;
/** 编号 */
@Transient
protected String code;
/** 权益名称 */
@Transient
protected String name;
/** 会员ID */
@Transient
protected Long memberId;
/** 会员编号 */
@Transient
protected String memberCode;
/** 账号id */
@Transient
protected Long userId;
/** 发放策略 */
@Transient
protected Integer rightsSendStrategy;
/** 账号id */
@Transient
protected Long accountId;
/** 过期时间 */
@Transient
protected LocalDateTime expireTime;
/** 设备类型 1：大屏；2：小屏（微信）3.小屏（xx） */
@Transient
@NotNull(message = "设备类型不得为空")
protected Integer deviceType;
/** 应用code(表示当前用户对应应用的标识) */
@Transient
protected String appCode;
/** 订单id */
@Transient
protected Long orderId;
/** 节目id（针对观影操作） */
@Transient
protected Long mediaId;
/** 活动id（针对参与活动） */
@Transient
protected Long activityId;
/** 商品id */
@Transient
protected Long itemId;
/** 积分变化描述，用于管理侧显示 */
@Transient
protected String description;
/** 行为事件类型 1：登录；2：观影；3：参与活动；4：订购；10：跨屏绑定；11：积分转移；98：系统操作；99：其他 */
@Transient
protected Integer evtType;
/** 数量 */
@Transient
protected Integer rightsAmount;
}
package com.topdraw.business.process.service.domian;
public interface UnbindGroup {
}
package com.topdraw.business.process.service.domian.result;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CustomPointsResult {
private boolean result;
private Long point;
}
package com.topdraw.business.process.service.domian.result;
public interface TaskTemplateType {
int TYPE_1 = 1;
int TYPE_2 = 2;
int TYPE_3 = 3;
int TYPE_4 = 4;
}
package com.topdraw.business.process.service.domian.weixin;
import lombok.Data;
@Data
public class BindBean extends WeiXinUserBean {
private Long platformUserId;
private String platformAccount;
}
package com.topdraw.business.process.service.domian.weixin;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 微信账户信息
* @author XiangHan
* @date 2021-01-18
*/
@Data
public class BuyVipBean extends WeiXinUserBean {
private Integer vip;
@JsonFormat(shape = JsonFormat.Shape.STRING,pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime vipExpireTime;
}
package com.topdraw.business.process.service.domian.weixin;
import com.alibaba.fastjson.JSONObject;
import lombok.Data;
@Data
public class SubscribeBean extends WeiXinUserBean {
private JSONObject userInfoJson;
private JSONObject iptvUserInfo;
private String msgType;
private String event;
/** */
private String openId;
/** */
private String appId;
/** */
private String eventKey;
private String unionid;
private String nickname;
private String headimgurl;
}
package com.topdraw.business.process.service.domian.weixin;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SubscribeBeanEvent {
@NotNull(message = "【content】 not be null !!!")
private String content;
}
package com.topdraw.business.process.service.domian.weixin;
import com.alibaba.fastjson.annotation.JSONField;
import com.topdraw.annotation.Query;
import lombok.Data;
import java.sql.Timestamp;
@Data
public class UserCollectionMq {
// 应用ID
@JSONField(name = "app_id")
private Long appId;
@JSONField(name = "userId")
private Long userId;
// 收藏夹类型：1-收藏 2-播放记录 3-播放列表 4-评分 5-点赞/关注/订阅
private Integer type;
// 收藏夹名称
private String name;
// 数量
private Integer count;
private String images;
// 收藏夹ID
@JSONField(name = "user_collection_id")
@Query
private Long userCollectionId;
// 自定义收藏内容的类型CODE，默认：DEFAULT
@JSONField(name = "detail_folder_code")
@Query
private String detailFolderCode;
// 收藏内容的类型：MEDIA|EPISODE|CATEGORY|SUBJECT|ARTICLE|ARTIST|SCHOOL
@JSONField(name = "detail_type")
@Query
private String detailType;
// 收藏内容的ID
@JSONField(name = "detail_id")
@Query
private Long detailId;
// 收藏内容的CODE
@JSONField(name = "detail_code")
@Query
private String detailCode;
// 收藏内容的剧集ID
@JSONField(name = "detail_episode_id")
@Query
private Long detailEpisodeId;
// 收藏内容的剧集CODE
@JSONField(name = "detail_episode_code")
@Query
private String detailEpisodeCode;
// 收藏内容的名称
@JSONField(name = "detail_name")
@Query
private String detailName;
// 收藏内容的标记
@JSONField(name = "detail_mark")
@Query
private Integer detailMark;
// 收藏内容的图片
@JSONField(name = "detail_img")
private String detailImg;
// 收藏内容的剧集序号
@JSONField(name = "detail_index")
@Query
private Integer detailIndex;
// 收藏内容的剧集总数
@JSONField(name = "detail_total_index")
@Query
private Integer detailTotalIndex;
// 收藏内容的播放时间
@JSONField(name = "detail_play_time")
@Query
private Integer detailPlayTime;
// 收藏内容的总时间
@JSONField(name = "detail_total_time")
@Query
private Integer detailTotalTime;
// 收藏内容在同一folder中的顺序
@JSONField(name = "detail_sequence")
@Query
private Integer detailSequence;
// 收藏内容的评分
@JSONField(name = "detail_score")
@Query
private Float detailScore;
// 收藏内容（根据文件夹和类型的不同）的点赞/关注/订阅
@JSONField(name = "detail_like")
@Query
private Integer detailLike;
// 收藏内容的扩展数据
@JSONField(name = "detail_ext_data")
@Query
private String detailExtData;
// 创建时间
@JSONField(name = "create_time")
@Query
private Timestamp createTime;
// 更新时间
@JSONField(name = "update_time")
private Timestamp updateTime;
}
package com.topdraw.business.process.service.domian.weixin;
import lombok.Data;
/**
* 微信账户信息
* @author XiangHan
* @date 2021-01-18
*/
@Data
public class WeiXinUserBean {
private Long id;
private String unionid;
/** */
private String openid;
/** */
private String appid;
/** 加密后的appId，参数 */
private String wxAppid;
/** 加密后的code，参数 */
private String wxCode;
/** */
private String userInfo;
/** 会员id */
private Long memberId;
/** 加密信息 */
private String encryptedData;
/** 解析用户电话号码时使用，参数 */
private String iv;
/** 资源id */
private String sourceId;
/** 资源类型 */
private String sourceType;
/** 资源描述，用来表示从哪个地方链接进来的 */
private String sourceDesc;
/** 资源实例 */
private String sourceEntity;
/** 推荐者id */
private Long sourceUser;
private String nikename;
private String headimgurl;
}
package com.topdraw.business.process.service.impl;
import com.topdraw.business.module.member.service.dto.MemberDTO;
import com.topdraw.business.module.task.domain.Task;
import java.util.List;
@FunctionalInterface
public interface CompareTaskCondition {
boolean compareCondition(MemberDTO memberDTO, List<Task> taskList);
}
......@@ -17,8 +17,6 @@ public class CouponOperationServiceImpl implements CouponOperationService {
@Autowired
private CouponHistoryService couponHistoryService;
@Autowired
private MemberOperationService memberOperationService;
@Autowired
private MemberService memberService;
public void asyncMemberCoupon(Member member) {
......
......@@ -3,43 +3,66 @@ package com.topdraw.business.process.service.impl;
import com.topdraw.business.module.exp.detail.domain.ExpDetail;
import com.topdraw.business.module.exp.detail.service.ExpDetailService;
import com.topdraw.business.module.member.domain.Member;
import com.topdraw.business.module.member.level.service.MemberLevelService;
import com.topdraw.business.module.member.service.MemberService;
import com.topdraw.business.module.member.service.dto.MemberDTO;
import com.topdraw.business.process.service.ExpOperationService;
import com.topdraw.business.process.service.member.MemberOperationService;
import com.topdraw.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import java.util.Objects;
/**
*
*/
@Service
@Slf4j
public class ExpOperationServiceImpl implements ExpOperationService {
@Autowired
private ExpDetailService expDetailService;
@Autowired
private MemberService memberService;
@Autowired
private ExpDetailService expDetailService;
public void asyncMemberExpAndLevel(Member resource) {
log.info("同步会员成长值和等级，参数 asyncMemberExpAndLevel# resource ==>> {}", resource);
String code = resource.getCode();
if (StringUtils.isBlank(code)) {
log.error("同步会员成长值和等级异常，asyncMemberExpAndLevel# message ==>> 会员code不得为空");
return;
}
public void asyncMemberExpAndLevel(Member member) {
String code = member.getCode();
MemberDTO memberDTO = this.memberService.findByCode(code);
member.setId(memberDTO.getId());
log.info("同步会员成长值和等级，asyncMemberExpAndLevel# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", code, memberDTO);
resource.setId(memberDTO.getId());
log.info("同步会员成长值和等级，asyncMemberExpAndLevel# 入库参数，resource ==>> {}", resource);
this.memberService.doUpdateMemberExpAndLevel(resource);
}
this.memberService.doUpdateMemberExpAndLevel(member);
public void asyncExpDetail(ExpDetail resource) {
log.info("同步会员成长值详情，参数 asyncExpDetail# resource ==>> {}", resource);
String code = resource.getMemberCode();
if (StringUtils.isBlank(code)) {
log.error("同步会员成长值和等级异常，asyncExpDetail# message ==>> 会员code不得为空");
return;
}
public void asyncExpDetail(ExpDetail expDetail) {
String code = expDetail.getMemberCode();
MemberDTO memberDTO = this.memberService.findByCode(code);
if (Objects.nonNull(memberDTO.getId())) {
expDetail.setMemberId(memberDTO.getId());
this.expDetailService.create(expDetail);
log.info("同步会员成长值详情，asyncExpDetail# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", code, memberDTO);
if (Objects.isNull(memberDTO.getId())) {
log.error("同步会员成长值详情，asyncExpDetail# message ==>> 会员");
return;
}
resource.setMemberId(memberDTO.getId());
log.info("同步会员成长值详情，asyncExpDetail# 入库参数，resource ==>> {}", resource);
this.expDetailService.create(resource);
}
}
......
......@@ -13,7 +13,6 @@ import com.topdraw.business.process.service.PointsOperationService;
import com.topdraw.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
......@@ -29,49 +28,92 @@ import java.util.*;
public class PointsOperationServiceImpl implements PointsOperationService {
@Autowired
private MemberService memberService;
@Autowired
private PointsDetailService pointsDetailService;
@Autowired
private PointsAvailableService pointsAvailableService;
@Autowired
private MemberService memberService;
@Autowired
ThreadPoolTaskExecutor threadPoolTaskExecutor;
public void asyncMemberPoint(Member member) {
log.info("修改会员积分,参数 =>> {}", member);
String code = member.getCode();
public void asyncMemberPoint(Member resource) {
log.info("同步会员积分，参数 asyncMemberPoint# resource ==>> {}", resource);
String code = resource.getCode();
if (StringUtils.isBlank(code)) {
log.error("修改会员积分失败，参数错误，会员code为空");
log.error("同步会员积分异常，asyncMemberPoint# message ==>> 会员code不得为空");
return;
}
MemberDTO memberDTO = this.memberService.findByCode(code);
if (Objects.nonNull(memberDTO.getId())) {
member.setId(memberDTO.getId());
this.memberService.doUpdateMemberPoints(member);
log.info("同步会员积分，asyncMemberPoint# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", code, memberDTO);
if (Objects.isNull(memberDTO.getId())) {
log.error("同步会员积分异常，asyncMemberPoint# message ==>> 会员信息不存在");
return;
}
resource.setId(memberDTO.getId());
log.info("同步会员积分，asyncMemberPoint# 入库参数， resource ==>> {}", resource);
this.memberService.doUpdateMemberPoints(resource);
}
public void asyncPointsAvailable(PointsAvailable resource) {
log.info("同步会员可用积分，参数 asyncPointsAvailable# resource ==>> {}", resource);
String memberCode = resource.getMemberCode();
if (StringUtils.isBlank(memberCode)) {
log.error("同步会员可用积分异常，asyncPointsAvailable# message ==>> 会员code不得为空");
return;
}
public void asyncPointsAvailable(PointsAvailable pointsAvailable) {
String memberCode = pointsAvailable.getMemberCode();
MemberDTO memberDTO = this.memberService.findByCode(memberCode);
if (Objects.nonNull(memberDTO.getId())) {
pointsAvailable.setMemberId(memberDTO.getId());
this.pointsAvailableService.create4Custom(pointsAvailable);
log.info("同步会员可用积分，asyncPointsAvailable# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", memberCode, memberDTO);
if (Objects.isNull(memberDTO.getId())) {
log.error("同步会员可用积分异常，asyncPointsAvailable# message ==>> 会员信息不存在 || code ==>> {}", memberCode);
return;
}
resource.setMemberId(memberDTO.getId());
log.info("同步会员可用积分，asyncPointsAvailable# 入库参数， resource ==>> {}", resource);
this.pointsAvailableService.create4Custom(resource);
}
public void asyncPointsDetail(PointsDetail resource) {
log.info("同步会员积分流水，参数 asyncPointsDetail# resource ==>> {}", resource);
String memberCode = resource.getMemberCode();
if (StringUtils.isBlank(memberCode)) {
log.error("同步会员积分流水异常，asyncPointsDetail# message ==>> 会员code不得为空");
return;
}
public void asyncPointsDetail(PointsDetail pointsDetail) {
String memberCode = pointsDetail.getMemberCode();
MemberDTO memberDTO = this.memberService.findByCode(memberCode);
log.info("同步会员积分流水，asyncPointsDetail# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", memberCode, memberDTO);
if (Objects.nonNull(memberDTO.getId())) {
pointsDetail.setMemberId(memberDTO.getId());
this.pointsDetailService.create4Custom(pointsDetail);
log.error("同步会员积分流水异常，asyncPointsDetail# message ==>> 会员信息不存在 || code ==>> {}", memberCode);
return;
}
resource.setMemberId(memberDTO.getId());
log.info("同步会员积分流水，asyncPointsDetail# 入库参数， resource ==>> {}", resource);
this.pointsDetailService.create4Custom(resource);
}
public void asyncDeletePointsAvailable(PointsAvailable resource) {
log.info("同步删除会员可用积分，参数 asyncDeletePointsAvailable# resource ==>> {}", resource);
String code = resource.getCode();
if (StringUtils.isBlank(code)) {
log.error("同步删除会员可用积分异常，asyncDeletePointsAvailable# message ==>> 可用积分code不得为空");
return;
}
public void asyncDeletePointsAvailable(PointsAvailable pointsAvailable) {
String code = pointsAvailable.getCode();
PointsAvailableDTO pointsAvailableDTO = this.pointsAvailableService.getByCode(code);
log.info("同步会员积分流水，asyncPointsDetail# 通过code ==>> {}，查询会员可用积分，结果集，pointsAvailableDTO ==>> {}", code, pointsAvailableDTO);
log.info("同步会员积分流水，asyncPointsDetail# 删除可用积分，入库参数，pointsAvailableDTO ==>> {}", pointsAvailableDTO);
this.pointsAvailableService.delete(pointsAvailableDTO.getId());
}
}
......
package com.topdraw.business.process.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.topdraw.business.module.task.attribute.domain.TaskAttr;
import com.topdraw.business.module.task.attribute.service.TaskAttrService;
import com.topdraw.business.module.task.attribute.service.dto.TaskAttrDTO;
......
......@@ -5,7 +5,6 @@ import com.topdraw.business.module.task.template.service.TaskTemplateService;
import com.topdraw.business.module.task.template.service.dto.TaskTemplateDTO;
import com.topdraw.business.process.service.TaskTemplateOperationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
......@@ -29,27 +28,14 @@ public class TaskTemplateOperationServiceImpl implements TaskTemplateOperationSe
private TaskTemplateService taskTemplateService;
public void asyncCreate(TaskTemplate resources) {
this.create(resources);
}
public void asyncUpdate(TaskTemplate resources) {
this.update(resources);
}
public void asyncDelete(TaskTemplate resources) {
this.delete(resources);
}
private void create(TaskTemplate resources) {
String code = resources.getCode();
TaskTemplateDTO taskTemplateDTO = this.findByCode(code);
if (Objects.isNull(taskTemplateDTO.getId())) {
this.taskTemplateService.create(resources);
}
}
private void update(TaskTemplate resources) {
public void asyncUpdate(TaskTemplate resources) {
String code = resources.getCode();
TaskTemplateDTO taskTemplateDTO = this.findByCode(code);
if (Objects.nonNull(taskTemplateDTO.getId())) {
......@@ -59,7 +45,7 @@ public class TaskTemplateOperationServiceImpl implements TaskTemplateOperationSe
}
}
private void delete(TaskTemplate resources) {
public void asyncDelete(TaskTemplate resources) {
String code = resources.getCode();
TaskTemplateDTO taskTemplateDTO = this.findByCode(code);
if (Objects.nonNull(taskTemplateDTO.getId())) {
......@@ -68,21 +54,11 @@ public class TaskTemplateOperationServiceImpl implements TaskTemplateOperationSe
}
}
private void delete(Long id) {
TaskTemplateDTO taskTemplateDTO = this.findById(id);
this.taskTemplateService.delete(id);
TaskTemplate taskTemplate = new TaskTemplate();
BeanUtils.copyProperties(taskTemplateDTO, taskTemplate);
taskTemplate.setDeleteMark(1);
}
@Override
public TaskTemplateDTO findByCode(String code) {
return this.taskTemplateService.findByCode(code);
}
private TaskTemplateDTO findById(Long id) {
return this.taskTemplateService.findById(id);
}
......
......@@ -2,23 +2,17 @@ package com.topdraw.business.process.service.impl;
import com.topdraw.business.module.member.domain.Member;
import com.topdraw.business.module.member.domain.MemberBuilder;
import com.topdraw.business.module.member.domain.MemberTypeConstant;
import com.topdraw.business.module.member.profile.domain.MemberProfile;
import com.topdraw.business.module.member.profile.service.MemberProfileService;
import com.topdraw.business.module.member.profile.service.dto.MemberProfileDTO;
import com.topdraw.business.module.member.service.MemberService;
import com.topdraw.business.module.member.service.dto.MemberDTO;
import com.topdraw.business.module.user.app.domain.UserApp;
import com.topdraw.business.module.user.app.domain.UserAppBind;
import com.topdraw.business.module.user.app.domain.UserAppBindBuilder;
import com.topdraw.business.module.user.app.domain.UserAppBuilder;
import com.topdraw.business.module.user.app.service.UserAppBindService;
import com.topdraw.business.module.user.app.service.UserAppService;
import com.topdraw.business.module.user.app.service.dto.AppRegisterDTO;
import com.topdraw.business.module.user.app.service.dto.UserAppBindDTO;
import com.topdraw.business.module.user.app.service.dto.UserAppDTO;
import com.topdraw.business.module.user.app.service.dto.UserAppSimpleDTO;
import com.topdraw.business.module.user.iptv.domain.UserTv;
import com.topdraw.business.module.user.iptv.growreport.domain.GrowthReport;
import com.topdraw.business.module.user.iptv.growreport.service.GrowthReportService;
......@@ -33,10 +27,8 @@ import com.topdraw.business.process.service.dto.MemberAndUserTvDTO;
import com.topdraw.business.process.service.dto.MemberAndWeixinUserDTO;
import com.topdraw.exception.EntityNotFoundException;
import com.topdraw.exception.GlobeExceptionMsg;
import com.topdraw.util.TimestampUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
......@@ -56,95 +48,162 @@ public class UserOperationServiceImpl implements UserOperationService {
@Autowired
private UserTvService userTvService;
@Autowired
private UserAppService userAppService;
@Autowired
private UserWeixinService userWeixinService;
@Autowired
private MemberProfileService memberProfileService;
private UserAppBindService userAppBindService;
@Autowired
private GrowthReportService growthReportService;
@Autowired
private UserAppService userAppService;
@Autowired
private UserAppBindService userAppBindService;
private MemberProfileService memberProfileService;
public void asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg(UserAppDTO resources) {
log.info("修改app昵称、头像和最后活跃时间，参数 asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# resources ==>> {}", resources);
if (StringUtils.isBlank(resources.getUsername())) {
log.error("修改app昵称、头像和最后活跃时间异常，asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# message ==>> username不得为空");
return;
}
UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername());
log.info("修改app昵称、头像和最后活跃时间，通过账号获取app账号信息结果，asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# userAppDTO ==>> {}", userAppDTO);
if (Objects.isNull(userAppDTO.getId())) {
log.error("修改app昵称、头像和最后活跃时间异常，asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# message ==>> app账号信息不存在 || username ==>> {}", resources.getUsername());
return;
}
UserApp userApp = new UserApp();
userApp.setId(userAppDTO.getId());
userApp.setUsername(userAppDTO.getUsername());
userApp.setNickname(resources.getNickname());
userApp.setHeadimgurl(resources.getHeadimgurl());
log.info("修改app昵称、头像和最后活跃时间，入库参数，asyncUpdateAppLastActiveTimeAndNicknameAndHeadImg# userApp ==>> {}", userApp);
this.userAppService.updateAppLastActiveTimeAndNicknameAndHeadImg(userApp);
}
}
public void asyncCancelUserAppBind(UserAppBindDTO resources) {
// TODO 取消关联第三方账号，暂不用同步至大屏
}
public void asyncUpdatePasswordByUsername(UserAppDTO resources) {
log.info("修改app密码，参数 asyncUpdatePasswordByUsername# resources ==>> {}", resources);
if (StringUtils.isBlank(resources.getUsername())) {
log.error("修改app密码异常，asyncUpdatePasswordByUsername# message ==>> username不得为空");
return;
}
UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername());
log.info("修改app密码，通过账号获取app账号信息结果，asyncUpdatePasswordByUsername# userAppDTO ==>> {}", userAppDTO);
if (Objects.isNull(userAppDTO.getId())) {
log.error("修改app密码异常，asyncUpdatePasswordByUsername# message ==>> app账号信息不存在 || username ==>> {}", resources.getUsername());
return;
}
UserApp userApp = new UserApp();
userApp.setId(userAppDTO.getId());
userApp.setPassword(resources.getPassword());
log.info("修改app密码，入库参数，asyncUpdatePasswordByUsername# userApp ==>> {}", userApp);
this.userAppService.updatePasswordById(userApp);
}
}
public void asyncUpdateAppInfo(UserAppDTO resources) {
log.info("修改app账号信息，参数 asyncUpdateAppInfo# resources ==>> {}", resources);
if (StringUtils.isBlank(resources.getUsername())) {
log.error("修改app账号信息异常，asyncUpdateAppInfo# message ==>> username不得为空");
return;
}
UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername());
if (Objects.nonNull(userAppDTO.getId())) {
log.info("修改app账号信息，通过账号获取app账号信息结果，asyncUpdateAppInfo# userAppDTO ==>> {}", userAppDTO);
if (Objects.isNull(userAppDTO.getId())) {
log.error("修改app账号信息异常，asyncUpdateAppInfo# message ==>> app账号信息不存在 || username ==>> {}", resources.getUsername());
return;
}
UserApp userApp = new UserApp();
BeanUtils.copyProperties(resources, userApp);
userApp.setId(userAppDTO.getId());
log.info("修改app账号信息，入库参数，asyncUpdateAppInfo# userApp ==>> {}", userApp);
this.userAppService.updateAppInfo(userApp);
}
}
public void asyncAppCancellation(UserAppDTO resources) {
log.info("注销app账号，参数 asyncAppCancellation# resources ==>> {}", resources);
if (StringUtils.isBlank(resources.getUsername())) {
log.error("注销app账号异常，asyncAppCancellation# message ==>> username不得为空");
return;
}
UserAppDTO userAppDTO = this.userAppService.findByUsername(resources.getUsername());
if (Objects.nonNull(userAppDTO.getId())) {
this.userAppService.appCancellation(userAppDTO.getId());
log.info("注销app账号信息，通过账号获取app账号信息结果，asyncAppCancellation# userAppDTO ==>> {}", userAppDTO);
if (Objects.isNull(userAppDTO.getId())) {
log.error("注销app账号信息异常，asyncAppCancellation# message ==>> app账号信息不存在 || username ==>> {}", resources.getUsername());
return;
}
log.info("注销app账号信息，入库参数，asyncAppCancellation# userAppDTO ==>> {}", userAppDTO);
this.userAppService.appCancellation(userAppDTO.getId());
}
public void asyncAppRegister(AppRegisterDTO appRegisterDTO) {
UserAppDTO userAppDTOResources = appRegisterDTO.getUserAppDTO();
MemberDTO memberDTOResources = appRegisterDTO.getMemberDTO();
public void asyncAppRegister(AppRegisterDTO resources) {
log.info("注册app账号，参数 asyncAppRegister# resources ==>> {}", resources);
UserAppDTO userAppDTOResources = resources.getUserAppDTO();
MemberDTO memberDTOResources = resources.getMemberDTO();
if (StringUtils.isBlank(userAppDTOResources.getUsername())) {
log.error("注册app账号异常，asyncAppRegister# message ==>> username不得为空");
return;
}
UserAppDTO userAppDTO = this.userAppService.findByUsername(userAppDTOResources.getUsername());
if (Objects.isNull(userAppDTO.getId())) {
log.info("注册app账号，通过账号获取app账号信息结果，asyncAppRegister# userAppDTO ==>> {}", userAppDTO);
if (Objects.nonNull(userAppDTO.getId())) {
log.error("注册app账号异常，asyncAppRegister# message ==>> app账号已存在 || userAppDTO ==>> {}", userAppDTO);
return;
}
// 先创建会员
// Member member = MemberBuilder.build(MemberTypeConstant.app, userAppDTOResources.getHeadimgurl(), userAppDTOResources.getNickname(), 0);
Member member = new Member();
BeanUtils.copyProperties(memberDTOResources, member);
member.setId(null);
MemberDTO _memberDTO = this.memberService.create(member);
log.info("注册app账号，app账号不存在，保存会员信息结果，asyncAppRegister# memberDTO ==>> {}", _memberDTO);
if (Objects.nonNull(_memberDTO.getId())) {
UserApp userApp = new UserApp();
BeanUtils.copyProperties(userAppDTOResources, userApp);
userApp.setId(null);
// 保存app账号
UserAppDTO _userAppDTO = this.userAppService.create(UserAppBuilder.build(_memberDTO.getId(), userApp));
log.info("注册app账号，app账号不存在，保存会员信息之后保存app账号信息结果，asyncAppRegister# _userAppDTO ==>> {}", _userAppDTO);
if (Objects.nonNull(_userAppDTO.getId()) && StringUtils.isNotBlank(userAppDTO.getAccount())) {
/*if (Objects.nonNull(_userAppDTO.getId()) && StringUtils.isNotBlank(userAppDTO.getAccount())) {
UserAppBindDTO userAppBindDTO = this.userAppBindService.findFirstByAccount(userAppDTO.getAccount());
if (Objects.isNull(userAppBindDTO.getId())) {
// 保存绑定关系
UserAppBind userAppBind = UserAppBindBuilder.build(_userAppDTO.getId(), userAppDTO.getAccount(), userAppDTO.getAccountType());
this.userAppBindService.create(userAppBind);
}
}
}*/
}
}
}
public void asyncsaveGrowthReport(GrowthReport growthReport) {
String platformAccount = growthReport.getPlatformAccount();
......@@ -178,44 +237,48 @@ public class UserOperationServiceImpl implements UserOperationService {
}
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncMemberAndUserWeixin4Iptv(MemberAndWeixinUserDTO memberAndWeixinUserDTO) {
log.info("保存微信账号并同时创建会员信息 ==>> {}", memberAndWeixinUserDTO);
public void asyncMemberAndUserWeixin4Iptv(MemberAndWeixinUserDTO resource) {
log.info("保存微信账号并同时创建会员信息，参数 asyncMemberAndUserWeixin4Iptv# ==>> {}", resource);
UserWeixinDTO userWeixinDTO = memberAndWeixinUserDTO.getUserWeixinDTO();
UserWeixinDTO userWeixinDTO = resource.getUserWeixinDTO();
String openid = userWeixinDTO.getOpenid();
String unionid = userWeixinDTO.getUnionid();
String appid = userWeixinDTO.getAppid();
UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByAppIdAndOpenId(appid, openid);
log.info("通过appid ==>> {} 和openId ==>> {}，检查微信账号是否存在 ==>> {}",appid, openid, _userWeixinDTO);
// 无账号
log.info("保存微信账号并同时创建会员信息，asyncMemberAndUserWeixin4Iptv# 通过appid ==>> {}||openId ==>> {} ||结果集 ==>> {}",appid, openid, _userWeixinDTO);
// 当前微信账号不存在
if (Objects.isNull(_userWeixinDTO.getId())) {
// 其他账号
UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid);
log.info("账号不存在通过unionid ==>> {}，检查其他微信账号是否存在 ==>> {}",unionid, userWeixinDTO1);
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 无此微信账号，通过unionid ==>> {}，检查其他微信账号是否存在 ==>> {}",unionid, userWeixinDTO1);
// 有其他账号，需要共用一个会员信息
if (Objects.nonNull(userWeixinDTO1.getId())) {
Long memberId = userWeixinDTO1.getMemberId();
if (Objects.nonNull(memberId)) {
userWeixinDTO.setMemberId(memberId);
MemberDTO memberDTO = this.memberService.findById(memberId);
log.info("其他账号的会员信息 ==>> {}，memberId ==>> {}",memberDTO, memberId);
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 其他账号的会员信息 ==>> {}", memberDTO);
if (Objects.nonNull(memberDTO.getId())) {
MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
this.updateMember(memberDTO, memberDTO1);
userWeixinDTO.setMemberId(memberDTO.getId());
}
} else {
MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
log.info("其他账号的无会员信息，创建会员 memberDTO1 ==>> {}",memberDTO1);
MemberDTO memberDTO1 = resource.getMemberDTO();
String memberCode = memberDTO1.getCode();
if (StringUtils.isNotBlank(memberCode)) {
Member member = new Member();
member.setCode(memberCode);
log.warn("保存微信账号，asyncMemberAndUserWeixin4Iptv# 有其他账号但其他账号无会员信息，创建会员入库参数 member ==>> {}", member);
MemberDTO _memberDTO1 = this.memberService.create(member);
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 其他账号无会员信息，创建会员结果 _memberDTO1 ==>> {}", _memberDTO1);
userWeixinDTO.setMemberId(_memberDTO1.getId());
}
......@@ -224,59 +287,91 @@ public class UserOperationServiceImpl implements UserOperationService {
// 无其他账号
} else {
MemberDTO memberDTO = memberAndWeixinUserDTO.getMemberDTO();
log.info("无其他账号的无会员信息，创建会员 memberDTO ==>> {}",memberDTO);
MemberDTO memberDTO = resource.getMemberDTO();
Member member = new Member();
BeanUtils.copyProperties(memberDTO, member);
member.setId(null);
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 无其他账号，创建会员入库参数 member ==>> {}", member);
MemberDTO memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(memberDTO1.getId());
}
userWeixinDTO.setId(null);
log.info("保存微信账号，userWeixinDTO ==>> {}",userWeixinDTO);
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 入库信息 userWeixinDTO ==>> {}", userWeixinDTO);
this.createWeixin(userWeixinDTO);
// 当前微信账号存在
} else {
// 账号存在，会员也存在
// 会员存在
if(Objects.nonNull(_userWeixinDTO.getMemberId())) {
// 账号存在，修改账号和会员
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在且会员信息也存在更新账号信息，入库信息 userWeixinDTO ==>> {}", userWeixinDTO);
this.updateWeixin(_userWeixinDTO, userWeixinDTO);
MemberDTO _memberDTO = this.memberService.findById(_userWeixinDTO.getMemberId());
if (Objects.nonNull(_memberDTO.getId())){
MemberDTO memberDTO = memberAndWeixinUserDTO.getMemberDTO();
MemberDTO memberDTO = resource.getMemberDTO();
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在且会员信息也存在更新会员信息，入库信息 memberDTO ==>> {}", memberDTO);
this.updateMember(_memberDTO, memberDTO);
}
// 有账号无会员
// 无会员
} else {
// 是否存在会员
// 其他微信账号
UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid);
log.warn("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在但无会员信息，通过unionid ==>> {}，获取任意微信账号信息，结果集 ==>> {}", unionid, userWeixinDTO1);
// 有其他账号
// 有其他微信账号
if (Objects.nonNull(userWeixinDTO1.getId())) {
Long memberId = userWeixinDTO1.getMemberId();
if (Objects.nonNull(memberId)) {
userWeixinDTO.setMemberId(memberId);
MemberDTO memberDTO = this.memberService.findById(memberId);
MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在但无会员信息，通过unionid获取其他账号对应的会员信息，结果集 memberDTO ==>>{}", memberDTO);
MemberDTO memberDTO1 = resource.getMemberDTO();
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 微信账号信息存在但无会员信息，更新会员信息 memberDTO1 ==>>{}", memberDTO1);
this.updateMember(memberDTO, memberDTO1);
} else {
MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
MemberDTO memberDTO1 = resource.getMemberDTO();
Member member = new Member();
BeanUtils.copyProperties(memberDTO1, member);
member.setId(null);
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 其他微信账号信息存在但无会员信息，创建会员，入库参数 member ==>> {}", member);
MemberDTO _memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(_memberDTO1.getId());
}
// 无其他微信账号
} else {
MemberDTO memberDTO1 = resource.getMemberDTO();
Member member = new Member();
BeanUtils.copyProperties(memberDTO1, member);
member.setId(null);
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 其他微信账号信息存在但无会员信息，创建会员，入库参数 member ==>> {}", member);
MemberDTO _memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(_memberDTO1.getId());
}
log.info("保存微信账号，asyncMemberAndUserWeixin4Iptv# 更新微信账号信息，入库信息 userWeixinDTO ==>>{}", userWeixinDTO);
this.updateWeixin(_userWeixinDTO, userWeixinDTO);
}
......@@ -286,37 +381,46 @@ public class UserOperationServiceImpl implements UserOperationService {
}
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncMemberAndUserTv4Iptv(MemberAndUserTvDTO memberAndUserTvDTO) {
log.info("同步小屏侧过来的大屏账号和会员, memberAndUserTvDTO ==>> {}", memberAndUserTvDTO);
public void asyncMemberAndUserTv4Iptv(MemberAndUserTvDTO resource) {
log.info("保存大屏账号和会员，参数 asyncMemberAndUserTv4Iptv# ==>> {}", resource);
UserTvDTO userTvDTO = memberAndUserTvDTO.getUserTvDTO();
MemberDTO memberDTO = memberAndUserTvDTO.getMemberDTO();
UserTvDTO userTvDTO = resource.getUserTvDTO();
MemberDTO memberDTO = resource.getMemberDTO();
String platformAccount = userTvDTO.getPlatformAccount();
log.info("同步小屏侧过来的大屏账号, platformAccount ==>> {}", platformAccount);
if (StringUtils.isBlank(platformAccount)) {
log.error("保存大屏账号和会员异常，asyncMemberAndUserTv4Iptv# message ==>> 大屏账号不得为空");
return;
}
UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
// log.info("查询数据对应的大屏账号信息, _userTvDTO ==>> {}", _userTvDTO);
log.info("保存大屏账号和会员，asyncMemberAndUserTv4Iptv# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
// 大屏账号不存在
if (Objects.isNull(_userTvDTO)) {
log.info("大屏账号不存在, 创建会员并新增账号");
memberDTO.setId(null);
// 创建大屏会员
MemberDTO _memberDTO = this.createMember(memberDTO);
userTvDTO.setMemberId(_memberDTO.getId());
// 创建大屏账号
this.createUserTv(userTvDTO);
log.info("保存大屏账号和会员，asyncMemberAndUserTv4Iptv# 保存大屏账号信息，入库参数， _userTvDTO ==>> {}", _userTvDTO);
UserTv userTv = new UserTv();
BeanUtils.copyProperties(userTvDTO, userTv);
this.userTvService.create(userTv);
// 大屏账号存在
} else {
Long memberId = _userTvDTO.getMemberId();
if (Objects.isNull(memberId)) {
memberDTO.setId(null);
// 创建大屏会员
log.info("保存大屏账号和会员，asyncMemberAndUserTv4Iptv# 大屏账号存在但无会员信息，创建会员信息，入库参数，memberDTO ==>> {}", memberDTO);
MemberDTO _memberDTO = this.createMember(memberDTO);
userTvDTO.setMemberId(_memberDTO.getId());
log.info("大屏账号存在, 但无会员信息,新增会员信息并修改大屏账号");
// this.userTvService.updateMemberId(platformAccount, _memberDTO.getId());
userTvDTO.setMemberId(_memberDTO.getId());
} else {
......@@ -330,9 +434,10 @@ public class UserOperationServiceImpl implements UserOperationService {
}
UserTv userTv = new UserTv();
BeanUtils.copyProperties(_userTvDTO, userTv);
log.info("保存大屏账号和会员，asyncMemberAndUserTv4Iptv# 通过大屏账号修改大屏账号信息，入库参数，userTv ==>> {}", userTv);
this.userTvService.updateUserTvByPlatformAccount(userTv);
}
......@@ -340,21 +445,24 @@ public class UserOperationServiceImpl implements UserOperationService {
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncMinaBind(MemberAndUserTvDTO memberAndUserTvDTO) {
log.info("asyncAppletBind ==>> 小程序绑定大屏，参数 memberAndUserTvDTO ==>> {}", memberAndUserTvDTO);
log.info("小程序绑定大屏，参数 asyncMinaBind ==>> {}", memberAndUserTvDTO);
UserTvDTO userTvDTO = memberAndUserTvDTO.getUserTvDTO();
MemberDTO memberDTO = memberAndUserTvDTO.getMemberDTO();
String platformAccount = userTvDTO.getPlatformAccount();
if (StringUtils.isBlank(platformAccount)) {
log.error("小程序绑定大屏异常，asyncMinaBind# message ==>> 大屏账号不得为空");
return;
}
UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
if (Objects.nonNull(_userTvDTO.getId())) {
log.info("小程序绑定大屏，asyncMinaBind# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
//
// userTvDTO.getPriorityMemberCode();
// this.updateUserTv(_userTvDTO, userTvDTO);
if (Objects.nonNull(_userTvDTO.getId())) {
// 修改大屏账号的主会员
String priorityMemberCode = userTvDTO.getPriorityMemberCode();
log.info("修改大屏账号的主会员, 主会员priorityMemberCode ==>> {}", priorityMemberCode);
if (StringUtils.isNotBlank(priorityMemberCode)) {
if (StringUtils.isBlank(priorityMemberCode)) {
log.info("小程序绑定大屏，asyncMinaBind# 设置主会员 priorityMemberCode ==>> {}", priorityMemberCode);
this.userTvService.updatePriorityMemberCode(platformAccount, priorityMemberCode);
}
......@@ -362,111 +470,161 @@ public class UserOperationServiceImpl implements UserOperationService {
MemberDTO _memberDTO = this.memberService.findByCode(code);
memberDTO.setUserIptvId(_userTvDTO.getId());
log.info("修改会员对应绑定的大屏账号id, memberId ==>> {} || userTvId ==>> {}", _memberDTO.getId(), _userTvDTO.getId());
log.info("小程序绑定大屏，asyncMinaBind# 修改会员绑定的大屏id，入库参数，memberId ==>> {} || userTvId ==>> {}", _memberDTO.getId(), _userTvDTO.getId());
this.memberService.updateUserIptvIdById(_memberDTO.getId(), _userTvDTO.getId(), LocalDateTime.now());
} else {
log.error("asyncAppletBind ==>> 小程序绑定大屏异常，大屏账号不存在, platformAccount ==>> {}", platformAccount);
}
}
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncUnbind(MemberAndUserTvDTO memberAndUserTvDTO) {
UserTvDTO userTvDTO = memberAndUserTvDTO.getUserTvDTO();
MemberDTO memberDTO = memberAndUserTvDTO.getMemberDTO();
public void asyncUnbind(MemberAndUserTvDTO resource) {
log.info("解绑，参数 asyncMinaBind# ==>> {}", resource);
UserTvDTO userTvDTO = resource.getUserTvDTO();
MemberDTO memberDTO = resource.getMemberDTO();
String platformAccount = userTvDTO.getPlatformAccount();
if (StringUtils.isBlank(platformAccount)) {
log.error("解绑，asyncUnbind# message ==>> 大屏账号不得为空");
return;
}
UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
log.info("解绑，asyncUnbind# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
if (Objects.nonNull(_userTvDTO.getId())) {
//
UserTv userTv = new UserTv();
userTv.setPriorityMemberCode(userTvDTO.getPriorityMemberCode());
userTv.setId(_userTvDTO.getId());
userTv.setPlatformAccount(_userTvDTO.getPlatformAccount());
log.info("解绑，asyncUnbind# 修改主会员code，入库参数， userTv ==>> {}", userTv);
this.userTvService.doUpdatePriorityMemberCode(userTv);
}
String code = memberDTO.getCode();
if (StringUtils.isBlank(code)) {
log.error("解绑，asyncUnbind# message ==>> 会员code不得为空");
return;
}
MemberDTO _memberDTO = this.memberService.findByCode(code);
if (Objects.nonNull(_memberDTO.getId())) {
if (Objects.isNull(_memberDTO.getId())) {
log.error("解绑，asyncUnbind# message ==>> 会员信息不存在 || code ==>> {}", code);
return;
}
Member member = new Member();
member.setId(_memberDTO.getId());
member.setUserIptvId(null);
member.setBindIptvPlatformType(null);
member.setBindIptvTime(null);
log.info("解绑，asyncUnbind# 修改会员的绑定关系，入库参数， member ==>> {}", member);
this.memberService.doUpdateMemberUserIptvIdAndBindPlatformTypeAndBingTime(member);
}
}
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncWeixin(UserWeixinDTO userWeixinDTO) {
String openid = userWeixinDTO.getOpenid();
String unionid = userWeixinDTO.getUnionid();
String appid = userWeixinDTO.getAppid();
public void asyncWeixin(UserWeixinDTO resource) {
log.info("更新微信信息，参数 asyncWeixin# resource ==>> {}", resource);
String openid = resource.getOpenid();
String unionid = resource.getUnionid();
String appid = resource.getAppid();
if (StringUtils.isBlank(appid) || StringUtils.isBlank(openid)) {
log.error("更新微信信息，asyncWeixin# message ==>> openid或者appid不得为空");
return;
}
UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByAppIdAndOpenId(appid, openid);
if (Objects.nonNull(_userWeixinDTO.getId())) {
log.info("更新微信信息，参数 asyncWeixin# 通过appid和openid获取微信账号信息，结果集，_userWeixinDTO ==>> {}", _userWeixinDTO);
if(Objects.nonNull(_userWeixinDTO.getMemberId())) {
// 微信账号存在
if (Objects.nonNull(_userWeixinDTO.getId())) {
// unionid存在
if (StringUtils.isNotBlank(_userWeixinDTO.getUnionid())) {
// 会员不存在
if(Objects.isNull(_userWeixinDTO.getMemberId())) {
UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(_userWeixinDTO.getUnionid());
if (Objects.nonNull(userWeixinDTO1)) {
log.info("更新微信信息，asyncWeixin# 账号存在但会员不存在，通过unionid获取其他微信账号信息，结果集， userWeixinDTO1 ==>> {}", userWeixinDTO1);
Long memberId = userWeixinDTO1.getMemberId();
if (Objects.nonNull(memberId)) {
if (Objects.nonNull(userWeixinDTO1.getId())) {
userWeixinDTO.setMemberId(memberId);
Long memberId = userWeixinDTO1.getMemberId();
if (Objects.nonNull(memberId)) {
resource.setMemberId(memberId);
} else {
String memberCode = userWeixinDTO.getMemberCode();
String memberCode = resource.getMemberCode();
if (StringUtils.isNotBlank(memberCode)) {
Member member = new Member();
member.setCode(memberCode);
MemberDTO memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(memberDTO1.getId());
}
log.info("更新微信信息，asyncWeixin# 账号存在但会员不存在，无其他微信账号，创建会员信息，入库信息，member ==>> {}", member);
MemberDTO memberDTO1 = this.memberService.create(member);
resource.setMemberId(memberDTO1.getId());
}
}
} else {
String memberCode = userWeixinDTO.getMemberCode();
String memberCode = resource.getMemberCode();
if (StringUtils.isNotBlank(memberCode)) {
Member member = new Member();
member.setCode(memberCode);
log.info("更新微信信息，asyncWeixin# 账号存在但会员不存在，创建会员信息，入库信息，member ==>> {}", member);
MemberDTO memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(memberDTO1.getId());
resource.setMemberId(memberDTO1.getId());
}
}
}
// unionid不存在
} else {
String memberCode = userWeixinDTO.getMemberCode();
// 会员存在
if(Objects.isNull(_userWeixinDTO.getMemberId())) {
String memberCode = resource.getMemberCode();
if (StringUtils.isNotBlank(memberCode)) {
Member member = new Member();
member.setCode(memberCode);
MemberDTO memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(memberDTO1.getId());
resource.setMemberId(memberDTO1.getId());
}
}
userWeixinDTO.setId(_userWeixinDTO.getId());
this.updateWeixin(_userWeixinDTO, userWeixinDTO);
resource.setUnionid(unionid);
}
resource.setId(_userWeixinDTO.getId());
log.info("更新微信信息，参数 asyncWeixin# 修改微信信息，入库参数，resource ==>> {}", resource);
this.updateWeixin(_userWeixinDTO, resource);
// 微信账号不存在
} else {
userWeixinDTO.setId(null);
String memberCode = userWeixinDTO.getMemberCode();
resource.setId(null);
String memberCode = resource.getMemberCode();
Long memberId = null;
if (StringUtils.isNotBlank(memberCode)) {
MemberDTO memberDTO = this.memberService.findByCode(memberCode);
......@@ -479,8 +637,10 @@ public class UserOperationServiceImpl implements UserOperationService {
memberId = memberDTO.getId();
}
userWeixinDTO.setMemberId(memberId);
this.createWeixin(userWeixinDTO);
resource.setMemberId(memberId);
log.info("更新微信信息，参数 asyncWeixin# 保存微信账号信息，入库参数，resource ==>> {}", resource);
this.createWeixin(resource);
}
}
......@@ -488,20 +648,26 @@ public class UserOperationServiceImpl implements UserOperationService {
}
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncUserTvChangeMainAccount(UserTvDTO userTvDTO) {
log.info("asyncUserTv ==>> userTvDTO ==>> {}", userTvDTO);
public void asyncUserTvChangeMainAccount(UserTvDTO resource) {
log.info("更新大屏的主会员，参数 asyncUserTvChangeMainAccount# resource ==>> {}", resource);
String priorityMemberCode = userTvDTO.getPriorityMemberCode();
String priorityMemberCode = resource.getPriorityMemberCode();
if (StringUtils.isBlank(priorityMemberCode)) {
log.error("大屏账号设置主会员异常，主会员code不存在");
log.error("更新大屏的主会员异常，asyncUserTvChangeMainAccount# message ==>> 主会员code不得为空");
return;
}
String platformAccount = resource.getPlatformAccount();
if (StringUtils.isBlank(platformAccount)) {
log.error("更新大屏的主会员异常，asyncUserTvChangeMainAccount# message ==>> 大屏账号不得为空");
return;
}
String platformAccount = userTvDTO.getPlatformAccount();
UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
log.info("从数据库中获取大屏信息， _userTvDTO ==>> {}", _userTvDTO);
log.info("更新大屏的主会员，asyncUserTvChangeMainAccount# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
if (Objects.isNull(_userTvDTO.getId())) {
log.error("大屏账号设置主会员异常，大屏账号不存在");
log.error("大屏账号设置主会员异常，asyncUserTvChangeMainAccount# message ==>> 大屏账号不存在");
return;
}
......@@ -509,102 +675,131 @@ public class UserOperationServiceImpl implements UserOperationService {
userTv.setId(_userTvDTO.getId());
userTv.setPlatformAccount(platformAccount);
userTv.setPriorityMemberCode(priorityMemberCode);
log.info("开始修改大屏数据，userTv ==>>{}", userTv);
log.info("更新大屏的主会员，asyncUserTvChangeMainAccount# 修改大屏的主会员，入库参数，userTv ==>>{}", userTv);
this.userTvService.doUpdatePriorityMemberCode(userTv);
}
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncUserTv(UserTvDTO userTvDTO) {
log.info("asyncUserTv ==>> userTvDTO ==>> {}", userTvDTO);
String platformAccount = userTvDTO.getPlatformAccount();
public void asyncUserTv(UserTvDTO resource) {
log.info("更新大屏账号信息，参数 asyncUserTv# resource ==>> {}", resource);
String platformAccount = resource.getPlatformAccount();
if (StringUtils.isBlank(platformAccount)) {
log.error("更新大屏账号信息异常，asyncUserTv# message ==>> 大屏账号不得为空");
return;
}
UserTvDTO _userTvDTO = this.userTvService.findByPlatformAccount(platformAccount);
log.info("db result ==>> _userTvDTO ==>> {}", _userTvDTO);
// this.updateUserTv(_userTvDTO, userTvDTO);
log.info("更新大屏账号信息，asyncUserTv# 通过大屏账号查询大屏账号信息，结果集 _userTvDTO ==>> {}", _userTvDTO);
UserTv userTv = new UserTv();
BeanUtils.copyProperties(userTvDTO, userTv);
BeanUtils.copyProperties(resource, userTv);
log.info("更新大屏账号信息，asyncUserTv# 修改大屏账号信息，入库参数，userTv ==>>{}", userTv);
this.userTvService.updateUserTvByPlatformAccount(userTv);
}
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncMember(MemberDTO memberDTO) {
String code = memberDTO.getCode();
if (StringUtils.isNotBlank(code)) {
MemberDTO _memberDTO = this.memberService.findByCode(code);
if (Objects.nonNull(_memberDTO)) {
Long id = _memberDTO.getId();
memberDTO.setId(id);
this.updateMember(_memberDTO, memberDTO);
public void asyncMember(MemberDTO resource) {
log.info("更新会员信息，参数 asyncMember# resource ==>> {}", resource);
String code = resource.getCode();
if (StringUtils.isBlank(code)) {
log.error("更新会员信息异常，asyncMember# message ==>> 会员code不得为空");
return;
}
MemberDTO _memberDTO = this.memberService.findByCode(code);
if (Objects.isNull(_memberDTO.getId())) {
log.error("更新会员信息异常，asyncMember# message ==>> 会员信息不存在");
return;
}
Long id = _memberDTO.getId();
resource.setId(id);
this.updateMember(_memberDTO, resource);
}
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncSubscribe(MemberAndWeixinUserDTO memberAndWeixinUserDTO) {
log.info("微信关注业务开始");
UserWeixinDTO userWeixinDTO = memberAndWeixinUserDTO.getUserWeixinDTO();
log.info("小屏侧传过来的微信账号信息 ==>> userWeixinDTO ==>> {}", userWeixinDTO);
public void asyncSubscribe(MemberAndWeixinUserDTO resource) {
log.info("微信关注，参数 asyncSubscribe# resource ==>> {}", resource);
UserWeixinDTO userWeixinDTO = resource.getUserWeixinDTO();
String openid = userWeixinDTO.getOpenid();
String unionid = userWeixinDTO.getUnionid();
String appid = userWeixinDTO.getAppid();
MemberDTO memberDTO = memberAndWeixinUserDTO.getMemberDTO();
log.info("小屏侧传过来的会员信息 ==>> memberDTO ==>> {}", memberDTO);
if (StringUtils.isBlank(appid) || StringUtils.isBlank(openid)) {
log.error("微信关异常，asyncSubscribe# message ==>> openid或者appid不得为空");
return;
}
MemberDTO memberDTO = resource.getMemberDTO();
UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByUnionIdAndAppIdAndOpenId(unionid, appid, openid);
log.info("微信关注，asyncSubscribe# 通过unionid ==>> {} || appid ==>> {} || openid ==>> {}，查询微信账号信息，结果集 ==>>{}", unionid, appid, openid, _userWeixinDTO);
// 有账号
if (Objects.nonNull(_userWeixinDTO.getId())) {
log.info("账号存在，检查会员是否存在");
UserWeixinDTO _userWeixinDTO0 = this.userWeixinService.findFirstByAppIdAndOpenId(appid, openid);
// 会员存在
if(Objects.nonNull(_userWeixinDTO0.getMemberId())) {
log.info("会员存在，修改账号的关注状态, 关注状态 status ==>> {}", userWeixinDTO.getStatus());
// 账号存在，修改账号和会员
if(Objects.nonNull(_userWeixinDTO.getMemberId())) {
log.info("微信关注，asyncSubscribe# 修改微信信息，入库信息，userWeixinDTO ==>> {}", userWeixinDTO);
this.updateWeixin(_userWeixinDTO, userWeixinDTO);
MemberDTO _memberDTO = this.memberService.findById(_userWeixinDTO.getMemberId());
MemberDTO memberDTO0 = memberAndWeixinUserDTO.getMemberDTO();
MemberDTO memberDTO0 = resource.getMemberDTO();
memberDTO0.setUserIptvId(_memberDTO.getUserIptvId());
log.info("会员存在，修改会员的绑定和vip标识", userWeixinDTO.getStatus());
log.info("微信关注，asyncSubscribe# 修改会员的绑定状态和vip标识，入库参数，userWeixinDTO ==>> {}", userWeixinDTO);
this.updateMember(_memberDTO, memberDTO0);
// 有账号无会员
// 无会员
} else {
log.info("当前账号会员不存在");
// 是否存在会员
// 其他微信账号
UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid);
log.info("检查是否有其他账号存在, 其他账号信息 ==>> {}", userWeixinDTO1);
log.info("微信关注，asyncSubscribe#，通过unionid==>> {}，检查是否有其他账号存在，结果集 ==>> {}", unionid, userWeixinDTO1);
// 有其他账号
if (Objects.nonNull(userWeixinDTO1.getId())) {
log.info("存在其他账号，检查其他账号是否有会员");
Long memberId = userWeixinDTO1.getMemberId();
if (Objects.nonNull(memberId)) {
userWeixinDTO.setMemberId(memberId);
MemberDTO memberDTO0 = this.memberService.findById(memberId);
log.info("其他账号有会员，会员信息 ==>> {}", memberDTO0);
MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
MemberDTO memberDTO0 = this.memberService.findById(memberId);
log.info("开始同步会员信息");
this.updateMember(memberDTO0, memberDTO1);
log.info("微信关注，asyncSubscribe# 微信账号存在但无会员，同步其他账号的会员信息，入库参数，memberDTO0 ==>> {}", memberDTO);
this.updateMember(memberDTO0, memberDTO);
} else {
log.info("其他账号无会员");
MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
Member member = new Member();
BeanUtils.copyProperties(memberDTO1, member);
BeanUtils.copyProperties(memberDTO, member);
member.setId(null);
log.info("为当前账号创建会员，会员信息 ==>> {}", member);
log.info("微信关注，asyncSubscribe# 微信账号存在但无会员也其他账号也无会员，创建会员信息，入库参数，member ==>> {}", member);
MemberDTO _memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(_memberDTO1.getId());
}
// 无其他账号
} else {
Member member = new Member();
BeanUtils.copyProperties(memberDTO, member);
member.setId(null);
log.info("微信关注，asyncSubscribe# 微信账号存在但无会员也无其他账号，创建会员信息，入库参数，member ==>> {}", member);
MemberDTO _memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(_memberDTO1.getId());
}
log.info("开始修改账号信息");
log.info("微信关注，asyncSubscribe# 更新微信账号信息，入库参数，userWeixinDTO ==>> {}", userWeixinDTO);
this.updateWeixin(_userWeixinDTO, userWeixinDTO);
}
......@@ -612,36 +807,31 @@ public class UserOperationServiceImpl implements UserOperationService {
// 无账号
} else {
log.info("当前账号不存在，检查其他账号是否存在");
// 是否存在会员
UserWeixinDTO userWeixinDTO1 = this.userWeixinService.findFirstByUnionId(unionid);
log.info("微信关注，asyncSubscribe#，通过unionid==>> {}，检查是否有其他账号存在，结果集 userWeixinDTO1 ==>> {}", unionid, userWeixinDTO1);
// 有其他账号
if (Objects.nonNull(userWeixinDTO1.getId())) {
log.info("其他账号存在, 其他账号信息 ==>> {}", userWeixinDTO1);
log.info("检查其他账号是否有会员");
Long memberId = userWeixinDTO1.getMemberId();
if (Objects.nonNull(memberId)) {
userWeixinDTO.setMemberId(memberId);
MemberDTO memberDTO0 = this.memberService.findById(memberId);
log.info("其他账号有会员，会员信息 ==>> {}", memberDTO0);
MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
MemberDTO memberDTO0 = this.memberService.findById(memberId);
log.info("微信关注，asyncSubscribe#，当前微信账号不存在，获取其他账号的会员信息，结果集 memberDTO0 ==>> {}", memberDTO0);
log.info("开始同步会员信息");
this.updateMember(memberDTO0, memberDTO1);
log.info("微信关注，asyncSubscribe# 更新会员信息，入库参数 memberDTO ==>> {}", memberDTO);
this.updateMember(memberDTO0, memberDTO);
} else {
log.info("其他账号无会员");
MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
Member member = new Member();
BeanUtils.copyProperties(memberDTO1, member);
BeanUtils.copyProperties(memberDTO, member);
member.setId(null);
log.info("为当前账号创建会员，会员信息 ==>> {}", member);
log.info("微信关注，asyncSubscribe# 微信账号存在但无会员其他账号也无会员信息，创建会员信息，入库参数，member ==>> {}", member);
MemberDTO _memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(_memberDTO1.getId());
......@@ -649,53 +839,64 @@ public class UserOperationServiceImpl implements UserOperationService {
} else {
log.info("无其他账号存在");
MemberDTO memberDTO1 = memberAndWeixinUserDTO.getMemberDTO();
Member member = new Member();
BeanUtils.copyProperties(memberDTO1, member);
BeanUtils.copyProperties(memberDTO, member);
member.setId(null);
log.info("为当前账号创建会员，会员信息 ==>> {}", member);
log.info("微信关注，asyncSubscribe# 微信账号存在但无会员也无其他账号，创建会员信息，入库参数，member ==>> {}", member);
MemberDTO _memberDTO1 = this.memberService.create(member);
userWeixinDTO.setMemberId(_memberDTO1.getId());
}
log.info("开始创建微信账号");
log.info("微信关注，asyncSubscribe# 保存微信账号信息，入库参数，userWeixinDTO ==>> {}", userWeixinDTO);
this.createWeixin(userWeixinDTO);
}
}
@Transactional(propagation = Propagation.SUPPORTS, rollbackFor = Exception.class)
public void asyncUnsubscribe(MemberAndWeixinUserDTO memberAndWeixinUserDTO) {
UserWeixinDTO userWeixinDTO = memberAndWeixinUserDTO.getUserWeixinDTO();
public void asyncUnsubscribe(MemberAndWeixinUserDTO resource) {
log.info("微信取关，参数 asyncUnsubscribe# resource ==>> {}", resource);
UserWeixinDTO userWeixinDTO = resource.getUserWeixinDTO();
String openid = userWeixinDTO.getOpenid();
String unionid = userWeixinDTO.getUnionid();
String appid = userWeixinDTO.getAppid();
MemberDTO memberDTO = memberAndWeixinUserDTO.getMemberDTO();
if (StringUtils.isBlank(appid) || StringUtils.isBlank(openid)) {
log.error("微信取关异常，asyncUnsubscribe# message ==>> openid或者appid不得为空");
return;
}
MemberDTO memberDTO = resource.getMemberDTO();
UserWeixinDTO _userWeixinDTO = this.userWeixinService.findFirstByUnionIdAndAppIdAndOpenId(unionid, appid, openid);
if (Objects.nonNull(_userWeixinDTO)) {
log.info("微信取关，asyncUnsubscribe# 通过unionid ==>> {} || appid ==>> {} || openid ==>> {}，查询微信账号信息，结果集 ==>>{}", unionid, appid, openid, _userWeixinDTO);
if (Objects.nonNull(_userWeixinDTO.getId())) {
// 账号存在，修改账号和会员
log.info("微信取关，asyncUnsubscribe# 更新微信账号信息，入库参数，userWeixinDTO ==>>{}", userWeixinDTO);
this.updateWeixin(_userWeixinDTO, userWeixinDTO);
MemberDTO _memberDTO = this.memberService.findById(_userWeixinDTO.getMemberId());
if (Objects.nonNull(_memberDTO)) {
if (Objects.nonNull(_memberDTO.getId())) {
memberDTO.setUserIptvId(_memberDTO.getUserIptvId());
log.info("微信取关，asyncUnsubscribe# 更新会员信息，入库参数，memberDTO ==>>{}", memberDTO);
this.updateMember(_memberDTO, memberDTO);
} else {
throw new EntityNotFoundException(MemberDTO.class, "id", GlobeExceptionMsg.MEMBER_ID_IS_NULL);
log.error("微信取关异常，asyncUnsubscribe# message ==>> 会员信息不存在");
}
} else {
throw new EntityNotFoundException(UserWeixinDTO.class, "id", GlobeExceptionMsg.WEIXIN_IS_NULL);
log.error("微信取关异常，asyncUnsubscribe# message ==>> 微信账号不存在");
}
......@@ -707,15 +908,15 @@ public class UserOperationServiceImpl implements UserOperationService {
return this.memberService.create(member);
}
private MemberDTO updateMember(MemberDTO _memberDTO, MemberDTO memberDTO){
private void updateMember(MemberDTO _memberDTO, MemberDTO memberDTO){
memberDTO.setId(_memberDTO.getId());
memberDTO.setCode(_memberDTO.getCode());
Member member = new Member();
BeanUtils.copyProperties(memberDTO, member);
log.info("会员入库结果 ==>> member ==>> {}", member);
return this.memberService.update(member);
this.memberService.update(member);
}
private void createWeixin(UserWeixinDTO weixinDTO){
......@@ -745,10 +946,4 @@ public class UserOperationServiceImpl implements UserOperationService {
log.info("账号入库结果 ==>> userWeixin ==>> {}", userWeixin);
this.userWeixinService.update(userWeixin);
}
private void createUserTv(UserTvDTO userTvDTO){
UserTv userTv = new UserTv();
BeanUtils.copyProperties(userTvDTO, userTv);
this.userTvService.create(userTv);
}
}
......
......@@ -39,21 +39,25 @@ public class MemberProfileOperationServiceImpl implements MemberProfileOperation
* @param resource
*/
public void asyncCreateMemberProfileAndSyncMember(MemberProfileDTO resource) {
log.info("创建会员属性，参数 ==>> {}", resource);
log.info("保存会员以及会员属性，参数 asyncCreateMemberProfileAndSyncMember# resource ==>> {}", resource);
String memberCode = resource.getMemberCode();
if (StringUtils.isBlank(memberCode)) {
log.error("创建会员属性失败，会员code不存在");
log.error("保存会员以及会员属性异常，asyncCreateMemberProfileAndSyncMember# message ==>> 会员code不存在");
return;
}
MemberDTO memberDTO = this.memberService.findByCode(memberCode);
log.info("保存会员以及会员属性，asyncCreateMemberProfileAndSyncMember# 通过code ==>> {}，查询会员信息，结果集，memberDTO ==>> {}", memberCode, memberDTO);
if (Objects.isNull(memberDTO.getId())) {
log.error("创建会员属性失败，会员信息不存在 ==>> memberCode ==>> {}", memberCode);
log.error("保存会员以及会员属性失败，asyncCreateMemberProfileAndSyncMember# message ==>> 会员信息不存在 || memberCode ==>> {}", memberCode);
return;
}
Long memberId = memberDTO.getId();
MemberProfileDTO _memberProfileDTO = this.memberProfileService.findByMemberId(memberId);
log.info("保存会员以及会员属性，asyncCreateMemberProfileAndSyncMember# 通过会员id ==>> {}，查询会员属性信息，结果集，_memberProfileDTO ==>> {}", memberId, _memberProfileDTO);
if (Objects.isNull(_memberProfileDTO.getId())) {
......@@ -61,6 +65,8 @@ public class MemberProfileOperationServiceImpl implements MemberProfileOperation
BeanUtils.copyProperties(resource, memberProfile);
memberProfile.setId(null);
memberProfile.setMemberId(memberId);
log.info("保存会员以及会员属性，asyncCreateMemberProfileAndSyncMember# 保存会员属性，入库参数，memberProfile ==>> {}", memberProfile);
this.memberProfileService.createDefault(memberProfile);
Member member = new Member();
......@@ -69,56 +75,60 @@ public class MemberProfileOperationServiceImpl implements MemberProfileOperation
member.setAvatarUrl(memberProfile.getAvatarUrl());
member.setNickname(memberProfile.getRealname());
member.setGender(memberProfile.getGender());
log.info("保存会员以及会员属性，asyncCreateMemberProfileAndSyncMember# 更新会员头像、昵称、性别，入库参数，member ==>> {}", member);
this.memberService.doUpdateMemberAvatarUrlAndNicknameAndGender(member);
}
}
/**
*
* @param resources
*/
public void asyncUpdateMemberProfileAndSyncMember(MemberProfileAndMemberDTO resources) {
log.info("修改会员属性，参数 ==>> {}", resources);
log.info("修改会员属性，参数 asyncUpdateMemberProfileAndSyncMember# resource ==>> {}", resources);
MemberProfileDTO memberProfileDTO = resources.getMemberProfileDTO();
if (Objects.isNull(memberProfileDTO)) {
log.error("修改会员属性异常, 会员属性参数为空");
log.error("修改会员属性异常，asyncUpdateMemberProfileAndSyncMember# message ==>> 会员属性不得为空");
return;
}
MemberDTO memberDTO = resources.getMemberDTO();
if (Objects.isNull(memberDTO)) {
log.error("修改会员属性异常, 会员信息为空");
log.error("修改会员属性异常，asyncUpdateMemberProfileAndSyncMember# message ==>> 会员信息不得为空");
return;
}
MemberProfileDTO _memberProfileDTO = this.asyncMemberProfile(memberProfileDTO);
log.info("修改会员属性，asyncUpdateMemberProfileAndSyncMember# 结果集，_memberProfileDTO ==>> {}", _memberProfileDTO);
String code = memberDTO.getCode();
if (!StringUtils.isEmpty(code)) {
MemberDTO memberDTO1 = this.memberService.findByCode(code);
log.info("修改会员属性，asyncUpdateMemberProfileAndSyncMember# 通过code ==>> {}，查询会员信息，结果集，memberDTO1 ==>> {}", code, memberDTO);
Member member = new Member();
member.setId(memberDTO1.getId());
member.setNickname(_memberProfileDTO.getRealname());
member.setBirthday(_memberProfileDTO.getBirthday());
member.setGender(_memberProfileDTO.getGender());
log.info("修改会员属性，asyncUpdateMemberProfileAndSyncMember# 入库参数，member ==>> {}", member);
this.memberService.doUpdateMemberAvatarUrlAndNicknameAndGender(member);
}
}
public MemberProfileDTO asyncMemberProfile(MemberProfileDTO memberProfileDTO){
String memberCode = memberProfileDTO.getMemberCode();
public MemberProfileDTO asyncMemberProfile(MemberProfileDTO resource){
log.info("修改会员属性，参数 asyncMemberProfile# resource ==>> {}", resource);
String memberCode = resource.getMemberCode();
MemberDTO memberDTO = this.memberService.findByCode(memberCode);
Long memberId = memberDTO.getId();
MemberProfileDTO _memberProfileDTO = this.memberProfileService.findByMemberId(memberId);
memberProfileDTO.setId(_memberProfileDTO.getId());
memberProfileDTO.setMemberId(memberId);
resource.setId(_memberProfileDTO.getId());
resource.setMemberId(memberId);
MemberProfile memberProfile = new MemberProfile();
BeanUtils.copyProperties(memberProfileDTO, memberProfile);
BeanUtils.copyProperties(resource, memberProfile);
return this.memberProfileService.update(memberProfile);
}
......
package com.topdraw.business.process.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.module.user.weixin.collection.domain.UserCollectionDetail;
import com.topdraw.business.process.domian.weixin.UserCollectionMq;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.ReportingPolicy;
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface CollectionMq2DetailMapper extends BaseMapper<UserCollectionMq, UserCollectionDetail> {
@Override
@Mappings({
@Mapping(target = "detailImg", source = "images")
})
UserCollectionDetail toEntity(UserCollectionMq dto);
}