proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/aop/interceptor/PreventDuplicateSubmissionsInterceptor.java
|
PreventDuplicateSubmissionsInterceptor
|
getParams
|
class PreventDuplicateSubmissionsInterceptor {
@Autowired
private Cache<String> cache;
@Before("@annotation(preventDuplicateSubmissions)")
public void interceptor(PreventDuplicateSubmissions preventDuplicateSubmissions) {
try {
String redisKey = getParams(preventDuplicateSubmissions.userIsolation());
Long count = cache.incr(redisKey, preventDuplicateSubmissions.expire());
log.debug("防重复提交：params-{},value-{}", redisKey, count);
//如果超过0或者设置的参数，则表示重复提交了
if (count.intValue() > 0) {
throw new ServiceException(ResultCode.LIMIT_ERROR);
}
}
//如果参数为空，则表示用户未登录，直接略过，不做处理
catch (NullPointerException e) {
return;
} catch (ServiceException e) {
throw e;
} catch (Exception e) {
log.error("防重复提交拦截器异常", e);
throw new ServiceException(ResultCode.ERROR);
}
}
/**
* 获取表单参数
*
* @param userIsolation 用户是否隔离
* @return 计数器key
*/
private String getParams(Boolean userIsolation) {<FILL_FUNCTION_BODY>}
}
|
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
StringBuilder stringBuilder = new StringBuilder();
//拼接请求地址
stringBuilder.append(request.getRequestURI());
//参数不为空则拼接参数
if (!request.getParameterMap().isEmpty()) {
stringBuilder.append(JSONUtil.toJsonStr(request.getParameterMap()));
}
//用户隔离设置为开启，则选择当前用回顾
if (userIsolation) {
AuthUser authUser = UserContext.getCurrentUser();
//用户为空则发出警告，但不拼接，否则拼接用户id
if (authUser == null) {
log.warn("user isolation settings are on,but current user is null");
}
// 不为空则拼接用户id
else {
stringBuilder.append(authUser.getId());
}
}
//请求地址
return stringBuilder.toString();
| 360
| 243
| 603
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/aop/interceptor/RetryAspect.java
|
RetryAspect
|
retryOperation
|
class RetryAspect {
@Around(value = "@annotation(retryOperation)")
public Object retryOperation(ProceedingJoinPoint joinPoint, RetryOperation retryOperation) throws Throwable {<FILL_FUNCTION_BODY>}
}
|
Object response = null;
int retryCount = retryOperation.retryCount();
int waitSeconds = retryOperation.waitSeconds();
boolean successful = false;
do {
try {
response = joinPoint.proceed();
successful = true;
} catch (RetryException ex) {
log.info("Operation failed, retries remaining: {}", retryCount);
retryCount--;
if (retryCount < 0) {
successful = true;
log.error(ex.getMessage());
}
if (waitSeconds > 0 && !successful) {
log.info("Waiting for {} second(s) before next retry", waitSeconds);
Thread.sleep(waitSeconds * 1000L);
}
}
} while (!successful);
return response;
| 69
| 215
| 284
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/context/ThreadContextHolder.java
|
ThreadContextHolder
|
getHttpResponse
|
class ThreadContextHolder {
public static HttpServletResponse getHttpResponse() {<FILL_FUNCTION_BODY>}
public static HttpServletRequest getHttpRequest() {
ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
assert servletRequestAttributes != null;
return servletRequestAttributes.getRequest();
}
}
|
ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
assert servletRequestAttributes != null;
return servletRequestAttributes.getResponse();
| 97
| 49
| 146
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/exception/GlobalControllerExceptionHandler.java
|
GlobalControllerExceptionHandler
|
handleServiceException
|
class GlobalControllerExceptionHandler {
/**
* 如果超过长度，则前后段交互体验不佳，使用默认错误消息
*/
static Integer MAX_LENGTH = 200;
/**
* 自定义异常
*
* @param e
* @return
*/
@ExceptionHandler(ServiceException.class)
@ResponseStatus(value = HttpStatus.BAD_REQUEST)
public ResultMessage<Object> handleServiceException(HttpServletRequest request, final Exception e, HttpServletResponse response) {<FILL_FUNCTION_BODY>}
/*
@ExceptionHandler(ConstraintViolationException.class)
@ResponseStatus(value = HttpStatus.BAD_REQUEST)
public ResultMessage<Object> constraintExceptionHandler(HttpServletRequest request, final Exception e, HttpServletResponse response) {
log.error("全局异常[RuntimeException]:", e);
return ResultUtil.error(001, e.getMessage());
}*/
@ExceptionHandler(RuntimeException.class)
@ResponseStatus(value = HttpStatus.BAD_REQUEST)
public ResultMessage<Object> runtimeExceptionHandler(HttpServletRequest request, final Exception e, HttpServletResponse response) {
log.error("全局异常[RuntimeException]:", e);
return ResultUtil.error(ResultCode.ERROR);
}
// /**
// * 通用的接口映射异常处理方
// */
// @Override
// protected ResponseEntity<Object> handleExceptionInternal(Exception ex, Object body, HttpHeaders headers, HttpStatus status, WebRequest request) {
// if (ex instanceof MethodArgumentNotValidException) {
// MethodArgumentNotValidException exception = (MethodArgumentNotValidException) ex;
// return new ResponseEntity<>(new ResultUtil<>().setErrorMsg(exception.getBindingResult().getAllErrors().get(0).getDefaultMessage()),
// status);
// }
// if (ex instanceof MethodArgumentTypeMismatchException) {
// MethodArgumentTypeMismatchException exception = (MethodArgumentTypeMismatchException) ex;
// logger.error("参数转换失败，方法：" + exception.getParameter().getMethod().getName() + "，参数：" + exception.getName()
// + ",信息：" + exception.getLocalizedMessage());
// return new ResponseEntity<>(new ResultUtil<>().setErrorMsg("参数转换失败"), status);
// }
// ex.printStackTrace();
// return new ResponseEntity<>(new ResultUtil<>().setErrorMsg("未知异常，请联系管理员"), status);
// }
/**
* bean校验未通过异常
*
* @see javax.validation.Valid
* @see org.springframework.validation.Validator
* @see org.springframework.validation.DataBinder
*/
@ExceptionHandler(BindException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ResponseBody
public ResultMessage<Object> validExceptionHandler(HttpServletRequest request, final Exception e, HttpServletResponse response) {
BindException exception = (BindException) e;
List<FieldError> fieldErrors = exception.getBindingResult().getFieldErrors();
// 错误消息处理
try {
if (!fieldErrors.isEmpty()) {
return ResultUtil.error(ResultCode.PARAMS_ERROR.code(),
fieldErrors.stream()
.map(FieldError::getDefaultMessage) // 获取每个对象的名称字段
.collect(Collectors.joining(", ")));
}
return ResultUtil.error(ResultCode.PARAMS_ERROR);
} catch (Exception ex) {
return ResultUtil.error(ResultCode.PARAMS_ERROR);
}
}
/**
* bean校验未通过异常
*
* @see javax.validation.Valid
* @see org.springframework.validation.Validator
* @see org.springframework.validation.DataBinder
*/
@ExceptionHandler(ConstraintViolationException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ResponseBody
public ResultMessage<Object> constraintViolationExceptionHandler(HttpServletRequest request, final Exception e, HttpServletResponse response) {
ConstraintViolationException exception = (ConstraintViolationException) e;
return ResultUtil.error(ResultCode.PARAMS_ERROR.code(), exception.getMessage());
}
}
|
//如果是自定义异常，则获取异常，返回自定义错误消息
if (e instanceof ServiceException) {
ServiceException serviceException = ((ServiceException) e);
ResultCode resultCode = serviceException.getResultCode();
Integer code = null;
String message = null;
if (resultCode != null) {
code = resultCode.code();
message = resultCode.message();
}
//如果有扩展消息，则输出异常中，跟随补充异常
if (!serviceException.getMsg().equals(ServiceException.DEFAULT_MESSAGE)) {
message += ":" + serviceException.getMsg();
}
// 对一些特殊异常处理，不再打印error级别的日志
assert serviceException.getResultCode() != null;
if (serviceException.getResultCode().equals(ResultCode.DEMO_SITE_EXCEPTION)) {
log.debug("[DEMO_SITE_EXCEPTION]:{}", serviceException.getResultCode().message(), e);
return ResultUtil.error(code, message);
}
if (serviceException.getResultCode().equals(ResultCode.USER_AUTH_EXPIRED)) {
log.debug("403 :{}", serviceException.getResultCode().message(), e);
return ResultUtil.error(code, message);
}
log.error("全局异常[ServiceException]:{}-{}", serviceException.getResultCode().code(), serviceException.getResultCode().message(), e);
return ResultUtil.error(code, message);
} else {
log.error("全局异常[ServiceException]:", e);
}
//默认错误消息
String errorMsg = "服务器异常，请稍后重试";
if (e != null && e.getMessage() != null && e.getMessage().length() < MAX_LENGTH) {
errorMsg = e.getMessage();
}
return ResultUtil.error(ResultCode.ERROR.code(), errorMsg);
| 1,078
| 497
| 1,575
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/listener/TransactionCommitSendMQListener.java
|
TransactionCommitSendMQListener
|
send
|
class TransactionCommitSendMQListener {
/**
* rocketMq
*/
@Autowired
private RocketMQTemplate rocketMQTemplate;
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void send(TransactionCommitSendMQEvent event) {<FILL_FUNCTION_BODY>}
}
|
log.info("事务提交，发送mq信息!{}", event);
String destination = event.getTopic() + ":" + event.getTag();
//发送订单变更mq消息
rocketMQTemplate.asyncSend(destination, event.getMessage(), RocketmqSendCallbackBuilder.commonCallback());
| 99
| 85
| 184
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/properties/StatisticsProperties.java
|
StatisticsProperties
|
getOnlineMember
|
class StatisticsProperties {
/**
* 在线人数统计 X 小时
*/
private Integer onlineMember = 48;
/**
* 当前在线人数 刷新时间间隔
*/
private Integer currentOnlineUpdate = 600;
public Integer getOnlineMember() {<FILL_FUNCTION_BODY>}
public Integer getCurrentOnlineUpdate() {
if (currentOnlineUpdate == null) {
return 600;
}
return currentOnlineUpdate;
}
}
|
if (onlineMember == null) {
return 48;
}
return onlineMember;
| 132
| 29
| 161
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/properties/SystemSettingProperties.java
|
SystemSettingProperties
|
getSensitiveLevel
|
class SystemSettingProperties {
/**
* 是否是演示站点
*/
private Boolean isDemoSite = false;
/**
* 测试模式
* 验证码短信为6个1
*/
private Boolean isTestModel = false;
/**
* 脱敏级别：
* 0：不做脱敏处理
* 1：管理端用户手机号等信息脱敏
* 2：商家端信息脱敏（为2时，表示管理端，商家端同时脱敏）
* <p>
* PS:
*/
private Integer sensitiveLevel = 0;
public Boolean getDemoSite() {
if (isDemoSite == null) {
return false;
}
return isDemoSite;
}
public Boolean getTestModel() {
if (isTestModel == null) {
return false;
}
return isTestModel;
}
public Integer getSensitiveLevel() {<FILL_FUNCTION_BODY>}
}
|
if (sensitiveLevel == null) {
return 0;
}
return sensitiveLevel;
| 273
| 29
| 302
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/properties/VerificationCodeProperties.java
|
VerificationCodeProperties
|
getInterfereNum
|
class VerificationCodeProperties {
/**
* 过期时间
* 包含滑块验证码有效时间， 以及验证通过之后，缓存中存储的验证结果有效时间
*/
private Long effectiveTime = 600L;
/**
* 水印
*/
private String watermark = "";
/**
* 干扰数量 最大数量
*/
private Integer interfereNum = 0;
/**
* 容错像素
*/
private Integer faultTolerant = 3;
public String getWatermark() {
return watermark;
}
public Integer getInterfereNum() {<FILL_FUNCTION_BODY>}
}
|
if (interfereNum > 2) {
return 2;
}
return interfereNum;
| 184
| 30
| 214
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/security/SecurityBean.java
|
SecurityBean
|
corsConfigurationSource
|
class SecurityBean {
@Bean
public BCryptPasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* 定义跨域配置
*
* @return bean
*/
@Bean
CorsConfigurationSource corsConfigurationSource() {<FILL_FUNCTION_BODY>}
}
|
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
CorsConfiguration config = new CorsConfiguration();
config.setAllowCredentials(true);
config.setAllowedOriginPatterns(Collections.singletonList(CorsConfiguration.ALL));
config.addAllowedHeader(CorsConfiguration.ALL);
config.addAllowedMethod(CorsConfiguration.ALL);
source.registerCorsConfiguration("/**", config);
return source;
| 91
| 117
| 208
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/security/sensitive/SensitiveJsonSerializer.java
|
SensitiveJsonSerializer
|
createContextual
|
class SensitiveJsonSerializer extends JsonSerializer<String>
implements ContextualSerializer, ApplicationContextAware {
private SensitiveStrategy strategy;
//系统配置
private SystemSettingProperties systemSettingProperties;
@Override
public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
// 字段序列化处理
gen.writeString(strategy.desensitizer().apply(value));
}
@Override
public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {<FILL_FUNCTION_BODY>}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
systemSettingProperties = applicationContext.getBean(SystemSettingProperties.class);
}
/**
* 是否需要脱敏处理
*
* @return
*/
private boolean desensitization() {
//当前用户
AuthUser authUser = UserContext.getCurrentUser();
//默认脱敏
if (authUser == null) {
return false;
}
//如果是店铺
if (authUser.getRole().equals(UserEnums.STORE)) {
//店铺需要进行脱敏，则脱敏处理
return systemSettingProperties.getSensitiveLevel() == 2;
}
//如果是店铺
if (authUser.getRole().equals(UserEnums.MANAGER)) {
//店铺需要进行脱敏，则脱敏处理
return systemSettingProperties.getSensitiveLevel() >= 1;
}
return false;
}
}
|
// 判定是否 需要脱敏处理
if (desensitization()) {
//获取敏感枚举
Sensitive annotation = property.getAnnotation(Sensitive.class);
//如果有敏感注解，则加入脱敏规则
if (Objects.nonNull(annotation) && Objects.equals(String.class, property.getType().getRawClass())) {
this.strategy = annotation.strategy();
return this;
}
}
return prov.findValueSerializer(property.getType(), property);
| 406
| 137
| 543
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/security/token/SecretKeyUtil.java
|
SecretKeyUtil
|
generalKey
|
class SecretKeyUtil {
public static SecretKey generalKey() {<FILL_FUNCTION_BODY>}
public static SecretKey generalKeyByDecoders() {
return Keys.hmacShaKeyFor(Decoders.BASE64.decode("cuAihCz53DZRjZwbsGcZJ2Ai6At+T142uphtJMsk7iQ="));
}
}
|
//自定义
byte[] encodedKey = Base64.decodeBase64("cuAihCz53DZRjZwbsGcZJ2Ai6At+T142uphtJMsk7iQ=");
SecretKey key = Keys.hmacShaKeyFor(encodedKey);
return key;
| 110
| 88
| 198
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/security/token/TokenUtil.java
|
TokenUtil
|
createToken
|
class TokenUtil {
@Autowired
private JWTTokenProperties tokenProperties;
@Autowired
private Cache cache;
/**
* 构建token
*
* @param authUser 私有声明
* @return TOKEN
*/
public Token createToken(AuthUser authUser) {
Token token = new Token();
//访问token
String accessToken = createToken(authUser, tokenProperties.getTokenExpireTime());
cache.put(CachePrefix.ACCESS_TOKEN.getPrefix(authUser.getRole(), authUser.getId()) + accessToken, 1,
tokenProperties.getTokenExpireTime(), TimeUnit.MINUTES);
//刷新token生成策略：如果是长时间有效的token（用于app），则默认15天有效期刷新token。如果是普通用户登录，则刷新token为普通token2倍数
Long expireTime = authUser.getLongTerm() ? 15 * 24 * 60L : tokenProperties.getTokenExpireTime() * 2;
String refreshToken = createToken(authUser, expireTime);
cache.put(CachePrefix.REFRESH_TOKEN.getPrefix(authUser.getRole(), authUser.getId()) + refreshToken, 1, expireTime, TimeUnit.MINUTES);
token.setAccessToken(accessToken);
token.setRefreshToken(refreshToken);
return token;
}
/**
* 刷新token
*
* @param oldRefreshToken 刷新token
* @return token
*/
public Token refreshToken(String oldRefreshToken) {
Claims claims;
try {
claims = Jwts.parser()
.setSigningKey(SecretKeyUtil.generalKeyByDecoders())
.parseClaimsJws(oldRefreshToken).getBody();
} catch (ExpiredJwtException | UnsupportedJwtException | MalformedJwtException | SignatureException |
IllegalArgumentException e) {
//token 过期 认证失败等
throw new ServiceException(ResultCode.USER_AUTH_EXPIRED);
}
//获取存储在claims中的用户信息
String json = claims.get(SecurityEnum.USER_CONTEXT.getValue()).toString();
AuthUser authUser = new Gson().fromJson(json, AuthUser.class);
UserEnums userEnums = authUser.getRole();
String username = authUser.getUsername();
//获取是否长期有效的token
boolean longTerm = authUser.getLongTerm();
//如果缓存中有刷新token &&
if (cache.hasKey(CachePrefix.REFRESH_TOKEN.getPrefix(userEnums, authUser.getId()) + oldRefreshToken)) {
Token token = new Token();
//访问token
String accessToken = createToken(authUser, tokenProperties.getTokenExpireTime());
cache.put(CachePrefix.ACCESS_TOKEN.getPrefix(userEnums, authUser.getId()) + accessToken, 1, tokenProperties.getTokenExpireTime(),
TimeUnit.MINUTES);
//如果是信任登录设备，则刷新token长度继续延长
Long expirationTime = tokenProperties.getTokenExpireTime() * 2;
if (longTerm) {
expirationTime = 60 * 24 * 15L;
authUser.setLongTerm(true);
}
//刷新token生成策略：如果是长时间有效的token（用于app），则默认15天有效期刷新token。如果是普通用户登录，则刷新token为普通token2倍数
String refreshToken = createToken(authUser, expirationTime);
cache.put(CachePrefix.REFRESH_TOKEN.getPrefix(userEnums, authUser.getId()) + refreshToken, 1, expirationTime, TimeUnit.MINUTES);
token.setAccessToken(accessToken);
token.setRefreshToken(refreshToken);
cache.remove(CachePrefix.REFRESH_TOKEN.getPrefix(userEnums, authUser.getId()) + oldRefreshToken);
return token;
} else {
throw new ServiceException(ResultCode.USER_AUTH_EXPIRED);
}
}
/**
* 生成token
*
* @param authUser jwt主体对象
* @param expirationTime 过期时间（分钟）
* @return token字符串
*/
private String createToken(AuthUser authUser, Long expirationTime) {<FILL_FUNCTION_BODY>}
}
|
//JWT 生成
return Jwts.builder()
//jwt 私有声明
.claim(SecurityEnum.USER_CONTEXT.getValue(), new Gson().toJson(authUser))
//JWT的主体
.setSubject(authUser.getUsername())
//失效时间 当前时间+过期分钟
.setExpiration(new Date(System.currentTimeMillis() + expirationTime * 60 * 1000))
//签名算法和密钥
.signWith(SecretKeyUtil.generalKey())
.compact();
| 1,164
| 150
| 1,314
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/sensitive/StringPointer.java
|
StringPointer
|
nextStartsWith
|
class StringPointer implements Serializable, CharSequence, Comparable<StringPointer> {
private static final long serialVersionUID = 1L;
protected final char[] value;
protected final int offset;
protected final int length;
private int hash = 0;
public StringPointer(String str) {
value = str.toCharArray();
offset = 0;
length = value.length;
}
public StringPointer(char[] value, int offset, int length) {
this.value = value;
this.offset = offset;
this.length = length;
}
/**
* 计算该位置后（包含）2个字符的hash值
*
* @param i 从 0 到 length - 2
* @return 从 0 到 length - 2
*/
public int nextTwoCharHash(int i) {
return 31 * value[offset + i] + value[offset + i + 1];
}
/**
* 计算该位置后（包含）2个字符和为1个int型的值<br/>
* int值相同表示2个字符相同
*
* @param i 从 0 到 length - 2
* @return int值
*/
public int nextTwoCharMix(int i) {
return (value[offset + i] << 16) | value[offset + i + 1];
}
/**
* 该位置后（包含）的字符串，是否以某个词（word）开头
*
* @param i 从 0 到 length - 2
* @param word 词
* @return 是否？
*/
public boolean nextStartsWith(int i, StringPointer word) {<FILL_FUNCTION_BODY>}
/**
* 填充（替换）
*
* @param begin 从此位置开始（含）
* @param end 到此位置结束（不含）
* @param fillWith 以此字符填充（替换）
*/
public void fill(int begin, int end, char fillWith) {
for (int i = begin; i < end; i++) {
value[offset + i] = fillWith;
}
}
@Override
public int length() {
return length;
}
@Override
public char charAt(int i) {
return value[offset + i];
}
public StringPointer substring(int begin) {
return new StringPointer(value, offset + begin, length - begin);
}
public StringPointer substring(int begin, int end) {
return new StringPointer(value, offset + begin, end - begin);
}
@Override
public CharSequence subSequence(int start, int end) {
return substring(start, end);
}
@Override
public String toString() {
return new String(value, offset, length);
}
@Override
public int hashCode() {
int h = hash;
if (h == 0 && length > 0) {
for (int i = 0; i < length; i++) {
h = 31 * h + value[offset + i];
}
hash = h;
}
return h;
}
@Override
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof StringPointer) {
StringPointer that = (StringPointer) anObject;
if (length == that.length) {
char[] v1 = this.value;
char[] v2 = that.value;
for (int i = 0; i < this.length; i++) {
if (v1[this.offset + i] != v2[that.offset + i]) {
return false;
}
}
return true;
}
}
return false;
}
@Override
public int compareTo(StringPointer that) {
int len1 = this.length;
int len2 = that.length;
int lim = Math.min(len1, len2);
char[] v1 = this.value;
char[] v2 = that.value;
int k = 0;
while (k < lim) {
char c1 = v1[this.offset + k];
char c2 = v2[that.offset + k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}
}
|
//是否长度超出
if (word.length > length - i) {
return false;
}
//从尾开始判断
for (int c = word.length - 1; c >= 0; c--) {
if (value[offset + i + c] != word.value[word.offset + c]) {
return false;
}
}
return true;
| 1,188
| 102
| 1,290
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/sensitive/init/SensitiveWordsLoader.java
|
SensitiveWordsLoader
|
run
|
class SensitiveWordsLoader implements ApplicationRunner {
@Autowired
private Cache<List<String>> cache;
/**
* 程序启动时，获取最新的需要过滤的敏感词
* <p>
* 这里即便缓存中为空也没关系，定时任务会定时重新加载敏感词
*
* @param args 启动参数
*/
@Override
public void run(ApplicationArguments args) {<FILL_FUNCTION_BODY>}
}
|
List<String> sensitives = cache.get(CachePrefix.SENSITIVE.getPrefix());
log.info("系统初始化敏感词");
if (sensitives == null || sensitives.isEmpty()) {
return;
}
SensitiveWordsFilter.init(sensitives);
| 128
| 76
| 204
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/sensitive/quartz/QuartzConfig.java
|
QuartzConfig
|
sensitiveQuartzTrigger
|
class QuartzConfig {
@Bean
public JobDetail sensitiveQuartzDetail() {
return JobBuilder.newJob(SensitiveQuartz.class).withIdentity("sensitiveQuartz").storeDurably().build();
}
@Bean
public Trigger sensitiveQuartzTrigger() {<FILL_FUNCTION_BODY>}
}
|
SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(3600)
.repeatForever();
return TriggerBuilder.newTrigger().forJob(sensitiveQuartzDetail())
.withIdentity("sensitiveQuartz")
.withSchedule(scheduleBuilder)
.build();
| 91
| 91
| 182
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/sensitive/quartz/SensitiveQuartz.java
|
SensitiveQuartz
|
executeInternal
|
class SensitiveQuartz extends QuartzJobBean {
@Autowired
private Cache<List<String>> cache;
/**
* 定时更新敏感词信息
*
* @param jobExecutionContext
*/
@Override
protected void executeInternal(JobExecutionContext jobExecutionContext) {<FILL_FUNCTION_BODY>}
}
|
log.info("敏感词定时更新");
List<String> sensitives = cache.get(CachePrefix.SENSITIVE.getPrefix());
if (sensitives == null || sensitives.isEmpty()) {
return;
}
SensitiveWordsFilter.init(sensitives);
| 93
| 75
| 168
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/thread/ThreadConfig.java
|
ThreadConfig
|
getAsyncExecutor
|
class ThreadConfig implements AsyncConfigurer {
@Autowired
private ThreadProperties threadProperties;
@Override
public Executor getAsyncExecutor() {<FILL_FUNCTION_BODY>}
}
|
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
// 核心线程数，默认为5
executor.setCorePoolSize(threadProperties.getCorePoolSize());
// 最大线程数，默认为10
executor.setMaxPoolSize(threadProperties.getMaxPoolSize());
// 队列最大长度，一般需要设置值为足够大
executor.setQueueCapacity(threadProperties.getQueueCapacity());
// 线程池维护线程所允许的空闲时间，默认为60s
executor.setKeepAliveSeconds(threadProperties.getKeepAliveSeconds());
// 允许超时关闭
executor.setAllowCoreThreadTimeOut(threadProperties.getAllowCoreThreadTimeOut());
executor.initialize();
return executor;
| 57
| 203
| 260
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/BeanUtil.java
|
BeanUtil
|
getFiledName
|
class BeanUtil {
/**
* 复制属性
*
* @param objectFrom 源自对象
* @param objectTo 复制给对象
*/
public static void copyProperties(Object objectFrom, Object objectTo) {
BeanUtils.copyProperties(objectFrom, objectTo);
}
/**
* 获取属性名数组
*
* @param o 获取字段的对象
* @return 返回各个字段
*/
public static String[] getFiledName(Object o) {<FILL_FUNCTION_BODY>}
/**
* 根据属性名获取属性值
*
* @param fieldName 属性名
* @param o 对象
* @return 属性值
*/
public static Object getFieldValueByName(String fieldName, Object o) {
try {
String firstLetter = fieldName.substring(0, 1).toUpperCase();
String getter = "get" + firstLetter + fieldName.substring(1);
Method method = o.getClass().getMethod(getter, new Class[]{});
Object value = method.invoke(o, new Object[]{});
return value;
} catch (Exception e) {
return null;
}
}
/**
* 将对象转换为key value
* A=a&B=b&C=c 格式
*
* @param object 对象
* @return 格式化结果
*/
public static String formatKeyValuePair(Object object) {
//准备接受的字符串
StringBuilder stringBuffer = new StringBuilder();
//获取对象字段
String[] fieldNames = BeanUtil.getFiledName(object);
//遍历所有属性
for (int j = 0; j < fieldNames.length; j++) {
//不是第一个并且不是最后一个，拼接&
if (j != 0) {
stringBuffer.append("&");
}
//获取属性的名字
String key = fieldNames[j];
//获取值
Object value = BeanUtil.getFieldValueByName(key, object);
assert value != null;
stringBuffer.append(key).append("=").append(value.toString());
}
return stringBuffer.toString();
}
/**
* key value键值对 转换为 对象
* A=a&B=b&C=c 格式 转换为对象
*
* @param str 对象字符串
* @param t 范型
* @param <T> 范型
* @return 格式化结果
*/
public static <T> T formatKeyValuePair(String str, T t) {
//填写对参数键值对
String[] params = str.split("&");
//获取对象字段
String[] fieldNames = BeanUtil.getFiledName(t);
try {
//循环每个参数
for (String param : params) {
String[] keyValues = param.split("=");
for (int i = 0; i < fieldNames.length; i++) {
if (fieldNames[i].equals(keyValues[0])) {
Field f = t.getClass().getDeclaredField(fieldNames[i]);
f.setAccessible(true);
//长度为2 才转换，否则不转
if (keyValues.length == 2) {
f.set(t, keyValues[1]);
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return t;
}
}
|
Field[] fields = o.getClass().getDeclaredFields();
Field[] superFields = o.getClass().getSuperclass().getDeclaredFields();
String[] fieldNames = new String[fields.length + superFields.length];
int index = 0;
for (int i = 0; i < fields.length; i++) {
fieldNames[index] = fields[i].getName();
index++;
}
for (int i = 0; i < superFields.length; i++) {
if ("id".equals(superFields[i].getName())) {
continue;
}
fieldNames[index] = superFields[i].getName();
index++;
}
return fieldNames;
| 935
| 179
| 1,114
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/CommonUtil.java
|
CommonUtil
|
rename
|
class CommonUtil {
public static final String BASE_NUMBER = "0123456789";
/**
* 以UUID重命名
* @param fileName 文件名称
* @return 格式化名称
*/
public static String rename(String fileName) {<FILL_FUNCTION_BODY>}
/**
* 随机6位数生成
*/
public static String getRandomNum() {
StringBuilder sb = new StringBuilder(6);
for (int i = 0; i < 6; i++) {
int num = ThreadLocalRandom.current().nextInt(BASE_NUMBER.length());
sb.append(BASE_NUMBER.charAt(num));
}
return sb.toString();
}
/**
* 获取特定字符 + 6位随机数
* @return
*/
public static String getSpecialStr(String value) {
return value + getRandomNum();
}
}
|
String extName = fileName.substring(fileName.lastIndexOf("."));
return UUID.randomUUID().toString().replace("-", "") + extName;
| 255
| 44
| 299
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/CookieUtil.java
|
CookieUtil
|
addCookie
|
class CookieUtil {
/**
* 新增cookie
*
* @param key key值
* @param value 对应值
* @param maxAge cookie 有效时间
* @param response 响应
*/
public static void addCookie(String key, String value, Integer maxAge, HttpServletResponse response) {<FILL_FUNCTION_BODY>}
/**
* 删除cookie
*
* @param key key值
* @param response 响应
*/
public static void delCookie(String key, HttpServletResponse response) {
try {
Cookie c = new Cookie(key, "");
c.setMaxAge(0);
response.addCookie(c);
} catch (Exception e) {
log.error("删除cookie错误",e);
}
}
/**
* 获取cookie
*
* @param key key值
* @param request 请求
* @return cookie value
*/
public static String getCookie(String key, HttpServletRequest request) {
try {
if (request.getCookies() == null) {
return null;
}
for (int i = 0; i < request.getCookies().length; i++) {
if (request.getCookies()[i].getName().equals(key)) {
return request.getCookies()[i].getValue();
}
}
} catch (Exception e) {
log.error("获取cookie错误",e);
}
return null;
}
}
|
try {
Cookie c = new Cookie(key, value);
c.setMaxAge(maxAge);
c.setPath("/");
response.addCookie(c);
} catch (Exception e) {
log.error("新增cookie错误",e);
}
| 409
| 77
| 486
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/CurrencyUtil.java
|
CurrencyUtil
|
mul
|
class CurrencyUtil {
/**
* 默认除法运算精度
*/
private static final int DEF_DIV_SCALE = 2;
/**
* 这个类不能实例化
*/
private CurrencyUtil() {
}
/**
* 提供精确的加法运算。
*
* @return 累加之和
*/
public static Double add(double... params) {
BigDecimal result = new BigDecimal("0");
for (double param : params) {
BigDecimal bigParam = BigDecimal.valueOf(param);
result = result.add(bigParam).setScale(2, RoundingMode.HALF_UP);
}
return result.doubleValue();
}
/**
* 提供精确的减法运算。
*
* @return 第一个参数为被减数，其余数字为减数
*/
public static Double sub(double... params) {
BigDecimal result = BigDecimal.valueOf(params[0]);
params = Arrays.stream(params).skip(1).toArray();
for (double param : params) {
BigDecimal bigParam = BigDecimal.valueOf(param);
result = result.subtract(bigParam).setScale(2, RoundingMode.HALF_UP);
}
return result.doubleValue();
}
/**
* 提供精确的乘法运算。
*
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static Double mul(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.multiply(b2).setScale(2, RoundingMode.HALF_UP).doubleValue();
}
/**
* 提供精确的乘法运算。
*
* @param v1 被乘数
* @param v2 乘数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的积
*/
public static Double mul(double v1, double v2, int scale) {<FILL_FUNCTION_BODY>}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时， 精确到小数点以后10位，以后的数字四舍五入。
*
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double div(double v1, double v2) {
return div(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。 当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。
*
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div(double v1, double v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
//如果被除数等于0，则返回0
if (v2 == 0) {
return 0;
}
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
}
/**
* 金额转分
*
* @param money 金额
* @return 转换单位为分
*/
public static Integer fen(Double money) {
double price = mul(money, 100);
return (int) price;
}
/**
* 金额转分
*
* @param money 金额
* @return double类型分
*/
public static double reversalFen(Double money) {
return div(money, 100);
}
}
|
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2);
return b1.multiply(b2).setScale(scale, RoundingMode.HALF_UP).doubleValue();
| 1,124
| 102
| 1,226
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/HttpClientUtils.java
|
HttpClientUtils
|
init
|
class HttpClientUtils {
/**
* org.apache.http.impl.client.CloseableHttpClient
*/
private static CloseableHttpClient httpClient = null;
//这里就直接默认固定了,因为以下三个参数在新建的method中仍然可以重新配置并被覆盖.
/**
* ms毫秒,从池中获取链接超时时间
*/
static final int CONNECTION_REQUEST_TIMEOUT = 30000;
/**
* ms毫秒,建立链接超时时间
*/
static final int CONNECT_TIMEOUT = 60000;
/**
* ms毫秒,读取超时时间
*/
static final int SOCKET_TIMEOUT = 60000;
/**
* 总配置,主要涉及是以下两个参数,如果要作调整没有用到properties会比较后麻烦,但鉴于一经粘贴,随处可用的特点,就不再做依赖性配置化处理了.
* 而且这个参数同一家公司基本不会变动.
* 最大总并发,很重要的参数
*/
static final int MAX_TOTAL = 500;
/**
* 每路并发,很重要的参数
*/
static final int MAX_PER_ROUTE = 100;
/**
* 正常情况这里应该配成MAP或LIST
* 细化配置参数,用来对每路参数做精细化处理,可以管控各ip的流量,比如默认配置请求baidu:80端口最大100个并发链接,
* 每个细化配置之ip(不重要,在特殊场景很有用)
*/
static final String DETAIL_HOST_NAME = "http://www.baidu.com";
/**
* 每个细化配置之port(不重要,在特殊场景很有用)
*/
static final int DETAIL_PORT = 80;
/**
* 每个细化配置之最大并发数(不重要,在特殊场景很有用)
*/
static final int DETAIL_MAX_PER_ROUTE = 100;
private synchronized static CloseableHttpClient getHttpClient() {
if (null == httpClient) {
httpClient = init();
}
return httpClient;
}
/**
* 链接池初始化 这里最重要的一点理解就是. 让CloseableHttpClient 一直活在池的世界里, 但是HttpPost却一直用完就消掉.
* 这样可以让链接一直保持着.
*/
private static CloseableHttpClient init() {<FILL_FUNCTION_BODY>}
public static String doGet(String url, Map<String, String> param) {
//httpClient
CloseableHttpClient httpClient = getHttpClient();
String resultString = "";
CloseableHttpResponse response = null;
try {
//创建uri
URIBuilder builder = new URIBuilder(url);
if (param != null) {
for (String key : param.keySet()) {
builder.addParameter(key, param.get(key));
}
}
URI uri = builder.build();
//创建http GET请求
HttpGet httpGet = new HttpGet(uri);
//执行请求
response = httpClient.execute(httpGet);
//判断返回状态是否为200
if (response.getStatusLine().getStatusCode() == 200) {
resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
}
} catch (Exception e) {
log.error("get请求错误", e);
} finally {
try {
if (response != null) {
response.close();
}
} catch (IOException e) {
log.error("Get错误", e);
}
}
return resultString;
}
}
|
CloseableHttpClient newHotpoint;
//设置连接池
ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create().register("http", plainsf).register("https", sslsf).build();
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
//将最大连接数增加
cm.setMaxTotal(MAX_TOTAL);
//将每个路由基础的连接增加
cm.setDefaultMaxPerRoute(MAX_PER_ROUTE);
//细化配置开始,其实这里用Map或List的for循环来配置每个链接,在特殊场景很有用.
//将每个路由基础的连接做特殊化配置,一般用不着
HttpHost httpHost = new HttpHost(DETAIL_HOST_NAME, DETAIL_PORT);
//将目标主机的最大连接数增加
cm.setMaxPerRoute(new HttpRoute(httpHost), DETAIL_MAX_PER_ROUTE);
//细化配置结束
//请求重试处理
HttpRequestRetryHandler httpRequestRetryHandler = (exception, executionCount, context) -> {
if (executionCount >= 2) {//如果已经重试了2次，就放弃
return false;
}
if (exception instanceof NoHttpResponseException) {//如果服务器丢掉了连接，那么就重试
return true;
}
if (exception instanceof SSLHandshakeException) {//不要重试SSL握手异常
return false;
}
if (exception instanceof InterruptedIOException) {//超时
return false;
}
if (exception instanceof UnknownHostException) {//目标服务器不可达
return false;
}
if (exception instanceof SSLException) {//SSL握手异常
return false;
}
HttpClientContext clientContext = HttpClientContext.adapt(context);
HttpRequest request = clientContext.getRequest();
//如果请求是幂等的，就再次尝试
return !(request instanceof HttpEntityEnclosingRequest);
};
//配置请求的超时设置
RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(CONNECTION_REQUEST_TIMEOUT).setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
newHotpoint = HttpClients.custom().setConnectionManager(cm).setDefaultRequestConfig(requestConfig).setRetryHandler(httpRequestRetryHandler).build();
return newHotpoint;
| 976
| 650
| 1,626
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/IpHelper.java
|
IpHelper
|
getIpCity
|
class IpHelper {
/**
* qq lbs 地区查询key
*/
@Value("${lili.lbs.key}")
private String key;
/**
* qq lbs 地区查询key
*/
@Value("${lili.lbs.sk}")
private String sk;
private static final String API = "https://apis.map.qq.com";
/**
* 获取IP返回地理信息
*
* @param request 请求参数
* @return 城市信息
*/
public String getIpCity(HttpServletRequest request) {<FILL_FUNCTION_BODY>}
}
|
String url = "/ws/location/v1/ip?key=" + key + "&ip=" + IpUtils.getIpAddress(request);
String sign = SecureUtil.md5(url + sk);
url = API + url + "&sign=" + sign;
String result = "未知";
try {
String json = HttpUtil.get(url, 3000);
JsonObject jsonObject = JsonParser.parseString(json).getAsJsonObject();
String status = jsonObject.get("status").getAsString();
if ("0".equals(status)) {
JsonObject address = jsonObject.get("result").getAsJsonObject().get("ad_info").getAsJsonObject();
String nation = address.get("nation").getAsString();
String province = address.get("province").getAsString();
String city = address.get("city").getAsString();
String district = address.get("district").getAsString();
if (StrUtil.isNotBlank(nation) && StrUtil.isBlank(province)) {
result = nation;
} else {
result = province;
if (StrUtil.isNotBlank(city)) {
result += " " + city;
}
if (StrUtil.isNotBlank(district)) {
result += " " + district;
}
}
}
} catch (Exception e) {
log.info("获取IP地理信息失败");
}
return result;
| 175
| 379
| 554
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/JasyptUtil.java
|
JasyptUtil
|
decryptPwd
|
class JasyptUtil {
/**
* Jasypt生成加密结果
* @param password 配置文件中设定的加密密码 jasypt.encryptor.password
* @param value 待加密值
* @return 加密字符串
*/
public static String encryptPwd(String password, String value){
PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
encryptor.setConfig(encryptor(password));
return encryptor.encrypt(value);
}
/**
* 解密
* @param password 配置文件中设定的加密密码 jasypt.encryptor.password
* @param value 待解密密文
* @return 揭秘字符串
*/
public static String decryptPwd(String password, String value){<FILL_FUNCTION_BODY>}
/**
* 加密处理
* @param password 密码
* @return 加密字符串
*/
public static SimpleStringPBEConfig encryptor(String password){
SimpleStringPBEConfig config = new SimpleStringPBEConfig();
config.setPassword(password);
config.setAlgorithm("PBEWITHHMACSHA512ANDAES_256");
config.setKeyObtentionIterations("1000");
config.setPoolSize(1);
config.setProviderName("SunJCE");
config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
config.setIvGeneratorClassName("org.jasypt.iv.RandomIvGenerator");
config.setStringOutputType("base64");
return config;
}
public static void main(String[] args){
//加密 若修改了第一个参数加密password记得在配置文件同步修改
System.out.println(encryptPwd("jasypt.encryptor.password","123456"));
//解密
System.out.println(decryptPwd("jasypt.encryptor.password","PYVnAYh+j5C3jkMV1d+myj6JzDaUk7pcfTWUaYsvQdEVkuvIVf7Y0mOU9XkffxT8"));
}
}
|
PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
encryptor.setConfig(encryptor(password));
encryptor.decrypt(value);
return encryptor.decrypt(value);
| 593
| 65
| 658
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/RegularUtil.java
|
RegularUtil
|
sqlReplace
|
class RegularUtil {
/**
* 手机号
*/
private static final Pattern MOBILE = Pattern.compile("^1[3|4|5|8][0-9]\\d{8}$");
/**
* 邮箱
*/
private static final Pattern EMAIL = Pattern.compile("^[a-zA-Z0-9_.-]+@[a-zA-Z0-9-]+(\\.[a-zA-Z0-9-]+)*\\.[a-zA-Z0-9]{2,6}$");
//sql正则
static Pattern sqlPattern = Pattern.compile("(select|update|and|delete|insert|trancate|char|substr|ascii|declare|exec|count|master|into|drop|execute" +
// 可能涉及英文查询参数问题
// "|in|not in exists|not exists" +
// "|between|not between" +
// "|like|not like" +
// "|is null|is not null" +
")", Pattern.CASE_INSENSITIVE);
//符号正则
static Pattern symbolPattern = Pattern.compile("[\\s~·`!！@#￥$%^……&*（()）\\-——\\-_=+【\\[\\]】｛{}｝\\|、\\\\；;：:‘'“”\"，,《<。.》>、/？?]");
/**
* 校验手机号
*
* @param v
* @return
*/
public static boolean mobile(String v) {
Matcher m = MOBILE.matcher(v);
if (m.matches()) {
return true;
}
return false;
}
//校验邮箱
public static boolean email(String v) {
Matcher m = EMAIL.matcher(v);
if (m.matches()) {
return true;
}
return false;
}
/**
* 搜索参数过滤
*
* @param str 字符串
* @return 过滤后的字符串
*/
public static String replace(String str) {
return symbolReplace(sqlReplace(str));
}
/**
* 过滤sql关键字
*
* @param str 字符串
* @return 过滤后的字符串
*/
public static String sqlReplace(String str) {<FILL_FUNCTION_BODY>}
/**
* 符号过滤
*
* @param str 字符串
* @return 过滤后的字符串
*/
public static String symbolReplace(String str) {
if (StringUtils.isEmpty(str)) {
return "";
}
Matcher symbolMatcher = symbolPattern.matcher(str);
return symbolMatcher.replaceAll("");
}
public static void main(String[] args) {
System.out.println(replace("selectSELECTINORNOTIN123阿松大asdfa!@#$%^&&*()_+{}[]！？>?").trim());
}
}
|
if (StringUtils.isEmpty(str)) {
return "";
}
Matcher sqlMatcher = sqlPattern.matcher(str);
return sqlMatcher.replaceAll("");
| 823
| 49
| 872
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/SnowflakeInitiator.java
|
SnowflakeInitiator
|
init
|
class SnowflakeInitiator {
/**
* 缓存前缀
*/
private static final String KEY = "{Snowflake}";
@Autowired
private Cache cache;
/**
* 尝试初始化
*
* @return
*/
@PostConstruct
public void init() {<FILL_FUNCTION_BODY>}
public static void main(String[] args) {
SnowFlake.initialize(0, 8);
System.out.println(SnowFlake.getId());
}
}
|
Long num = cache.incr(KEY);
long dataCenter = num / 32;
long workedId = num % 32;
//如果数据中心大于32，则抹除缓存，从头开始
if (dataCenter >= 32) {
cache.remove(KEY);
num = cache.incr(KEY);
dataCenter = num / 32;
workedId = num % 32;
}
SnowFlake.initialize(workedId, dataCenter);
| 149
| 130
| 279
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/SpelUtil.java
|
SpelUtil
|
compileParams
|
class SpelUtil {
/**
* spel表达式解析器
*/
private static SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
/**
* 参数名发现器
*/
private static DefaultParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
/**
* 转换 jspl参数
*
* @param joinPoint
* @param spel
* @return
*/
public static String compileParams(JoinPoint joinPoint, String spel) {<FILL_FUNCTION_BODY>}
/**
* 转换 jspl参数
*
* @param joinPoint
* @param spel
* @return
*/
public static String compileParams(JoinPoint joinPoint, Object rvt, String spel) { //Spel表达式解析日志信息
//获得方法参数名数组
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
String[] parameterNames = parameterNameDiscoverer.getParameterNames(signature.getMethod());
if (parameterNames != null && parameterNames.length > 0) {
EvaluationContext context = new StandardEvaluationContext();
//获取方法参数值
Object[] args = joinPoint.getArgs();
for (int i = 0; i < args.length; i++) {
//替换spel里的变量值为实际值， 比如 #user --> user对象
context.setVariable(parameterNames[i], args[i]);
}
context.setVariable("rvt", rvt);
return spelExpressionParser.parseExpression(spel).getValue(context).toString();
}
return "";
}
}
|
//Spel表达式解析日志信息
//获得方法参数名数组
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
String[] parameterNames = parameterNameDiscoverer.getParameterNames(signature.getMethod());
if (parameterNames != null && parameterNames.length > 0) {
EvaluationContext context = new StandardEvaluationContext();
//获取方法参数值
Object[] args = joinPoint.getArgs();
for (int i = 0; i < args.length; i++) {
//替换spel里的变量值为实际值， 比如 #user --> user对象
context.setVariable(parameterNames[i], args[i]);
}
return spelExpressionParser.parseExpression(spel).getValue(context).toString();
}
return "";
| 424
| 200
| 624
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/StringUtils.java
|
StringUtils
|
toFen
|
class StringUtils extends StrUtil {
/**
* MD5加密方法
*
* @param str String
* @return String
*/
public static String md5(String str) {
MessageDigest messageDigest = null;
try {
messageDigest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException ex) {
ex.printStackTrace();
return null;
}
byte[] resultByte = messageDigest.digest(str.getBytes());
StringBuffer result = new StringBuffer();
for (int i = 0; i < resultByte.length; ++i) {
int v = 0xFF & resultByte[i];
if (v < 16) {
result.append("0");
}
result.append(Integer.toHexString(v));
}
return result.toString();
}
/**
* 获取随机数
*
* @param n 随机次数
* @return
*/
public static String getRandStr(int n) {
Random random = new Random();
String sRand = "";
for (int i = 0; i < n; i++) {
String rand = String.valueOf(random.nextInt(10));
sRand += rand;
}
return sRand;
}
/**
* 切个字符串，如果超出长度则切割
*
* @param var
* @param size
* @return
*/
public static String subStringLength(String var, Integer size) {
if (var.length() > size) {
return var.substring(0, (size - 4)).toString() + "...";
}
return var;
}
/**
* 对象转map
*
* @param obj
* @return
* @throws Exception
*/
public static Map<String, Object> objectToMap(Object obj) throws Exception {
if (obj == null) {
return null;
}
Map<String, Object> map = new HashMap<String, Object>(16);
BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor property : propertyDescriptors) {
String key = property.getName();
if (key.compareToIgnoreCase("class") == 0) {
continue;
}
Method getter = property.getReadMethod();
Object value = getter != null ? getter.invoke(obj) : null;
map.put(key, value);
}
return map;
}
/**
* 驼峰法转下划线
*/
public static String camel2Underline(String str) {
if (StrUtil.isBlank(str)) {
return "";
}
if (str.length() == 1) {
return str.toLowerCase();
}
StringBuffer sb = new StringBuffer();
for (int i = 1; i < str.length(); i++) {
if (Character.isUpperCase(str.charAt(i))) {
sb.append("_" + Character.toLowerCase(str.charAt(i)));
} else {
sb.append(str.charAt(i));
}
}
return (str.charAt(0) + sb.toString()).toLowerCase();
}
/**
* 如果给定字符串{@code str}中不包含{@code appendStr}，则在{@code str}后追加{@code appendStr}；
* 如果已包含{@code appendStr}，则在{@code str}后追加{@code otherwise}
*
* @param str 给定的字符串
* @param appendStr 需要追加的内容
* @param otherwise 当{@code appendStr}不满足时追加到{@code str}后的内容
* @return 追加后的字符串
*/
public static String appendIfNotContain(String str, String appendStr, String otherwise) {
if (isEmpty(str) || isEmpty(appendStr)) {
return str;
}
if (str.contains(appendStr)) {
return str.concat(otherwise);
}
return str.concat(appendStr);
}
/**
* 切割字符串
*
* @param str 字符串
* @param length 长度
* @return 处理后的字符串
*/
public static String sub(String str, Integer length) {
if (str.length() < length) {
return str;
}
return str.substring(0, length);
}
/**
* 过滤特殊字符串
*
* @param str
* @return
*/
public static String filterSpecialChart(String str) {
String regEx = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(str);
return m.replaceAll("").trim();
}
/**
* double 转价格字符串
*
* @return
*/
public static String toFen(Double doubleValue) {<FILL_FUNCTION_BODY>}
}
|
String str = doubleValue.toString();
if (!str.contains(".")) {
str = str + ".00";
} else if (str.substring(str.indexOf(".")).length() == 2) {
str = str + "0";
}
return str;
| 1,414
| 75
| 1,489
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/utils/UrlBuilder.java
|
UrlBuilder
|
queryParam
|
class UrlBuilder {
private final Map<String, String> params = new LinkedHashMap<>(7);
private String baseUrl;
private UrlBuilder() {
}
/**
* @param baseUrl 基础路径
* @return the new {@code UrlBuilder}
*/
public static UrlBuilder fromBaseUrl(String baseUrl) {
UrlBuilder builder = new UrlBuilder();
builder.setBaseUrl(baseUrl);
return builder;
}
/**
* 只读的参数Map
*
* @return unmodifiable Map
* @since 1.15.0
*/
public Map<String, Object> getReadOnlyParams() {
return Collections.unmodifiableMap(params);
}
/**
* 添加参数
*
* @param key 参数名称
* @param value 参数值
* @return this UrlBuilder
*/
public UrlBuilder queryParam(String key, Object value) {<FILL_FUNCTION_BODY>}
/**
* 添加参数
*
* @param value 参数值
* @return this UrlBuilder
*/
public UrlBuilder pathAppend(String value) {
if (StringUtils.isEmpty(value)) {
throw new RuntimeException("参数不能为空");
}
this.setBaseUrl(this.baseUrl += value);
return this;
}
/**
* 构造url
*
* @return url
*/
public String build() {
return this.build(false);
}
/**
* 构造url
*
* @param encode 转码
* @return url
*/
public String build(boolean encode) {
if (MapUtil.isEmpty(this.params)) {
return this.baseUrl;
}
String baseUrl = StringUtils.appendIfNotContain(this.baseUrl, "?", "&");
String paramString = MapUtil.parseMapToString(this.params, encode);
return baseUrl + paramString;
}
}
|
if (StringUtils.isEmpty(key)) {
throw new RuntimeException("参数名不能为空");
}
String valueAsString = (value != null ? value.toString() : null);
this.params.put(key, valueAsString);
return this;
| 534
| 71
| 605
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/validation/impl/MobileValidator.java
|
MobileValidator
|
isValid
|
class MobileValidator implements ConstraintValidator<Mobile, String> {
private static final Pattern PHONE = Pattern.compile("^0?(13[0-9]|14[0-9]|15[0-9]|16[0-9]|17[0-9]|18[0-9]|19[0-9])[0-9]{8}$");
private static final Pattern AREA_MOBILE = Pattern.compile("0\\d{2,3}[-]?\\d{7,8}|0\\d{2,3}\\s?\\d{7,8}|13[0-9]\\d{8}|15[1089]\\d{8}");
private static final Pattern MOBILE = Pattern.compile("^[1-9]{1}[0-9]{5,8}$");
@Override
public boolean isValid(String value, ConstraintValidatorContext constraintValidatorContext) {<FILL_FUNCTION_BODY>}
@Override
public void initialize(Mobile constraintAnnotation) {
}
}
|
Matcher m = null;
// 验证手机号
if (value.length() == 11) {
m = PHONE.matcher(value);
// 验证带区号的电话
} else if (value.length() > 9) {
m = AREA_MOBILE.matcher(value);
//验证没有区号的电话
} else {
m = MOBILE.matcher(value);
}
return m.matches();
| 274
| 124
| 398
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/vo/PageVO.java
|
PageVO
|
getSort
|
class PageVO implements Serializable {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "页号")
private Integer pageNumber = 1;
@ApiModelProperty(value = "页面大小")
private Integer pageSize = 10;
@ApiModelProperty(value = "排序字段")
private String sort;
@ApiModelProperty(value = "排序方式 asc/desc")
private String order;
@ApiModelProperty(value = "需要驼峰转换蛇形", notes = "一般不做处理，如果数据库中就是蛇形，则这块需要处理。")
private Boolean notConvert;
public String getSort() {<FILL_FUNCTION_BODY>}
}
|
if (CharSequenceUtil.isNotEmpty(sort)) {
if (notConvert == null || Boolean.FALSE.equals(notConvert)) {
return StringUtils.camel2Underline(sort);
} else {
return sort;
}
}
return sort;
| 190
| 72
| 262
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/common/vo/SearchVO.java
|
SearchVO
|
getConvertStartDate
|
class SearchVO implements Serializable {
@ApiModelProperty(value = "起始日期")
private String startDate;
@ApiModelProperty(value = "结束日期")
private String endDate;
public Date getConvertStartDate() {<FILL_FUNCTION_BODY>}
public Date getConvertEndDate() {
if (StringUtils.isEmpty(endDate)) {
return null;
}
//结束时间等于结束日期+1天 -1秒，
Date date = DateUtil.toDate(endDate, DateUtil.STANDARD_DATE_FORMAT);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.DAY_OF_MONTH, calendar.get(Calendar.DAY_OF_MONTH) + 1);
calendar.set(Calendar.SECOND, -1);
return calendar.getTime();
}
}
|
if (StringUtils.isEmpty(startDate)) {
return null;
}
return DateUtil.toDate(startDate, DateUtil.STANDARD_DATE_FORMAT);
| 229
| 47
| 276
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/elasticsearch/config/ElasticsearchConfig.java
|
ElasticsearchConfig
|
clientClose
|
class ElasticsearchConfig extends AbstractElasticsearchConfiguration {
@Autowired
private ElasticsearchProperties elasticsearchProperties;
private RestHighLevelClient client;
@Override
@Bean
public RestHighLevelClient elasticsearchClient() {
String username = elasticsearchProperties.getAccount().getUsername();
String password = elasticsearchProperties.getAccount().getPassword();
final CredentialsProvider credential = createCredentialsIfNotNull(username, password);
RestClientBuilder restBuilder = createRestClientBuilderWithConfig(credential);
client = new RestHighLevelClient(restBuilder);
return client;
}
private CredentialsProvider createCredentialsIfNotNull(String username, String password) {
if (username == null || password == null) {
return null;
}
final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
return credentialsProvider;
}
private RestClientBuilder createRestClientBuilderWithConfig(CredentialsProvider credentialsProvider) {
return RestClient
.builder(this.getHttpHosts())
.setHttpClientConfigCallback(httpClientBuilder -> configureHttpClientBuilder(httpClientBuilder, credentialsProvider))
.setRequestConfigCallback(requestConfigBuilder ->
requestConfigBuilder
.setConnectTimeout(1000)
.setSocketTimeout(12 * 1000));
}
private HttpAsyncClientBuilder configureHttpClientBuilder(HttpAsyncClientBuilder httpClientBuilder,
CredentialsProvider credentialsProvider) {
httpClientBuilder
.setKeepAliveStrategy(getConnectionKeepAliveStrategy())
.setMaxConnPerRoute(10)
.setDefaultIOReactorConfig(
IOReactorConfig
.custom()
.setIoThreadCount(Runtime.getRuntime().availableProcessors())
.build());
if (credentialsProvider != null) {
httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
}
return httpClientBuilder;
}
private HttpHost[] getHttpHosts() {
List<String> clusterNodes = elasticsearchProperties.getClusterNodes();
HttpHost[] httpHosts = new HttpHost[clusterNodes.size()];
for (int i = 0; i < clusterNodes.size(); i++) {
String[] node = clusterNodes.get(i).split(":");
httpHosts[i] = new HttpHost(node[0], Convert.toInt(node[1]), elasticsearchProperties.getSchema());
}
return httpHosts;
}
private ConnectionKeepAliveStrategy getConnectionKeepAliveStrategy() {
return (response, context) -> 2 * 60 * 1000;
}
/**
* it gets called when bean instance is getting removed from the context if
* scope is not a prototype
* If there is a method named shutdown or close then spring container will try
* to automatically configure them as callback methods when bean is being
* destroyed
*/
@PreDestroy
public void clientClose() {<FILL_FUNCTION_BODY>}
}
|
try {
this.client.close();
} catch (IOException e) {
log.error("es clientClose错误", e);
}
| 783
| 40
| 823
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/connect/request/BaseAuthAlipayRequest.java
|
BaseAuthAlipayRequest
|
getUserInfo
|
class BaseAuthAlipayRequest extends BaseAuthRequest {
private final AlipayClient alipayClient;
public BaseAuthAlipayRequest(AuthConfig config, Cache cache) {
super(config, ConnectAuthEnum.ALIPAY, cache);
this.alipayClient = new DefaultAlipayClient(ConnectAuthEnum.ALIPAY.accessToken(), config.getClientId(), config.getClientSecret(), "json", "UTF-8", config
.getAlipayPublicKey(), "RSA2");
}
@Override
protected AuthToken getAccessToken(AuthCallback authCallback) {
AlipaySystemOauthTokenRequest request = new AlipaySystemOauthTokenRequest();
request.setGrantType("authorization_code");
request.setCode(authCallback.getAuthCode());
AlipaySystemOauthTokenResponse response = null;
try {
response = this.alipayClient.execute(request);
} catch (Exception e) {
throw new AuthException(e);
}
if (!response.isSuccess()) {
throw new AuthException(response.getSubMsg());
}
return AuthToken.builder()
.accessToken(response.getAccessToken())
.uid(response.getUserId())
.expireIn(Convert.toInt(response.getExpiresIn()))
.refreshToken(response.getRefreshToken())
.build();
}
/**
* 刷新access token （续期）
*
* @param authToken 登录成功后返回的Token信息
* @return AuthResponse
*/
@Override
public AuthResponse refresh(AuthToken authToken) {
AlipaySystemOauthTokenRequest request = new AlipaySystemOauthTokenRequest();
request.setGrantType("refresh_token");
request.setRefreshToken(authToken.getRefreshToken());
AlipaySystemOauthTokenResponse response = null;
try {
response = this.alipayClient.execute(request);
} catch (Exception e) {
throw new AuthException(e);
}
if (!response.isSuccess()) {
throw new AuthException(response.getSubMsg());
}
return AuthResponse.builder()
.code(AuthResponseStatus.SUCCESS.getCode())
.data(AuthToken.builder()
.accessToken(response.getAccessToken())
.uid(response.getUserId())
.expireIn(Convert.toInt(response.getExpiresIn()))
.refreshToken(response.getRefreshToken())
.build())
.build();
}
@Override
protected ConnectAuthUser getUserInfo(AuthToken authToken) {<FILL_FUNCTION_BODY>}
/**
* 返回带{@code state}参数的授权url，授权回调时会带上这个{@code state}
*
* @param state state 验证授权流程的参数，可以防止csrf
* @return 返回授权地址
* @since 1.9.3
*/
@Override
public String authorize(String state) {
return UrlBuilder.fromBaseUrl(source.authorize())
.queryParam("app_id", config.getClientId())
.queryParam("scope", "auth_user")
.queryParam("redirect_uri", config.getRedirectUri())
.queryParam("state", getRealState(state))
.build();
}
}
|
String accessToken = authToken.getAccessToken();
AlipayUserInfoShareRequest request = new AlipayUserInfoShareRequest();
AlipayUserInfoShareResponse response = null;
try {
response = this.alipayClient.execute(request, accessToken);
} catch (AlipayApiException e) {
throw new AuthException(e.getErrMsg(), e);
}
if (!response.isSuccess()) {
throw new AuthException(response.getSubMsg());
}
String province = response.getProvince(), city = response.getCity();
String location = String.format("%s %s", StringUtils.isEmpty(province) ? "" : province, StringUtils.isEmpty(city) ? "" : city);
return ConnectAuthUser.builder()
.rawUserInfo(JSONObject.parseObject(JSONObject.toJSONString(response)))
.uuid(response.getUserId())
.username(StringUtils.isEmpty(response.getUserName()) ? response.getNickName() : response.getUserName())
.nickname(response.getNickName())
.avatar(response.getAvatar())
.location(location)
.gender(AuthUserGender.getRealGender(response.getGender()))
.token(authToken)
.source(ConnectEnum.ALIPAY)
.build();
| 873
| 339
| 1,212
|
<methods>public void <init>(cn.lili.modules.connect.config.AuthConfig, cn.lili.modules.connect.config.ConnectAuth, Cache#RAW) ,public java.lang.String authorize(java.lang.String) ,public AuthResponse#RAW login(cn.lili.modules.connect.entity.dto.AuthCallback) <variables>protected Cache#RAW cache,protected cn.lili.modules.connect.config.AuthConfig config,protected cn.lili.modules.connect.config.ConnectAuth source
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/connect/request/BaseAuthQQRequest.java
|
BaseAuthQQRequest
|
getOpenId
|
class BaseAuthQQRequest extends BaseAuthRequest {
public BaseAuthQQRequest(AuthConfig config, Cache cache) {
super(config, ConnectAuthEnum.QQ, cache);
}
@Override
protected AuthToken getAccessToken(AuthCallback authCallback) {
String response = doGetAuthorizationCode(authCallback.getCode());
return getAuthToken(response);
}
@Override
public AuthResponse refresh(AuthToken authToken) {
String response = new HttpUtils(config.getHttpConfig()).get(refreshTokenUrl(authToken.getRefreshToken()));
return AuthResponse.builder().code(AuthResponseStatus.SUCCESS.getCode()).data(getAuthToken(response)).build();
}
@Override
protected ConnectAuthUser getUserInfo(AuthToken authToken) {
String openId = this.getOpenId(authToken);
String response = doGetUserInfo(authToken);
JSONObject object = JSONObject.parseObject(response);
if (object.getIntValue("ret") != 0) {
throw new AuthException(object.getString("msg"));
}
String avatar = object.getString("figureurl_qq_2");
if (StringUtils.isEmpty(avatar)) {
avatar = object.getString("figureurl_qq_1");
}
String location = String.format("%s-%s", object.getString("province"), object.getString("city"));
return ConnectAuthUser.builder()
.rawUserInfo(object)
.username(object.getString("nickname"))
.nickname(object.getString("nickname"))
.avatar(avatar)
.location(location)
.uuid(openId)
.gender(AuthUserGender.getRealGender(object.getString("gender")))
.token(authToken)
.source(ConnectEnum.QQ)
.type(ClientTypeEnum.PC)
.build();
}
/**
* 获取QQ用户的OpenId，支持自定义是否启用查询unionid的功能，如果启用查询unionid的功能，
* 那就需要开发者先通过邮件申请unionid功能，参考链接 {@see http://wiki.connect.qq.com/unionid%E4%BB%8B%E7%BB%8D}
*
* @param authToken 通过{@link BaseAuthQQRequest#getAccessToken(AuthCallback)}获取到的{@code authToken}
* @return openId
*/
private String getOpenId(AuthToken authToken) {<FILL_FUNCTION_BODY>}
/**
* 返回获取userInfo的url
*
* @param authToken 用户授权token
* @return 返回获取userInfo的url
*/
@Override
protected String userInfoUrl(AuthToken authToken) {
return UrlBuilder.fromBaseUrl(source.userInfo())
.queryParam("access_token", authToken.getAccessToken())
.queryParam("oauth_consumer_key", config.getClientId())
.queryParam("openid", authToken.getOpenId())
.build();
}
private AuthToken getAuthToken(String response) {
Map<String, String> accessTokenObject = GlobalAuthUtils.parseStringToMap(response);
if (!accessTokenObject.containsKey("access_token") || accessTokenObject.containsKey("code")) {
throw new AuthException(accessTokenObject.get("msg"));
}
return AuthToken.builder()
.accessToken(accessTokenObject.get("access_token"))
.expireIn(Convert.toInt(accessTokenObject.getOrDefault("expires_in", "0")))
.refreshToken(accessTokenObject.get("refresh_token"))
.build();
}
@Override
public String authorize(String state) {
return UrlBuilder.fromBaseUrl(super.authorize(state))
.queryParam("scope", "get_user_info")
.build();
}
}
|
String response = new HttpUtils(config.getHttpConfig()).get(UrlBuilder.fromBaseUrl("https://graph.qq.com/oauth2.0/me")
.queryParam("access_token", authToken.getAccessToken())
.queryParam("unionid", config.isUnionId() ? 1 : 0)
.build());
String removePrefix = response.replace("callback(", "");
String removeSuffix = removePrefix.replace(");", "");
String openId = removeSuffix.trim();
JSONObject object = JSONObject.parseObject(openId);
if (object.containsKey("error")) {
throw new AuthException(object.get("error") + ":" + object.get("error_description"));
}
authToken.setOpenId(object.getString("openid"));
if (object.containsKey("unionid")) {
authToken.setUnionId(object.getString("unionid"));
}
return StringUtils.isEmpty(authToken.getUnionId()) ? authToken.getOpenId() : authToken.getUnionId();
| 1,007
| 270
| 1,277
|
<methods>public void <init>(cn.lili.modules.connect.config.AuthConfig, cn.lili.modules.connect.config.ConnectAuth, Cache#RAW) ,public java.lang.String authorize(java.lang.String) ,public AuthResponse#RAW login(cn.lili.modules.connect.entity.dto.AuthCallback) <variables>protected Cache#RAW cache,protected cn.lili.modules.connect.config.AuthConfig config,protected cn.lili.modules.connect.config.ConnectAuth source
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/connect/request/BaseAuthWeChatPCRequest.java
|
BaseAuthWeChatPCRequest
|
userInfoUrl
|
class BaseAuthWeChatPCRequest extends BaseAuthRequest {
public BaseAuthWeChatPCRequest(AuthConfig config, Cache cache) {
super(config, ConnectAuthEnum.WECHAT_PC, cache);
}
/**
* 微信的特殊性，此时返回的信息同时包含 openid 和 access_token
*
* @param authCallback 回调返回的参数
* @return 所有信息
*/
@Override
protected AuthToken getAccessToken(AuthCallback authCallback) {
return this.getToken(accessTokenUrl(authCallback.getCode()));
}
@Override
protected ConnectAuthUser getUserInfo(AuthToken authToken) {
String response = doGetUserInfo(authToken);
JSONObject object = JSONObject.parseObject(response);
this.checkResponse(object);
String location = String.format("%s-%s-%s", object.getString("country"), object.getString("province"), object.getString("city"));
if (object.containsKey("unionid")) {
authToken.setUnionId(object.getString("unionid"));
}
return ConnectAuthUser.builder()
.rawUserInfo(object)
.username(object.getString("nickname"))
.nickname(object.getString("nickname"))
.avatar(object.getString("headimgurl"))
.location(location)
.uuid(authToken.getOpenId())
.gender(AuthUserGender.getWechatRealGender(object.getString("sex")))
.token(authToken)
.source(ConnectEnum.WECHAT)
.type(ClientTypeEnum.PC)
.build();
}
@Override
public AuthResponse refresh(AuthToken oldToken) {
return AuthResponse.builder()
.code(AuthResponseStatus.SUCCESS.getCode())
.data(this.getToken(refreshTokenUrl(oldToken.getRefreshToken())))
.build();
}
/**
* 检查响应内容是否正确
*
* @param object 请求响应内容
*/
private void checkResponse(JSONObject object) {
if (object.containsKey("errcode")) {
throw new AuthException(object.getIntValue("errcode"), object.getString("errmsg"));
}
}
/**
* 获取token，适用于获取access_token和刷新token
*
* @param accessTokenUrl 实际请求token的地址
* @return token对象
*/
private AuthToken getToken(String accessTokenUrl) {
String response = new HttpUtils(config.getHttpConfig()).get(accessTokenUrl);
JSONObject accessTokenObject = JSONObject.parseObject(response);
this.checkResponse(accessTokenObject);
return AuthToken.builder()
.accessToken(accessTokenObject.getString("access_token"))
.refreshToken(accessTokenObject.getString("refresh_token"))
.expireIn(accessTokenObject.getIntValue("expires_in"))
.openId(accessTokenObject.getString("openid"))
.scope(accessTokenObject.getString("scope"))
.build();
}
/**
* 返回带{@code state}参数的授权url，授权回调时会带上这个{@code state}
*
* @param state state 验证授权流程的参数，可以防止csrf
* @return 返回授权地址
* @since 1.9.3
*/
@Override
public String authorize(String state) {
return UrlBuilder.fromBaseUrl(source.authorize())
.queryParam("response_type", "code")
.queryParam("appid", config.getClientId())
.queryParam("redirect_uri", config.getRedirectUri())
.queryParam("scope", "snsapi_login")
.queryParam("state", getRealState(state))
.build();
}
/**
* 返回获取accessToken的url
*
* @param code 授权码
* @return 返回获取accessToken的url
*/
@Override
protected String accessTokenUrl(String code) {
return UrlBuilder.fromBaseUrl(source.accessToken())
.queryParam("appid", config.getClientId())
.queryParam("secret", config.getClientSecret())
.queryParam("code", code)
.queryParam("grant_type", "authorization_code")
.build();
}
/**
* 返回获取userInfo的url
*
* @param authToken 用户授权后的token
* @return 返回获取userInfo的url
*/
@Override
protected String userInfoUrl(AuthToken authToken) {<FILL_FUNCTION_BODY>}
/**
* 返回获取userInfo的url
*
* @param refreshToken getAccessToken方法返回的refreshToken
* @return 返回获取userInfo的url
*/
@Override
protected String refreshTokenUrl(String refreshToken) {
return UrlBuilder.fromBaseUrl(source.refresh())
.queryParam("appid", config.getClientId())
.queryParam("grant_type", "refresh_token")
.queryParam("refresh_token", refreshToken)
.build();
}
}
|
return UrlBuilder.fromBaseUrl(source.userInfo())
.queryParam("access_token", authToken.getAccessToken())
.queryParam("openid", authToken.getOpenId())
.queryParam("lang", "zh_CN")
.build();
| 1,346
| 71
| 1,417
|
<methods>public void <init>(cn.lili.modules.connect.config.AuthConfig, cn.lili.modules.connect.config.ConnectAuth, Cache#RAW) ,public java.lang.String authorize(java.lang.String) ,public AuthResponse#RAW login(cn.lili.modules.connect.entity.dto.AuthCallback) <variables>protected Cache#RAW cache,protected cn.lili.modules.connect.config.AuthConfig config,protected cn.lili.modules.connect.config.ConnectAuth source
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/connect/request/BaseAuthWeChatRequest.java
|
BaseAuthWeChatRequest
|
getUserInfo
|
class BaseAuthWeChatRequest extends BaseAuthRequest {
public BaseAuthWeChatRequest(AuthConfig config, Cache cache) {
super(config, ConnectAuthEnum.WECHAT, cache);
}
/**
* 微信的特殊性，此时返回的信息同时包含 openid 和 access_token
*
* @param authCallback 回调返回的参数
* @return 所有信息
*/
@Override
protected AuthToken getAccessToken(AuthCallback authCallback) {
return this.getToken(accessTokenUrl(authCallback.getCode()));
}
@Override
protected ConnectAuthUser getUserInfo(AuthToken authToken) {<FILL_FUNCTION_BODY>}
@Override
public AuthResponse refresh(AuthToken oldToken) {
return AuthResponse.builder()
.code(AuthResponseStatus.SUCCESS.getCode())
.data(this.getToken(refreshTokenUrl(oldToken.getRefreshToken())))
.build();
}
/**
* 检查响应内容是否正确
*
* @param object 请求响应内容
*/
private void checkResponse(JSONObject object) {
if (object.containsKey("errcode")) {
throw new AuthException(object.getIntValue("errcode"), object.getString("errmsg"));
}
}
/**
* 获取token，适用于获取access_token和刷新token
*
* @param accessTokenUrl 实际请求token的地址
* @return token对象
*/
private AuthToken getToken(String accessTokenUrl) {
String response = new HttpUtils(config.getHttpConfig()).get(accessTokenUrl);
JSONObject accessTokenObject = JSONObject.parseObject(response);
this.checkResponse(accessTokenObject);
return AuthToken.builder()
.accessToken(accessTokenObject.getString("access_token"))
.refreshToken(accessTokenObject.getString("refresh_token"))
.expireIn(accessTokenObject.getIntValue("expires_in"))
.openId(accessTokenObject.getString("openid"))
.build();
}
/**
* 返回带{@code state}参数的授权url，授权回调时会带上这个{@code state}
*
* @param state state 验证授权流程的参数，可以防止csrf
* @return 返回授权地址
* @since 1.9.3
*/
@Override
public String authorize(String state) {
return UrlBuilder.fromBaseUrl(source.authorize())
.queryParam("appid", config.getClientId())
.queryParam("redirect_uri", GlobalAuthUtils.urlEncode(config.getRedirectUri()))
.queryParam("response_type", "code")
.queryParam("scope", "snsapi_userinfo")
.queryParam("state", getRealState(state).concat("#wechat_redirect"))
.build();
}
/**
* 返回获取accessToken的url
*
* @param code 授权码
* @return 返回获取accessToken的url
*/
@Override
protected String accessTokenUrl(String code) {
return UrlBuilder.fromBaseUrl(source.accessToken())
.queryParam("code", code)
.queryParam("appid", config.getClientId())
.queryParam("secret", config.getClientSecret())
.queryParam("grant_type", "authorization_code")
.build();
}
/**
* 返回获取userInfo的url
*
* @param authToken 用户授权后的token
* @return 返回获取userInfo的url
*/
@Override
protected String userInfoUrl(AuthToken authToken) {
return UrlBuilder.fromBaseUrl(source.userInfo())
.queryParam("access_token", authToken.getAccessToken())
.queryParam("openid", authToken.getOpenId())
.queryParam("lang", "zh_CN")
.build();
}
/**
* 返回获取userInfo的url
*
* @param refreshToken getAccessToken方法返回的refreshToken
* @return 返回获取userInfo的url
*/
@Override
protected String refreshTokenUrl(String refreshToken) {
return UrlBuilder.fromBaseUrl(source.refresh())
.queryParam("appid", config.getClientId())
.queryParam("refresh_token", refreshToken)
.queryParam("grant_type", "refresh_token")
.build();
}
}
|
String openId = authToken.getOpenId();
String response = doGetUserInfo(authToken);
JSONObject object = JSONObject.parseObject(response);
this.checkResponse(object);
String location = String.format("%s-%s-%s", object.getString("country"), object.getString("province"), object.getString("city"));
if (object.containsKey("unionid")) {
authToken.setUnionId(object.getString("unionid"));
}
return ConnectAuthUser.builder()
.rawUserInfo(object)
.username(object.getString("nickname"))
.nickname(object.getString("nickname"))
.avatar(object.getString("headimgurl"))
.location(location)
.uuid(openId)
.gender(AuthUserGender.getWechatRealGender(object.getString("sex")))
.token(authToken)
.source(ConnectEnum.WECHAT)
.type(ClientTypeEnum.H5)
.build();
| 1,163
| 263
| 1,426
|
<methods>public void <init>(cn.lili.modules.connect.config.AuthConfig, cn.lili.modules.connect.config.ConnectAuth, Cache#RAW) ,public java.lang.String authorize(java.lang.String) ,public AuthResponse#RAW login(cn.lili.modules.connect.entity.dto.AuthCallback) <variables>protected Cache#RAW cache,protected cn.lili.modules.connect.config.AuthConfig config,protected cn.lili.modules.connect.config.ConnectAuth source
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/connect/request/BaseAuthWeiboRequest.java
|
BaseAuthWeiboRequest
|
revoke
|
class BaseAuthWeiboRequest extends BaseAuthRequest {
public BaseAuthWeiboRequest(AuthConfig config, Cache cache) {
super(config, ConnectAuthEnum.WEIBO, cache);
}
@Override
protected AuthToken getAccessToken(AuthCallback authCallback) {
String response = doPostAuthorizationCode(authCallback.getCode());
JSONObject accessTokenObject = JSONObject.parseObject(response);
if (accessTokenObject.containsKey("error")) {
throw new AuthException(accessTokenObject.getString("error_description"));
}
return AuthToken.builder()
.accessToken(accessTokenObject.getString("access_token"))
.uid(accessTokenObject.getString("uid"))
.openId(accessTokenObject.getString("uid"))
.expireIn(accessTokenObject.getIntValue("expires_in"))
.build();
}
@Override
protected ConnectAuthUser getUserInfo(AuthToken authToken) {
String accessToken = authToken.getAccessToken();
String uid = authToken.getUid();
String oauthParam = String.format("uid=%s&access_token=%s", uid, accessToken);
HttpHeader httpHeader = new HttpHeader();
httpHeader.add("Authorization", "OAuth2 " + oauthParam);
httpHeader.add("API-RemoteIP", IpUtils.getLocalIp());
String userInfo = new HttpUtils(config.getHttpConfig()).get(userInfoUrl(authToken), null, httpHeader, false);
JSONObject object = JSONObject.parseObject(userInfo);
if (object.containsKey("error")) {
throw new AuthException(object.getString("error"));
}
return ConnectAuthUser.builder()
.rawUserInfo(object)
.uuid(object.getString("id"))
.username(object.getString("name"))
.avatar(object.getString("profile_image_url"))
.blog(StringUtils.isEmpty(object.getString("url")) ? "https://weibo.com/" + object.getString("profile_url") : object
.getString("url"))
.nickname(object.getString("screen_name"))
.location(object.getString("location"))
.remark(object.getString("description"))
.gender(AuthUserGender.getRealGender(object.getString("gender")))
.token(authToken)
.source(ConnectEnum.WEIBO)
.build();
}
/**
* 返回获取userInfo的url
*
* @param authToken authToken
* @return 返回获取userInfo的url
*/
@Override
protected String userInfoUrl(AuthToken authToken) {
return UrlBuilder.fromBaseUrl(source.userInfo())
.queryParam("access_token", authToken.getAccessToken())
.queryParam("uid", authToken.getUid())
.build();
}
@Override
public String authorize(String state) {
return UrlBuilder.fromBaseUrl(super.authorize(state))
.queryParam("scope", "all")
.build();
}
@Override
public AuthResponse revoke(AuthToken authToken) {<FILL_FUNCTION_BODY>}
}
|
String response = doGetRevoke(authToken);
JSONObject object = JSONObject.parseObject(response);
if (object.containsKey("error")) {
return AuthResponse.builder()
.code(AuthResponseStatus.FAILURE.getCode())
.msg(object.getString("error"))
.build();
}
//返回 result = true 表示取消授权成功，否则失败
AuthResponseStatus status = object.getBooleanValue("result") ? AuthResponseStatus.SUCCESS : AuthResponseStatus.FAILURE;
return AuthResponse.builder().code(status.getCode()).msg(status.getMsg()).build();
| 813
| 158
| 971
|
<methods>public void <init>(cn.lili.modules.connect.config.AuthConfig, cn.lili.modules.connect.config.ConnectAuth, Cache#RAW) ,public java.lang.String authorize(java.lang.String) ,public AuthResponse#RAW login(cn.lili.modules.connect.entity.dto.AuthCallback) <variables>protected Cache#RAW cache,protected cn.lili.modules.connect.config.AuthConfig config,protected cn.lili.modules.connect.config.ConnectAuth source
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/connect/util/AuthChecker.java
|
AuthChecker
|
checkCode
|
class AuthChecker {
/**
* 是否支持第三方登录
*
* @param config config
* @param connectAuth source
* @return true or false
* @since 1.6.1-beta
*/
public static boolean isSupportedAuth(AuthConfig config, ConnectAuth connectAuth) {
boolean isSupported = StringUtils.isNotEmpty(config.getClientId()) && StringUtils.isNotEmpty(config.getClientSecret()) && StringUtils.isNotEmpty(config.getRedirectUri());
if (isSupported && ConnectAuthEnum.ALIPAY == connectAuth) {
isSupported = StringUtils.isNotEmpty(config.getAlipayPublicKey());
}
return isSupported;
}
/**
* 检查配置合法性。针对部分平台， 对redirect uri有特定要求。一般来说redirect uri都是http://，而对于facebook平台， redirect uri 必须是https的链接
*
* @param config config
* @param connectAuth source
* @since 1.6.1-beta
*/
public static void checkConfig(AuthConfig config, ConnectAuth connectAuth) {
String redirectUri = config.getRedirectUri();
if (!GlobalAuthUtils.isHttpProtocol(redirectUri) && !GlobalAuthUtils.isHttpsProtocol(redirectUri)) {
throw new AuthException(AuthResponseStatus.ILLEGAL_REDIRECT_URI, connectAuth);
}
//支付宝在创建回调地址时，不允许使用localhost或者106.124.130.167
if (ConnectAuthEnum.ALIPAY == connectAuth && GlobalAuthUtils.isLocalHost(redirectUri)) {
//The redirect uri of alipay is forbidden to use localhost or 106.124.130.167
throw new AuthException(AuthResponseStatus.ILLEGAL_REDIRECT_URI, connectAuth);
}
}
/**
* 校验回调传回的code
* <p>
* {@code v1.10.0}版本中改为传入{@code source}和{@code callback}，对于不同平台使用不同参数接受code的情况统一做处理
*
* @param connectAuth 当前授权平台
* @param callback 从第三方授权回调回来时传入的参数集合
* @since 1.8.0
*/
public static void checkCode(ConnectAuth connectAuth, AuthCallback callback) {<FILL_FUNCTION_BODY>}
/**
* 校验回调传回的{@code state}，为空或者不存在
* <p>
* {@code state}不存在的情况只有两种：
* 1. {@code state}已使用，被正常清除
* 2. {@code state}为前端伪造，本身就不存在
*
* @param state {@code state}一定不为空
*/
public static void checkState(String state, ConnectAuth connectAuth, Cache cache) {
if (StringUtils.isEmpty(state) || !cache.hasKey(state)) {
throw new AuthException(AuthResponseStatus.ILLEGAL_STATUS, connectAuth);
}
}
}
|
String code = callback.getCode();
if (connectAuth == ConnectAuthEnum.ALIPAY) {
code = callback.getAuthCode();
}
if (StringUtils.isEmpty(code)) {
throw new AuthException(AuthResponseStatus.ILLEGAL_CODE, connectAuth);
}
| 807
| 78
| 885
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/distribution/entity/dto/DistributionGoodsSearchParams.java
|
DistributionGoodsSearchParams
|
distributionQueryWrapper
|
class DistributionGoodsSearchParams extends PageVO {
@ApiModelProperty(value = "商品ID")
private String goodsId;
@ApiModelProperty(value = "商品名称")
private String goodsName;
@ApiModelProperty(value = "是否已选择")
private boolean isChecked;
public <T> QueryWrapper<T> queryWrapper() {
QueryWrapper<T> queryWrapper = this.distributionQueryWrapper();
queryWrapper.eq(CharSequenceUtil.isNotEmpty(goodsId), "goods_id", goodsId);
queryWrapper.eq(CharSequenceUtil.isNotEmpty(goodsName), "goods_name", goodsId);
return queryWrapper;
}
public <T> QueryWrapper<T> storeQueryWrapper() {
QueryWrapper<T> queryWrapper = this.distributionQueryWrapper();
queryWrapper.eq("dg.store_id", Objects.requireNonNull(UserContext.getCurrentUser()).getStoreId());
return queryWrapper;
}
public <T> QueryWrapper<T> distributionQueryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
queryWrapper.like(CharSequenceUtil.isNotEmpty(goodsName), "dg.goods_name", goodsName);
return queryWrapper;
| 281
| 55
| 336
|
<methods>public non-sealed void <init>() ,public java.lang.String getSort() <variables>private java.lang.Boolean notConvert,private java.lang.String order,private java.lang.Integer pageNumber,private java.lang.Integer pageSize,private static final long serialVersionUID,private java.lang.String sort
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/distribution/entity/dto/DistributionSearchParams.java
|
DistributionSearchParams
|
queryWrapper
|
class DistributionSearchParams {
@ApiModelProperty(value = "会员名称")
private String memberName;
@ApiModelProperty(value = "分销员状态", allowableValues = "APPLY,RETREAT,REFUSE,PASS")
private String distributionStatus;
public <T> QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotEmpty(memberName), "member_name", memberName);
queryWrapper.eq(StringUtils.isNotEmpty(distributionStatus), "distribution_status", distributionStatus);
return queryWrapper;
| 100
| 74
| 174
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/distribution/entity/vos/DistributionCashSearchParams.java
|
DistributionCashSearchParams
|
queryWrapper
|
class DistributionCashSearchParams extends PageVO {
/**
* 编号
*/
@ApiModelProperty(value = "编号")
private String sn;
/**
* 会员名称
*/
@ApiModelProperty(value = "会员名称")
private String memberName;
/**
* 分销员提现状态
*/
@ApiModelProperty(value = "分销员提现状态",allowableValues = "APPLY,PASS,REFUSE")
private String distributionCashStatus;
public <T> QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
if (StringUtils.isNotEmpty(memberName)) {
queryWrapper.like("distribution_name", memberName);
}
if (StringUtils.isNotEmpty(sn)) {
queryWrapper.like("sn", sn);
}
if (StringUtils.isNotEmpty(distributionCashStatus)) {
queryWrapper.like("distribution_cash_status", distributionCashStatus);
}
return queryWrapper;
| 167
| 123
| 290
|
<methods>public non-sealed void <init>() ,public java.lang.String getSort() <variables>private java.lang.Boolean notConvert,private java.lang.String order,private java.lang.Integer pageNumber,private java.lang.Integer pageSize,private static final long serialVersionUID,private java.lang.String sort
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/distribution/entity/vos/DistributionOrderSearchParams.java
|
DistributionOrderSearchParams
|
queryWrapper
|
class DistributionOrderSearchParams extends PageVO {
private static final long serialVersionUID = -8736018687663645064L;
@ApiModelProperty(value = "分销员名称")
private String distributionName;
@ApiModelProperty(value = "订单sn")
private String orderSn;
@ApiModelProperty(value = "分销员ID", hidden = true)
private String distributionId;
@ApiModelProperty(value = "分销订单状态")
private String distributionOrderStatus;
@ApiModelProperty(value = "店铺ID")
private String storeId;
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "开始时间")
private Date startTime;
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value = "结束时间")
private Date endTime;
public <T> QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = Wrappers.query();
queryWrapper.like(StringUtils.isNotBlank(distributionName), "distribution_name", distributionName);
queryWrapper.eq(StringUtils.isNotBlank(distributionOrderStatus), "distribution_order_status", distributionOrderStatus);
queryWrapper.eq(StringUtils.isNotBlank(orderSn), "order_sn", orderSn);
queryWrapper.eq(StringUtils.isNotBlank(distributionId), "distribution_id", distributionId);
queryWrapper.eq(StringUtils.isNotBlank(storeId), "store_id", storeId);
if (endTime != null && startTime != null) {
endTime = DateUtil.endOfDate(endTime);
queryWrapper.between("create_time", startTime, endTime);
}
return queryWrapper;
| 344
| 211
| 555
|
<methods>public non-sealed void <init>() ,public java.lang.String getSort() <variables>private java.lang.Boolean notConvert,private java.lang.String order,private java.lang.Integer pageNumber,private java.lang.Integer pageSize,private static final long serialVersionUID,private java.lang.String sort
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/distribution/serviceimpl/DistributionCashServiceImpl.java
|
DistributionCashServiceImpl
|
cash
|
class DistributionCashServiceImpl extends ServiceImpl<DistributionCashMapper, DistributionCash> implements DistributionCashService {
/**
* 分销员
*/
@Autowired
private DistributionService distributionService;
/**
* 会员余额
*/
@Autowired
private MemberWalletService memberWalletService;
@Autowired
private RocketMQTemplate rocketMQTemplate;
@Autowired
private RocketmqCustomProperties rocketmqCustomProperties;
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean cash(Double applyMoney) {<FILL_FUNCTION_BODY>}
@Override
public IPage<DistributionCash> getDistributionCash(PageVO page) {
Distribution distribution = distributionService.getDistribution();
QueryWrapper<DistributionCash> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("distribution_id", distribution.getId());
return this.page(PageUtil.initPage(page), queryWrapper);
}
@Override
public IPage<DistributionCash> getDistributionCash(DistributionCashSearchParams distributionCashSearchParams) {
return this.page(PageUtil.initPage(distributionCashSearchParams), distributionCashSearchParams.queryWrapper());
}
@Override
@Transactional(rollbackFor = Exception.class)
public DistributionCash audit(String id, String result) {
//检查分销功能开关
distributionService.checkDistributionSetting();
//获取分销佣金信息
DistributionCash distributorCash = this.getById(id);
//只有分销员和分销佣金记录存在的情况才可以审核
if (distributorCash != null) {
//获取分销员
Distribution distribution = distributionService.getById(distributorCash.getDistributionId());
if (distribution != null && distribution.getDistributionStatus().equals(DistributionStatusEnum.PASS.name())) {
MemberWithdrawalMessage memberWithdrawalMessage = new MemberWithdrawalMessage();
//审核通过
if (result.equals(WithdrawStatusEnum.VIA_AUDITING.name())) {
memberWithdrawalMessage.setStatus(WithdrawStatusEnum.VIA_AUDITING.name());
//分销记录操作
distributorCash.setDistributionCashStatus(WithdrawStatusEnum.VIA_AUDITING.name());
distributorCash.setPayTime(new Date());
//提现到余额
memberWalletService.increase(new MemberWalletUpdateDTO(distributorCash.getPrice(), distribution.getMemberId(), "分销[" + distributorCash.getSn() + "]佣金提现到余额[" + distributorCash.getPrice() + "]", DepositServiceTypeEnum.WALLET_COMMISSION.name()));
} else {
memberWithdrawalMessage.setStatus(WithdrawStatusEnum.FAIL_AUDITING.name());
//分销员可提现金额退回
distribution.setCanRebate(CurrencyUtil.add(distribution.getCanRebate(), distributorCash.getPrice()));
distributorCash.setDistributionCashStatus(WithdrawStatusEnum.FAIL_AUDITING.name());
}
distribution.setCommissionFrozen(CurrencyUtil.sub(distribution.getCommissionFrozen(), distributorCash.getPrice()));
//分销员金额相关处理
distributionService.updateById(distribution);
//修改分销提现申请
boolean bool = this.updateById(distributorCash);
//if (bool) {
// //组织会员提现审核消息
// memberWithdrawalMessage.setMemberId(distribution.getMemberId());
// memberWithdrawalMessage.setPrice(distributorCash.getPrice());
// String destination = rocketmqCustomProperties.getMemberTopic() + ":" + MemberTagsEnum.MEMBER_WITHDRAWAL.name();
// rocketMQTemplate.asyncSend(destination, memberWithdrawalMessage, RocketmqSendCallbackBuilder.commonCallback());
//}
return distributorCash;
}
throw new ServiceException(ResultCode.DISTRIBUTION_NOT_EXIST);
}
throw new ServiceException(ResultCode.DISTRIBUTION_CASH_NOT_EXIST);
}
}
|
//检查分销功能开关
distributionService.checkDistributionSetting();
//获取分销员
Distribution distribution = distributionService.getDistribution();
//如果未找到分销员或者分销员状态不是已通过则无法申请提现
if (distribution != null && distribution.getDistributionStatus().equals(DistributionStatusEnum.PASS.name())) {
//校验分销佣金是否大于提现金额
if (distribution.getCanRebate() < applyMoney) {
throw new ServiceException(ResultCode.WALLET_WITHDRAWAL_INSUFFICIENT);
}
//将提现金额存入冻结金额,扣减可提现金额
distribution.setCanRebate(CurrencyUtil.sub(distribution.getCanRebate(), applyMoney));
distribution.setCommissionFrozen(CurrencyUtil.add(distribution.getCommissionFrozen(), applyMoney));
distributionService.updateById(distribution);
//提现申请记录
DistributionCash distributionCash = new DistributionCash("D" + SnowFlake.getId(), distribution.getId(), applyMoney, distribution.getMemberName());
boolean result = this.save(distributionCash);
if (result) {
//发送提现消息
MemberWithdrawalMessage memberWithdrawalMessage = new MemberWithdrawalMessage();
memberWithdrawalMessage.setMemberId(distribution.getMemberId());
memberWithdrawalMessage.setPrice(applyMoney);
memberWithdrawalMessage.setStatus(WithdrawStatusEnum.APPLY.name());
String destination = rocketmqCustomProperties.getMemberTopic() + ":" + MemberTagsEnum.MEMBER_WITHDRAWAL.name();
rocketMQTemplate.asyncSend(destination, memberWithdrawalMessage, RocketmqSendCallbackBuilder.commonCallback());
return true;
}
return false;
}
throw new ServiceException(ResultCode.DISTRIBUTION_NOT_EXIST);
| 1,119
| 500
| 1,619
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/distribution/serviceimpl/DistributionGoodsServiceImpl.java
|
DistributionGoodsServiceImpl
|
checked
|
class DistributionGoodsServiceImpl extends ServiceImpl<DistributionGoodsMapper, DistributionGoods> implements DistributionGoodsService {
/**
* 分销员
*/
@Autowired
private DistributionService distributionService;
/**
* 规格商品
*/
@Autowired
private GoodsSkuService goodsSkuService;
@Override
public IPage<DistributionGoodsVO> goodsPage(DistributionGoodsSearchParams searchParams) {
//获取商家的分销商品列表
if (Objects.requireNonNull(UserContext.getCurrentUser()).getRole().equals(UserEnums.STORE)) {
return this.baseMapper.getDistributionGoodsVO(PageUtil.initPage(searchParams), searchParams.storeQueryWrapper());
} else if (UserContext.getCurrentUser().getRole().equals(UserEnums.MEMBER)) {
//判断当前登录用户是否为分销员
Distribution distribution = distributionService.getDistribution();
if (distribution != null) {
//判断查看已选择的分销商品列表
if (searchParams.isChecked()) {
return this.baseMapper.selectGoods(PageUtil.initPage(searchParams), searchParams.distributionQueryWrapper(), distribution.getId());
} else {
return this.baseMapper.notSelectGoods(PageUtil.initPage(searchParams), searchParams.distributionQueryWrapper(), distribution.getId());
}
}
throw new ServiceException(ResultCode.DISTRIBUTION_NOT_EXIST);
}
//如果是平台则直接进行查询
return this.baseMapper.getDistributionGoodsVO(PageUtil.initPage(searchParams), searchParams.distributionQueryWrapper());
}
/**
* 根据条件查询分销商品信息列表
*
* @param distributionGoodsSearchParams 商品条件
* @return 分销商品信息列表
*/
@Override
public List<DistributionGoods> getDistributionGoodsList(DistributionGoodsSearchParams distributionGoodsSearchParams) {
return this.list(distributionGoodsSearchParams.queryWrapper());
}
/**
* 根据条件查询分销商品信息
*
* @param distributionGoodsSearchParams 条件
* @return 分销商品信息
*/
@Override
public DistributionGoods getDistributionGoods(DistributionGoodsSearchParams distributionGoodsSearchParams) {
return this.getOne(distributionGoodsSearchParams.queryWrapper(), false);
}
/**
* 根据条件删除分销商品
*
* @param distributionGoodsSearchParams 条件
*/
@Override
public boolean deleteDistributionGoods(DistributionGoodsSearchParams distributionGoodsSearchParams) {
return this.remove(distributionGoodsSearchParams.queryWrapper());
}
@Override
public DistributionGoods distributionGoodsVO(String id) {
return this.getById(id);
}
@Override
public DistributionGoods distributionGoodsVOBySkuId(String skuId) {
return this.getOne(new LambdaUpdateWrapper<DistributionGoods>().eq(DistributionGoods::getSkuId, skuId));
}
@Override
public List<DistributionGoods> distributionGoods(List<String> skuIds) {
return this.list(new LambdaUpdateWrapper<DistributionGoods>().in(DistributionGoods::getSkuId, skuIds));
}
@Override
public DistributionGoods checked(String skuId, Double commission, String storeId) {<FILL_FUNCTION_BODY>}
}
|
//检查分销功能开关
distributionService.checkDistributionSetting();
//判断是否存在分销商品，如果存在不能添加
QueryWrapper queryWrapper = Wrappers.query().eq("sku_id", skuId);
if (this.getOne(queryWrapper) != null) {
throw new ServiceException(ResultCode.DISTRIBUTION_GOODS_DOUBLE);
}
GoodsSku goodsSku = goodsSkuService.getGoodsSkuByIdFromCache(skuId);
if (!goodsSku.getStoreId().equals(storeId)) {
throw new ServiceException(ResultCode.USER_AUTHORITY_ERROR);
}
DistributionGoods distributionGoods = new DistributionGoods(goodsSku, commission);
this.save(distributionGoods);
return distributionGoods;
| 912
| 217
| 1,129
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/distribution/serviceimpl/DistributionSelectedGoodsServiceImpl.java
|
DistributionSelectedGoodsServiceImpl
|
add
|
class DistributionSelectedGoodsServiceImpl extends ServiceImpl<DistributionSelectedGoodsMapper, DistributionSelectedGoods> implements DistributionSelectedGoodsService {
/**
* 分销员
*/
@Autowired
private DistributionService distributionService;
@Override
public boolean add(String distributionGoodsId) {<FILL_FUNCTION_BODY>}
@Override
public boolean delete(String distributionGoodsId) {
//检查分销功能开关
distributionService.checkDistributionSetting();
String distributionId = distributionService.getDistribution().getId();
return this.remove(new LambdaQueryWrapper<DistributionSelectedGoods>()
.eq(DistributionSelectedGoods::getDistributionGoodsId, distributionGoodsId)
.eq(DistributionSelectedGoods::getDistributionId, distributionId));
}
@Override
public boolean deleteByDistributionGoodsId(String distributionGoodsId) {
return this.remove(new LambdaQueryWrapper<DistributionSelectedGoods>()
.eq(DistributionSelectedGoods::getDistributionGoodsId, distributionGoodsId));
}
}
|
//检查分销功能开关
distributionService.checkDistributionSetting();
String distributionId = distributionService.getDistribution().getId();
DistributionSelectedGoods distributionSelectedGoods = new DistributionSelectedGoods(distributionId, distributionGoodsId);
return this.save(distributionSelectedGoods);
| 283
| 77
| 360
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/distribution/serviceimpl/DistributionServiceImpl.java
|
DistributionServiceImpl
|
applyDistribution
|
class DistributionServiceImpl extends ServiceImpl<DistributionMapper, Distribution> implements DistributionService {
/**
* 会员
*/
@Autowired
private MemberService memberService;
/**
* 缓存
*/
@Autowired
private Cache cache;
/**
* 设置
*/
@Autowired
private SettingService settingService;
@Override
public IPage<Distribution> distributionPage(DistributionSearchParams distributionSearchParams, PageVO page) {
return this.page(PageUtil.initPage(page), distributionSearchParams.queryWrapper());
}
@Override
public Distribution getDistribution() {
return this.getOne(new LambdaQueryWrapper<Distribution>().eq(Distribution::getMemberId, UserContext.getCurrentUser().getId()));
}
@Override
@Transactional(rollbackFor = Exception.class)
public Distribution applyDistribution(DistributionApplyDTO distributionApplyDTO) {<FILL_FUNCTION_BODY>}
@Override
public boolean audit(String id, String status) {
//检查分销开关
checkDistributionSetting();
//根据id获取分销员
Distribution distribution = this.getById(id);
if (Optional.ofNullable(distribution).isPresent()) {
if (status.equals(DistributionStatusEnum.PASS.name())) {
distribution.setDistributionStatus(DistributionStatusEnum.PASS.name());
} else {
distribution.setDistributionStatus(DistributionStatusEnum.REFUSE.name());
}
return this.updateById(distribution);
}
return false;
}
@Override
public boolean retreat(String id) {
//检查分销开关
checkDistributionSetting();
//根据id获取分销员
Distribution distribution = this.getById(id);
if (Optional.ofNullable(distribution).isPresent()) {
distribution.setDistributionStatus(DistributionStatusEnum.RETREAT.name());
return this.updateById(distribution);
}
return false;
}
@Override
public boolean resume(String id) {
//检查分销开关
checkDistributionSetting();
//根据id获取分销员
Distribution distribution = this.getById(id);
if (Optional.ofNullable(distribution).isPresent()) {
distribution.setDistributionStatus(DistributionStatusEnum.PASS.name());
return this.updateById(distribution);
}
return false;
}
@Override
public void bindingDistribution(String distributionId) {
//判断用户是否登录，未登录不能进行绑定
if (UserContext.getCurrentUser() == null) {
throw new ServiceException(ResultCode.USER_NOT_LOGIN);
}
//储存分销关系时间
Distribution distribution = this.getById(distributionId);
if (distribution != null) {
Setting setting = settingService.get(SettingEnum.DISTRIBUTION_SETTING.name());
DistributionSetting distributionSetting = JSONUtil.toBean(setting.getSettingValue(), DistributionSetting.class);
cache.put(CachePrefix.DISTRIBUTION.getPrefix() + "_" + UserContext.getCurrentUser().getId(), distribution.getId(), distributionSetting.getDistributionDay().longValue(), TimeUnit.DAYS);
}
}
/**
* 检查分销设置开关
*/
@Override
public void checkDistributionSetting() {
//获取分销是否开启
Setting setting = settingService.get(SettingEnum.DISTRIBUTION_SETTING.name());
DistributionSetting distributionSetting = JSONUtil.toBean(setting.getSettingValue(), DistributionSetting.class);
if (Boolean.FALSE.equals(distributionSetting.getIsOpen())) {
throw new ServiceException(ResultCode.DISTRIBUTION_CLOSE);
}
}
@Override
public void subCanRebate(Double canRebate, String distributionId) {
this.baseMapper.subCanRebate(canRebate, distributionId);
}
@Override
public void addRebate(Double rebate, String distributionId) {
this.baseMapper.addCanRebate(rebate, distributionId);
}
}
|
//检查分销开关
checkDistributionSetting();
//判断用户是否申请过分销
Distribution distribution = getDistribution();
//如果分销员非空并未审核则提示用户请等待，如果分销员为拒绝状态则重新提交申请
if (Optional.ofNullable(distribution).isPresent()) {
switch (DistributionStatusEnum.valueOf(distribution.getDistributionStatus())) {
case REFUSE:
case RETREAT:
distribution.setDistributionStatus(DistributionStatusEnum.APPLY.name());
BeanUtil.copyProperties(distributionApplyDTO, distribution);
this.updateById(distribution);
return distribution;
default:
throw new ServiceException(ResultCode.DISTRIBUTION_IS_APPLY);
}
}else{
//如果未申请分销员则新增进行申请
//获取当前登录用户
Member member = memberService.getUserInfo();
//新建分销员
distribution = new Distribution(member.getId(), member.getNickName(), distributionApplyDTO);
//添加分销员
this.save(distribution);
}
return distribution;
| 1,084
| 295
| 1,379
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/file/entity/dto/FileOwnerDTO.java
|
FileOwnerDTO
|
getConvertEndDate
|
class FileOwnerDTO extends PageVO {
@ApiModelProperty(value = "拥有者id")
private String ownerId;
@ApiModelProperty(value = "拥有者名称")
private String ownerName;
@ApiModelProperty(value = "用户类型")
private String userEnums;
@ApiModelProperty(value = "原文件名")
private String name;
@ApiModelProperty(value = "存储文件名")
private String fileKey;
@ApiModelProperty(value = "文件类型")
private String fileType;
@ApiModelProperty(value = "文件夹ID")
private String fileDirectoryId;
@ApiModelProperty(value = "起始日期")
private String startDate;
@ApiModelProperty(value = "结束日期")
private String endDate;
public Date getConvertStartDate() {
if (StringUtils.isEmpty(startDate)) {
return null;
}
return DateUtil.toDate(startDate, DateUtil.STANDARD_DATE_FORMAT);
}
public Date getConvertEndDate() {<FILL_FUNCTION_BODY>}
}
|
if (StringUtils.isEmpty(endDate)) {
return null;
}
//结束时间等于结束日期+1天 -1秒，
Date date = DateUtil.toDate(endDate, DateUtil.STANDARD_DATE_FORMAT);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.DAY_OF_MONTH, calendar.get(Calendar.DAY_OF_MONTH) + 1);
calendar.set(Calendar.SECOND, -1);
return calendar.getTime();
| 294
| 140
| 434
|
<methods>public non-sealed void <init>() ,public java.lang.String getSort() <variables>private java.lang.Boolean notConvert,private java.lang.String order,private java.lang.Integer pageNumber,private java.lang.Integer pageSize,private static final long serialVersionUID,private java.lang.String sort
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/file/plugin/FilePluginFactory.java
|
FilePluginFactory
|
filePlugin
|
class FilePluginFactory {
@Autowired
private SettingService settingService;
/**
* 获取oss client
*
* @return
*/
public FilePlugin filePlugin() {<FILL_FUNCTION_BODY>}
}
|
OssSetting ossSetting = null;
try {
Setting setting = settingService.get(SettingEnum.OSS_SETTING.name());
ossSetting = JSONUtil.toBean(setting.getSettingValue(), OssSetting.class);
switch (OssEnum.valueOf(ossSetting.getType())) {
case MINIO:
return new MinioFilePlugin(ossSetting);
case ALI_OSS:
return new AliFilePlugin(ossSetting);
case HUAWEI_OBS:
return new HuaweiFilePlugin(ossSetting);
case TENCENT_COS:
return new TencentFilePlugin(ossSetting);
default:
throw new ServiceException();
}
} catch (Exception e) {
throw new ServiceException();
}
| 70
| 206
| 276
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/file/plugin/impl/AliFilePlugin.java
|
AliFilePlugin
|
inputStreamUpload
|
class AliFilePlugin implements FilePlugin {
private OssSetting ossSetting;
public AliFilePlugin(OssSetting ossSetting) {
this.ossSetting = ossSetting;
}
@Override
public OssEnum pluginName() {
return OssEnum.ALI_OSS;
}
/**
* 获取oss client
*
* @return
*/
private OSS getOssClient() {
return new OSSClientBuilder().build(
ossSetting.getAliyunOSSEndPoint(),
ossSetting.getAliyunOSSAccessKeyId(),
ossSetting.getAliyunOSSAccessKeySecret());
}
/**
* 获取配置前缀
*
* @return
*/
private String getUrlPrefix() {
return "https://" + ossSetting.getAliyunOSSBucketName() + "." + ossSetting.getAliyunOSSEndPoint() + "/";
}
@Override
public String pathUpload(String filePath, String key) {
OSS ossClient = getOssClient();
try {
ossClient.putObject(ossSetting.getAliyunOSSBucketName(), key, new File(filePath));
} catch (OSSException oe) {
log.error("Caught an OSSException, which means your request made it to OSS, "
+ "but was rejected with an error response for some reason.");
log.error("Error Message: " + oe.getErrorMessage());
log.error("Error Code: " + oe.getErrorCode());
log.error("Request ID: " + oe.getRequestId());
log.error("Host ID: " + oe.getHostId());
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} catch (ClientException ce) {
log.error("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ "such as not being able to access the network.");
log.error("Error Message: " + ce.getMessage());
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} finally {
/*
* Do not forget to shut down the client finally to release all allocated resources.
*/
ossClient.shutdown();
}
ossClient.shutdown();
return getUrlPrefix() + key;
}
@Override
public String inputStreamUpload(InputStream inputStream, String key) {<FILL_FUNCTION_BODY>}
@Override
public void deleteFile(List<String> key) {
OSS ossClient = getOssClient();
try {
ossClient.deleteObjects(
new DeleteObjectsRequest(ossSetting.getAliyunOSSBucketName()).withKeys(key));
} catch (OSSException oe) {
log.error("Caught an OSSException, which means your request made it to OSS, "
+ "but was rejected with an error response for some reason.");
log.error("Error Message: " + oe.getErrorMessage());
log.error("Error Code: " + oe.getErrorCode());
log.error("Request ID: " + oe.getRequestId());
log.error("Host ID: " + oe.getHostId());
throw new ServiceException(ResultCode.OSS_DELETE_ERROR);
} catch (ClientException ce) {
log.error("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ "such as not being able to access the network.");
log.error("Error Message: " + ce.getMessage());
throw new ServiceException(ResultCode.OSS_DELETE_ERROR);
} finally {
/*
* Do not forget to shut down the client finally to release all allocated resources.
*/
ossClient.shutdown();
}
}
}
|
OSS ossClient = getOssClient();
try {
ObjectMetadata meta = new ObjectMetadata();
meta.setContentType("image/jpg");
ossClient.putObject(ossSetting.getAliyunOSSBucketName(), key, inputStream, meta);
} catch (OSSException oe) {
log.error("Caught an OSSException, which means your request made it to OSS, "
+ "but was rejected with an error response for some reason.");
log.error("Error Message: " + oe.getErrorMessage());
log.error("Error Code: " + oe.getErrorCode());
log.error("Request ID: " + oe.getRequestId());
log.error("Host ID: " + oe.getHostId());
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} catch (ClientException ce) {
log.error("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ "such as not being able to access the network.");
log.error("Error Message: " + ce.getMessage());
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} finally {
/*
* Do not forget to shut down the client finally to release all allocated resources.
*/
ossClient.shutdown();
}
ossClient.shutdown();
return getUrlPrefix() + key;
| 1,008
| 369
| 1,377
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/file/plugin/impl/TencentFilePlugin.java
|
TencentFilePlugin
|
getCOSClient
|
class TencentFilePlugin implements FilePlugin {
private OssSetting ossSetting;
public TencentFilePlugin(OssSetting ossSetting) {
this.ossSetting = ossSetting;
}
@Override
public OssEnum pluginName() {
return OssEnum.TENCENT_COS;
}
/**
* 获取oss client
*
* @return
*/
private COSClient getCOSClient() {<FILL_FUNCTION_BODY>}
/**
* 获取配置前缀
*
* @return
*/
private String getUrlPrefix() {
return "https://" + ossSetting.getTencentCOSBucket() + ".cos." + ossSetting.getTencentCOSRegion() + ".myqcloud.com/";
}
@Override
public String pathUpload(String filePath, String key) {
COSClient cosClient = getCOSClient();
try {
cosClient.putObject(ossSetting.getTencentCOSBucket(), key, new File(filePath));
} catch (CosServiceException oe) {
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} catch (CosClientException ce) {
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} finally {
cosClient.shutdown();
}
return getUrlPrefix() + key;
}
@Override
public String inputStreamUpload(InputStream inputStream, String key) {
COSClient cosClient = getCOSClient();
try {
ObjectMetadata meta = new ObjectMetadata();
meta.setContentType("image/jpg");
cosClient.putObject(ossSetting.getTencentCOSBucket(), key, inputStream, meta);
} catch (CosServiceException oe) {
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} catch (CosClientException ce) {
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} finally {
cosClient.shutdown();
}
return getUrlPrefix() + key;
}
@Override
public void deleteFile(List<String> keys) {
COSClient cosClient = getCOSClient();
try {
List<DeleteObjectsRequest.KeyVersion> delObjects = new ArrayList<>();
for (String key : keys) {
delObjects.add(new DeleteObjectsRequest.KeyVersion(key));
}
cosClient.deleteObjects(new DeleteObjectsRequest(ossSetting.getTencentCOSBucket()).withKeys(delObjects));
} catch (CosServiceException oe) {
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} catch (CosClientException ce) {
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} finally {
cosClient.shutdown();
}
}
}
|
// 1 初始化用户身份信息（secretId, secretKey）。
COSCredentials cred = new BasicCOSCredentials(ossSetting.getTencentCOSSecretId(), ossSetting.getTencentCOSSecretKey());
// 2 设置 bucket 的地域, COS 地域的简称请参见 https://cloud.tencent.com/document/product/436/6224
ClientConfig clientConfig = new ClientConfig(new Region(ossSetting.getTencentCOSRegion()));
// 这里建议设置使用 https 协议
clientConfig.setHttpProtocol(HttpProtocol.https);
// 3 生成 cos 客户端。
return new COSClient(cred, clientConfig);
| 752
| 189
| 941
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/file/serviceimpl/FileDirectoryServiceImpl.java
|
FileDirectoryServiceImpl
|
initChild
|
class FileDirectoryServiceImpl extends ServiceImpl<FileDirectoryMapper, FileDirectory> implements FileDirectoryService {
@Override
public void addFileDirectory(UserEnums userEnum, String id, String ownerName) {
FileDirectory fileDirectory = new FileDirectory();
fileDirectory.setOwnerId(id);
fileDirectory.setDirectoryName(ownerName);
fileDirectory.setDirectoryType(userEnum.name());
this.save(fileDirectory);
}
@Override
public List<FileDirectoryDTO> getFileDirectoryList(String scene) {
List<FileDirectory> fileDirectoryList = this.list(new LambdaQueryWrapper<FileDirectory>().eq(FileDirectory::getOwnerId, scene));
List<FileDirectoryDTO> fileDirectoryDTOList = new ArrayList<>();
fileDirectoryList.forEach(item -> {
if (item.getLevel() == 0) {
FileDirectoryDTO fileDirectoryDTO = new FileDirectoryDTO(item);
initChild(fileDirectoryDTO, fileDirectoryList);
fileDirectoryDTOList.add(fileDirectoryDTO);
}
});
return fileDirectoryDTOList;
}
/**
* 递归初始化子树
*/
private void initChild(FileDirectoryDTO fileDirectoryDTO, List<FileDirectory> fileDirectoryList) {<FILL_FUNCTION_BODY>}
}
|
if (fileDirectoryList == null) {
return;
}
fileDirectoryList.stream()
.filter(item -> (item.getParentId().equals(fileDirectoryDTO.getId())))
.forEach(child -> {
FileDirectoryDTO childTree = new FileDirectoryDTO(child);
initChild(childTree, fileDirectoryList);
fileDirectoryDTO.getChildren().add(childTree);
});
| 341
| 110
| 451
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/file/serviceimpl/FileServiceImpl.java
|
FileServiceImpl
|
batchDelete
|
class FileServiceImpl extends ServiceImpl<FileMapper, File> implements FileService {
@Autowired
private FilePluginFactory filePluginFactory;
@Override
public void batchDelete(List<String> ids) {
LambdaQueryWrapper<File> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(File::getId, ids);
List<File> files = this.list(queryWrapper);
List<String> keys = new ArrayList<>();
files.forEach(item -> keys.add(item.getFileKey()));
filePluginFactory.filePlugin().deleteFile(keys);
this.remove(queryWrapper);
}
@Override
public void batchDeleteByDirectory(String directoryId) {
LambdaQueryWrapper<File> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(File::getFileDirectoryId, directoryId);
List<File> files = this.list(queryWrapper);
List<String> keys = new ArrayList<>();
files.forEach(item -> keys.add(item.getFileKey()));
filePluginFactory.filePlugin().deleteFile(keys);
this.remove(queryWrapper);
}
@Override
public void batchDelete(List<String> ids, AuthUser authUser) {<FILL_FUNCTION_BODY>}
@Override
public IPage<File> customerPage(FileOwnerDTO fileOwnerDTO) {
LambdaQueryWrapper<File> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getName()), File::getName, fileOwnerDTO.getName())
.like(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getOwnerName()), File::getOwnerName, fileOwnerDTO.getOwnerName())
.eq(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getFileDirectoryId()),File::getFileDirectoryId, fileOwnerDTO.getFileDirectoryId())
.like(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getFileKey()), File::getFileKey, fileOwnerDTO.getFileKey())
.like(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getFileType()), File::getFileType, fileOwnerDTO.getFileType())
.between(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getStartDate()) && CharSequenceUtil.isNotEmpty(fileOwnerDTO.getEndDate()),
File::getCreateTime, fileOwnerDTO.getStartDate(), fileOwnerDTO.getEndDate());
return this.page(PageUtil.initPage(fileOwnerDTO), queryWrapper);
}
@Override
public IPage<File> customerPageOwner(FileOwnerDTO fileOwnerDTO) {
LambdaQueryWrapper<File> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getOwnerId()), File::getOwnerId, fileOwnerDTO.getOwnerId())
.eq(File::getUserEnums, fileOwnerDTO.getUserEnums())
.eq(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getFileDirectoryId()),File::getFileDirectoryId, fileOwnerDTO.getFileDirectoryId())
.like(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getName()), File::getName, fileOwnerDTO.getName())
.like(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getFileKey()), File::getFileKey, fileOwnerDTO.getFileKey())
.like(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getFileType()), File::getFileType, fileOwnerDTO.getFileType())
.between(CharSequenceUtil.isNotEmpty(fileOwnerDTO.getStartDate()) && CharSequenceUtil.isNotEmpty(fileOwnerDTO.getEndDate()),
File::getCreateTime, fileOwnerDTO.getStartDate(), fileOwnerDTO.getEndDate());
return this.page(PageUtil.initPage(fileOwnerDTO), queryWrapper);
}
}
|
LambdaQueryWrapper<File> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(File::getId, ids);
queryWrapper.eq(File::getUserEnums, authUser.getRole().name());
//操作图片属性判定
switch (authUser.getRole()) {
case MEMBER:
queryWrapper.eq(File::getOwnerId, authUser.getId());
break;
case STORE:
queryWrapper.eq(File::getOwnerId, authUser.getStoreId());
break;
case MANAGER:
break;
default:
throw new ServiceException(ResultCode.USER_AUTHORITY_ERROR);
}
List<File> files = this.list(queryWrapper);
List<String> keys = new ArrayList<>();
files.forEach(item -> keys.add(item.getFileKey()));
filePluginFactory.filePlugin().deleteFile(keys);
this.remove(queryWrapper);
| 990
| 245
| 1,235
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/entity/dos/GoodsSku.java
|
GoodsSku
|
getCreateTime
|
class GoodsSku extends BaseEntity {
private static final long serialVersionUID = 4865908658161118934L;
@ApiModelProperty(value = "商品id")
private String goodsId;
@ApiModelProperty(value = "规格信息json", hidden = true)
@JsonIgnore
private String specs;
@ApiModelProperty(value = "规格信息")
private String simpleSpecs;
@ApiModelProperty(value = "配送模版id")
private String freightTemplateId;
@ApiModelProperty(value = "是否是促销商品")
private Boolean promotionFlag;
@ApiModelProperty(value = "促销价")
private Double promotionPrice;
@ApiModelProperty(value = "商品名称")
private String goodsName;
@Length(max = 30, message = "商品规格编号太长，不能超过30个字符")
@ApiModelProperty(value = "商品编号")
private String sn;
@ApiModelProperty(value = "品牌id")
private String brandId;
@ApiModelProperty(value = "分类path")
private String categoryPath;
@ApiModelProperty(value = "计量单位")
private String goodsUnit;
@ApiModelProperty(value = "卖点")
private String sellingPoint;
@ApiModelProperty(value = "重量")
@Max(value = 99999999, message = "重量不能超过99999999")
private Double weight;
/**
* @see GoodsStatusEnum
*/
@ApiModelProperty(value = "上架状态")
private String marketEnable;
@ApiModelProperty(value = "商品详情")
private String intro;
@Max(value = 99999999, message = "价格不能超过99999999")
@ApiModelProperty(value = "商品价格")
private Double price;
@Max(value = 99999999, message = "成本价格99999999")
@ApiModelProperty(value = "成本价格")
private Double cost;
@ApiModelProperty(value = "浏览数量")
private Integer viewCount;
@ApiModelProperty(value = "购买数量")
private Integer buyCount;
@Max(value = 99999999, message = "库存不能超过99999999")
@ApiModelProperty(value = "库存")
private Integer quantity;
@ApiModelProperty(value = "商品好评率")
private Double grade;
@ApiModelProperty(value = "缩略图路径")
private String thumbnail;
@ApiModelProperty(value = "大图路径")
private String big;
@ApiModelProperty(value = "小图路径")
private String small;
@ApiModelProperty(value = "原图路径")
private String original;
@ApiModelProperty(value = "店铺分类id")
private String storeCategoryPath;
@ApiModelProperty(value = "评论数量")
private Integer commentNum;
@ApiModelProperty(value = "卖家id")
private String storeId;
@ApiModelProperty(value = "卖家名字")
private String storeName;
@ApiModelProperty(value = "运费模板id")
private String templateId;
/**
* @see GoodsAuthEnum
*/
@ApiModelProperty(value = "审核状态")
private String authFlag;
@ApiModelProperty(value = "审核信息")
private String authMessage;
@ApiModelProperty(value = "下架原因")
private String underMessage;
@ApiModelProperty(value = "是否自营")
private Boolean selfOperated;
@ApiModelProperty(value = "商品移动端详情")
private String mobileIntro;
@ApiModelProperty(value = "商品视频")
private String goodsVideo;
@ApiModelProperty(value = "是否为推荐商品", required = true)
private Boolean recommend;
/**
* @see cn.lili.modules.goods.entity.enums.GoodsSalesModeEnum
*/
@ApiModelProperty(value = "销售模式", required = true)
private String salesModel;
/**
* @see cn.lili.modules.goods.entity.enums.GoodsTypeEnum
*/
@ApiModelProperty(value = "商品类型", required = true)
private String goodsType;
@ApiModelProperty(value = "预警数量")
private Integer alertQuantity;
public Double getWeight() {
if (weight == null) {
return 0d;
}
return weight;
}
public Integer getAlertQuantity() {
if(alertQuantity == null){
return 0;
}
return alertQuantity;
}
@Override
public Date getCreateTime() {<FILL_FUNCTION_BODY>}
/**
* 设置规格商品的基本商品信息
*
* @param goods 基本商品信息
*/
public GoodsSku(Goods goods) {
//商品基本信息
this.goodsId = goods.getId();
this.goodsName = goods.getGoodsName();
this.goodsType = goods.getGoodsType();
this.goodsVideo = goods.getGoodsVideo();
this.selfOperated = goods.getSelfOperated();
this.sellingPoint = goods.getSellingPoint();
this.categoryPath = goods.getCategoryPath();
this.brandId = goods.getBrandId();
this.marketEnable = goods.getMarketEnable();
this.intro = goods.getIntro();
this.mobileIntro = goods.getMobileIntro();
this.goodsUnit = goods.getGoodsUnit();
this.grade = 100D;
this.alertQuantity = 0;
//商品状态
this.authFlag = goods.getAuthFlag();
this.salesModel = goods.getSalesModel();
//卖家信息
this.storeId = goods.getStoreId();
this.storeName = goods.getStoreName();
this.storeCategoryPath = goods.getStoreCategoryPath();
this.freightTemplateId = goods.getTemplateId();
this.recommend = goods.getRecommend();
}
}
|
if (super.getCreateTime() == null) {
return new Date(1593571928);
} else {
return super.getCreateTime();
}
| 1,650
| 51
| 1,701
|
<methods>public non-sealed void <init>() <variables>private java.lang.String createBy,private java.util.Date createTime,private java.lang.Boolean deleteFlag,private java.lang.String id,private static final long serialVersionUID,private java.lang.String updateBy,private java.util.Date updateTime
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/entity/dto/CategorySearchParams.java
|
CategorySearchParams
|
queryWrapper
|
class CategorySearchParams {
@ApiModelProperty(value = "分类名称")
private String name;
@ApiModelProperty(value = "父id")
private String parentId;
@ApiModelProperty(value = "层级")
private Integer level;
@ApiModelProperty(value = "排序值")
private BigDecimal sortOrder;
@ApiModelProperty(value = "佣金比例")
private BigDecimal commissionRate;
@ApiModelProperty(value = "父节点名称")
private String parentTitle;
@ApiModelProperty(value = "是否禁用")
private Boolean deleteFlag;
public <T > QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
queryWrapper.like(name != null, "name", name);
queryWrapper.like(parentTitle != null, "parent_title", parentTitle);
queryWrapper.eq(parentId != null, "parent_id", parentId);
queryWrapper.eq(level != null, "level", level);
queryWrapper.eq(sortOrder != null, "sort_order", sortOrder);
queryWrapper.eq(commissionRate != null, "commission_rate", commissionRate);
queryWrapper.eq(deleteFlag != null, "delete_flag", deleteFlag);
return queryWrapper;
| 193
| 165
| 358
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/entity/dto/DraftGoodsSearchParams.java
|
DraftGoodsSearchParams
|
queryWrapper
|
class DraftGoodsSearchParams extends GoodsSearchParams {
private static final long serialVersionUID = -1057830772267228050L;
/**
* @see DraftGoodsSaveType
*/
@ApiModelProperty(value = "草稿商品保存类型")
private String saveType;
@Override
public <T> QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = super.queryWrapper();
if (CharSequenceUtil.isNotEmpty(saveType)) {
queryWrapper.eq("save_type", saveType);
}
return queryWrapper;
| 123
| 57
| 180
|
<methods>public non-sealed void <init>() ,public QueryWrapper<T> queryWrapper() <variables>private java.lang.Boolean alertQuantity,private java.lang.String authFlag,private java.lang.String categoryPath,private java.lang.Integer geQuantity,private java.lang.String goodsId,private java.lang.String goodsName,private java.lang.String goodsType,private java.lang.String id,private List<java.lang.String> ids,private java.lang.Integer leQuantity,private java.lang.String marketEnable,private java.lang.String price,private java.lang.Boolean recommend,private java.lang.String salesModel,private java.lang.Boolean selfOperated,private static final long serialVersionUID,private java.lang.String storeCategoryPath,private java.lang.String storeId,private java.lang.String storeName
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/entity/dto/GoodsSearchParams.java
|
GoodsSearchParams
|
queryWrapper
|
class GoodsSearchParams extends PageVO {
private static final long serialVersionUID = 2544015852728566887L;
@ApiModelProperty(value = "商品编号")
private String goodsId;
@ApiModelProperty(value = "商品名称")
private String goodsName;
@ApiModelProperty(value = "商品编号")
private String id;
@ApiModelProperty(value = "商品编号")
private List<String> ids;
@ApiModelProperty(value = "商家ID")
private String storeId;
@ApiModelProperty(value = "卖家名字")
private String storeName;
@ApiModelProperty(value = "价格,可以为范围，如10_1000")
private String price;
@ApiModelProperty(value = "分类path")
private String categoryPath;
@ApiModelProperty(value = "店铺分类id")
private String storeCategoryPath;
@ApiModelProperty(value = "是否自营")
private Boolean selfOperated;
/**
* @see GoodsStatusEnum
*/
@ApiModelProperty(value = "上下架状态")
private String marketEnable;
/**
* @see GoodsAuthEnum
*/
@ApiModelProperty(value = "审核状态")
private String authFlag;
@ApiModelProperty(value = "库存数量")
private Integer leQuantity;
@ApiModelProperty(value = "库存数量")
private Integer geQuantity;
@ApiModelProperty(value = "是否为推荐商品")
private Boolean recommend;
/**
* @see cn.lili.modules.goods.entity.enums.GoodsTypeEnum
*/
@ApiModelProperty(value = "商品类型")
private String goodsType;
/**
* @see cn.lili.modules.goods.entity.enums.GoodsSalesModeEnum
*/
@ApiModelProperty(value = "销售模式", required = true)
private String salesModel;
@ApiModelProperty(value = "预警库存")
private Boolean alertQuantity;
public <T> QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
private <T> void betweenWrapper(QueryWrapper<T> queryWrapper) {
if (CharSequenceUtil.isNotEmpty(price)) {
String[] s = price.split("_");
if (s.length > 1) {
queryWrapper.between("price", s[0], s[1]);
} else {
queryWrapper.ge("price", s[0]);
}
}
}
}
|
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
if (CharSequenceUtil.isNotEmpty(goodsId)) {
queryWrapper.eq("goods_id", goodsId);
}
if (CharSequenceUtil.isNotEmpty(goodsName)) {
queryWrapper.like("goods_name", goodsName);
}
if (CharSequenceUtil.isNotEmpty(id)) {
queryWrapper.in("id", Arrays.asList(id.split(",")));
}
if (CollUtil.isNotEmpty(ids)) {
queryWrapper.in("id", ids);
}
if (CharSequenceUtil.isNotEmpty(storeId)) {
queryWrapper.eq("store_id", storeId);
}
if (CharSequenceUtil.isNotEmpty(storeName)) {
queryWrapper.like("store_name", storeName);
}
if (CharSequenceUtil.isNotEmpty(categoryPath)) {
queryWrapper.like("category_path", categoryPath);
}
if (CharSequenceUtil.isNotEmpty(storeCategoryPath)) {
queryWrapper.like("store_category_path", storeCategoryPath);
}
if (selfOperated != null) {
queryWrapper.eq("self_operated", selfOperated);
}
if (CharSequenceUtil.isNotEmpty(marketEnable)) {
queryWrapper.eq("market_enable", marketEnable);
}
if (CharSequenceUtil.isNotEmpty(authFlag)) {
queryWrapper.eq("auth_flag", authFlag);
}
if (leQuantity != null) {
queryWrapper.le("quantity", leQuantity);
}
if (geQuantity != null) {
queryWrapper.gt("quantity", geQuantity);
}
if (recommend != null) {
queryWrapper.le("recommend", recommend);
}
if (CharSequenceUtil.isNotEmpty(goodsType)) {
queryWrapper.eq("goods_type", goodsType);
}
if (CharSequenceUtil.isNotEmpty(salesModel)) {
queryWrapper.eq("sales_model", salesModel);
}
if(alertQuantity != null && alertQuantity){
queryWrapper.apply("quantity <= alert_quantity");
queryWrapper.ge("alert_quantity", 0);
}
queryWrapper.in(CollUtil.isNotEmpty(ids), "id", ids);
queryWrapper.eq("delete_flag", false);
this.betweenWrapper(queryWrapper);
return queryWrapper;
| 686
| 645
| 1,331
|
<methods>public non-sealed void <init>() ,public java.lang.String getSort() <variables>private java.lang.Boolean notConvert,private java.lang.String order,private java.lang.Integer pageNumber,private java.lang.Integer pageSize,private static final long serialVersionUID,private java.lang.String sort
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/entity/dto/GoodsSkuSearchParams.java
|
GoodsSkuSearchParams
|
queryWrapper
|
class GoodsSkuSearchParams extends GoodsSearchParams {
private static final long serialVersionUID = -6235885068610635045L;
@ApiModelProperty(value = "商品id")
private String goodsId;
@Override
public <T> QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = super.queryWrapper();
queryWrapper.eq(StringUtils.isNotEmpty(goodsId), "goods_id", goodsId);
return queryWrapper;
| 104
| 51
| 155
|
<methods>public non-sealed void <init>() ,public QueryWrapper<T> queryWrapper() <variables>private java.lang.Boolean alertQuantity,private java.lang.String authFlag,private java.lang.String categoryPath,private java.lang.Integer geQuantity,private java.lang.String goodsId,private java.lang.String goodsName,private java.lang.String goodsType,private java.lang.String id,private List<java.lang.String> ids,private java.lang.Integer leQuantity,private java.lang.String marketEnable,private java.lang.String price,private java.lang.Boolean recommend,private java.lang.String salesModel,private java.lang.Boolean selfOperated,private static final long serialVersionUID,private java.lang.String storeCategoryPath,private java.lang.String storeId,private java.lang.String storeName
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/entity/vos/CategoryVO.java
|
CategoryVO
|
getChildren
|
class CategoryVO extends Category {
private static final long serialVersionUID = 3775766246075838410L;
@ApiModelProperty(value = "父节点名称")
private String parentTitle;
@ApiModelProperty("子分类列表")
private List<CategoryVO> children;
@ApiModelProperty("分类关联的品牌列表")
private List<Brand> brandList;
public CategoryVO(Category category) {
BeanUtil.copyProperties(category, this);
}
public CategoryVO(String id, String createBy, Date createTime, String updateBy, Date updateTime, Boolean deleteFlag, String name, String parentId, Integer level, BigDecimal sortOrder, Double commissionRate, String image, Boolean supportChannel) {
super(id, createBy, createTime, updateBy, updateTime, deleteFlag, name, parentId, level, sortOrder, commissionRate, image, supportChannel);
}
public List<CategoryVO> getChildren() {<FILL_FUNCTION_BODY>}
}
|
if (children != null) {
children.sort(new Comparator<CategoryVO>() {
@Override
public int compare(CategoryVO o1, CategoryVO o2) {
return o1.getSortOrder().compareTo(o2.getSortOrder());
}
});
return children;
}
return null;
| 267
| 90
| 357
|
<methods>public void <init>(java.lang.String, java.lang.String, java.util.Date, java.lang.String, java.util.Date, java.lang.Boolean, java.lang.String, java.lang.String, java.lang.Integer, java.math.BigDecimal, java.lang.Double, java.lang.String, java.lang.Boolean) ,public void <init>(java.lang.String, java.lang.String, java.lang.String, java.lang.Integer, java.math.BigDecimal, java.lang.Double, java.lang.String, java.lang.Boolean) <variables>private java.lang.Double commissionRate,private java.lang.String image,private java.lang.Integer level,private java.lang.String name,private java.lang.String parentId,private static final long serialVersionUID,private java.math.BigDecimal sortOrder,private java.lang.Boolean supportChannel
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/entity/vos/GoodsParamsVO.java
|
GoodsParamsVO
|
getOptionList
|
class GoodsParamsVO extends GoodsParamsDTO {
private static final long serialVersionUID = -4904700751774005326L;
@ApiModelProperty("1 输入项 2 选择项")
private Integer paramType;
@ApiModelProperty(" 选择项的内容获取值，使用optionList")
private String options;
@ApiModelProperty("是否必填是 1 否 0")
private Integer required;
@ApiModelProperty("参数组id")
private String groupId;
@ApiModelProperty("是否可索引 1 可以 0不可以")
private Integer isIndex;
private String[] optionList;
public void setOptionList(String[] optionList) {
this.optionList = optionList;
}
public String[] getOptionList() {<FILL_FUNCTION_BODY>}
}
|
if (options != null) {
return options.replaceAll("\r|\n", "").split(",");
}
return optionList;
| 228
| 41
| 269
|
<methods>public non-sealed void <init>() <variables>private List<cn.lili.modules.goods.entity.dto.GoodsParamsItemDTO> goodsParamsItemDTOList,private java.lang.String groupId,private java.lang.String groupName,private static final long serialVersionUID
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/BrandServiceImpl.java
|
BrandServiceImpl
|
checkBind
|
class BrandServiceImpl extends ServiceImpl<BrandMapper, Brand> implements BrandService {
/**
* 分类品牌绑定
*/
@Autowired
private CategoryBrandService categoryBrandService;
@Autowired
private CategoryService categoryService;
@Autowired
private GoodsService goodsService;
@Override
public IPage<Brand> getBrandsByPage(BrandPageDTO page) {
LambdaQueryWrapper<Brand> queryWrapper = new LambdaQueryWrapper<>();
if (page.getName() != null) {
queryWrapper.like(Brand::getName, page.getName());
}
return this.page(PageUtil.initPage(page), queryWrapper);
}
@Override
public List<Brand> getBrandsByCategory(String categoryId) {
QueryWrapper<CategoryBrand> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("category_id", categoryId);
List<CategoryBrand> list = categoryBrandService.list(queryWrapper);
if (list != null && !list.isEmpty()) {
List<String> collect = list.stream().map(CategoryBrand::getBrandId).collect(Collectors.toList());
return this.list(new LambdaQueryWrapper<Brand>().in(Brand::getId, collect));
}
return new ArrayList<>();
}
@Override
public List<Map<String, Object>> getBrandsMapsByCategory(List<String> categoryIds, String columns) {
QueryWrapper<Brand> queryWrapper = new QueryWrapper<>();
queryWrapper.select(columns);
queryWrapper.in("id", categoryIds);
return this.listMaps(queryWrapper);
}
@Override
public boolean addBrand(BrandVO brandVO) {
if (getOne(new LambdaQueryWrapper<Brand>().eq(Brand::getName, brandVO.getName())) != null) {
throw new ServiceException(ResultCode.BRAND_NAME_EXIST_ERROR);
}
return this.save(brandVO);
}
@Override
public boolean updateBrand(BrandVO brandVO) {
this.checkExist(brandVO.getId());
if (getOne(new LambdaQueryWrapper<Brand>().eq(Brand::getName, brandVO.getName()).ne(Brand::getId, brandVO.getId())) != null) {
throw new ServiceException(ResultCode.BRAND_NAME_EXIST_ERROR);
}
return this.updateById(brandVO);
}
@Override
public boolean brandDisable(String brandId, boolean disable) {
Brand brand = this.checkExist(brandId);
//如果是要禁用，则需要先判定绑定关系
if (Boolean.TRUE.equals(disable)) {
List<String> ids = new ArrayList<>();
ids.add(brandId);
checkBind(ids);
}
brand.setDeleteFlag(disable);
return updateById(brand);
}
@Override
public void deleteBrands(List<String> ids) {
checkBind(ids);
this.removeByIds(ids);
}
/**
* 校验绑定关系
*
* @param brandIds 品牌Ids
*/
private void checkBind(List<String> brandIds) {<FILL_FUNCTION_BODY>}
/**
* 校验是否存在
*
* @param brandId 品牌ID
* @return 品牌
*/
private Brand checkExist(String brandId) {
Brand brand = getById(brandId);
if (brand == null) {
log.error("品牌ID为" + brandId + "的品牌不存在");
throw new ServiceException(ResultCode.BRAND_NOT_EXIST);
}
return brand;
}
}
|
//分了绑定关系查询
List<CategoryBrand> categoryBrands = categoryBrandService.getCategoryBrandListByBrandId(brandIds);
if (!categoryBrands.isEmpty()) {
List<String> categoryIds = categoryBrands.stream().map(CategoryBrand::getCategoryId).collect(Collectors.toList());
throw new ServiceException(ResultCode.BRAND_USE_DISABLE_ERROR,
JSONUtil.toJsonStr(categoryService.getCategoryNameByIds(categoryIds)));
}
//分了商品绑定关系查询
List<Goods> goods = goodsService.getByBrandIds(brandIds);
if (!goods.isEmpty()) {
List<String> goodsNames = goods.stream().map(Goods::getGoodsName).collect(Collectors.toList());
throw new ServiceException(ResultCode.BRAND_BIND_GOODS_ERROR,
JSONUtil.toJsonStr(goodsNames));
}
| 977
| 245
| 1,222
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/CategoryBrandServiceImpl.java
|
CategoryBrandServiceImpl
|
saveCategoryBrandList
|
class CategoryBrandServiceImpl extends ServiceImpl<CategoryBrandMapper, CategoryBrand> implements CategoryBrandService {
@Override
public List<CategoryBrandVO> getCategoryBrandList(String categoryId) {
return this.baseMapper.getCategoryBrandList(categoryId);
}
@Override
public void deleteByCategoryId(String categoryId) {
this.baseMapper.delete(new LambdaUpdateWrapper<CategoryBrand>().eq(CategoryBrand::getCategoryId, categoryId));
}
@Override
public List<CategoryBrand> getCategoryBrandListByBrandId(List<String> brandId) {
return this.list(new LambdaQueryWrapper<CategoryBrand>().in(CategoryBrand::getBrandId, brandId));
}
@Override
@Transactional(rollbackFor = Exception.class)
public void saveCategoryBrandList(String categoryId, List<String> brandIds) {<FILL_FUNCTION_BODY>}
}
|
//删除分类品牌绑定信息
this.deleteByCategoryId(categoryId);
//绑定品牌信息
if (!brandIds.isEmpty()) {
List<CategoryBrand> categoryBrands = new ArrayList<>();
for (String brandId : brandIds) {
categoryBrands.add(new CategoryBrand(categoryId, brandId));
}
this.saveBatch(categoryBrands);
}
| 249
| 108
| 357
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/CategoryParameterGroupServiceImpl.java
|
CategoryParameterGroupServiceImpl
|
updateCategoryGroup
|
class CategoryParameterGroupServiceImpl extends ServiceImpl<CategoryParameterGroupMapper, CategoryParameterGroup> implements CategoryParameterGroupService {
/**
* 商品参数
*/
@Autowired
private ParametersService parametersService;
@Autowired
private GoodsService goodsService;
@Override
public List<ParameterGroupVO> getCategoryParams(String categoryId) {
//根据id查询参数组
List<CategoryParameterGroup> groups = this.getCategoryGroup(categoryId);
//查询参数
List<Parameters> params = parametersService.list(new QueryWrapper<Parameters>().eq("category_id", categoryId));
//组合参数vo
return convertParamList(groups, params);
}
@Override
public List<CategoryParameterGroup> getCategoryGroup(String categoryId) {
return this.list(new QueryWrapper<CategoryParameterGroup>().eq("category_id", categoryId));
}
/**
* 更新分类参数组绑定信息
*
* @param categoryParameterGroup 分类参数组信息
* @return 是否成功
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateCategoryGroup(CategoryParameterGroup categoryParameterGroup) {<FILL_FUNCTION_BODY>}
@Override
public void deleteByCategoryId(String categoryId) {
this.baseMapper.delete(new LambdaUpdateWrapper<CategoryParameterGroup>().eq(CategoryParameterGroup::getCategoryId, categoryId));
}
/**
* 拼装参数组和参数的返回值
*
* @param groupList 参数组list
* @param paramList 商品参数list
* @return 参数组和参数的返回值
*/
public List<ParameterGroupVO> convertParamList(List<CategoryParameterGroup> groupList, List<Parameters> paramList) {
Map<String, List<Parameters>> map = new HashMap<>(paramList.size());
for (Parameters param : paramList) {
List<Parameters> list = map.get(param.getGroupId());
if (list == null) {
list = new ArrayList<>();
}
list.add(param);
map.put(param.getGroupId(), list);
}
List<ParameterGroupVO> resList = new ArrayList<>();
for (CategoryParameterGroup group : groupList) {
ParameterGroupVO groupVo = new ParameterGroupVO();
groupVo.setGroupId(group.getId());
groupVo.setGroupName(group.getGroupName());
groupVo.setParams(map.get(group.getId()) == null ? new ArrayList<>() : map.get(group.getId()));
resList.add(groupVo);
}
return resList;
}
}
|
CategoryParameterGroup origin = this.getById(categoryParameterGroup.getId());
if (origin == null) {
throw new ServiceException(ResultCode.CATEGORY_PARAMETER_NOT_EXIST);
}
LambdaQueryWrapper<Goods> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.select(Goods::getId, Goods::getParams);
queryWrapper.like(Goods::getParams, origin.getId());
List<Map<String, Object>> goodsList = this.goodsService.listMaps(queryWrapper);
for (Map<String, Object> goods : goodsList) {
String params = (String) goods.get("params");
List<GoodsParamsDTO> goodsParamsDTOS = JSONUtil.toList(params, GoodsParamsDTO.class);
List<GoodsParamsDTO> goodsParamsDTOList = goodsParamsDTOS.stream().filter(i -> i.getGroupId() != null && i.getGroupId().equals(origin.getId())).collect(Collectors.toList());
for (GoodsParamsDTO goodsParamsDTO : goodsParamsDTOList) {
goodsParamsDTO.setGroupName(categoryParameterGroup.getGroupName());
}
this.goodsService.updateGoodsParams(goods.get("id").toString(), JSONUtil.toJsonStr(goodsParamsDTOS));
}
return this.updateById(categoryParameterGroup);
| 686
| 351
| 1,037
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/CommodityServiceImpl.java
|
CommodityServiceImpl
|
addCommodity
|
class CommodityServiceImpl extends ServiceImpl<CommodityMapper, Commodity> implements CommodityService {
@Autowired
private WechatLivePlayerUtil wechatLivePlayerUtil;
@Autowired
private GoodsSkuService goodsSkuService;
@Override
@Transactional(rollbackFor = Exception.class)
public boolean addCommodity(List<Commodity> commodityList) {<FILL_FUNCTION_BODY>}
private void checkCommodity(Commodity commodity) {
//商品是否审核通过
GoodsSku goodsSku = goodsSkuService.getById(commodity.getSkuId());
if (!goodsSku.getAuthFlag().equals(GoodsAuthEnum.PASS.name())) {
throw new ServiceException(goodsSku.getGoodsName() + " 未审核通过，不能添加直播商品");
}
//是否已添加规格商品
if (this.count(new LambdaQueryWrapper<Commodity>().eq(Commodity::getSkuId, commodity.getSkuId())) > 0) {
throw new ServiceException(goodsSku.getGoodsName() + " 已添加规格商品，无法重复增加");
}
}
@Override
public boolean deleteCommodity(String goodsId) {
AuthUser currentUser = UserContext.getCurrentUser();
if (currentUser == null || (currentUser.getRole().equals(UserEnums.STORE) && currentUser.getStoreId() == null)) {
throw new ServiceException(ResultCode.USER_AUTHORITY_ERROR);
}
JSONObject json = wechatLivePlayerUtil.deleteGoods(goodsId);
if ("0".equals(json.getStr("errcode"))) {
return this.remove(new LambdaQueryWrapper<Commodity>().eq(Commodity::getLiveGoodsId, goodsId).eq(Commodity::getStoreId, currentUser.getStoreId()));
}
return false;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void getGoodsWareHouse() {
//查询审核中的商品
List<String> goodsIdList = this.baseMapper.getAuditCommodity();
if (!goodsIdList.isEmpty()) {
//同步状态
JSONObject json = wechatLivePlayerUtil.getGoodsWareHouse(goodsIdList);
//修改状态
List<CommodityDTO> commodityDTOList = JSONUtil.toList((JSONArray) json.get("goods"), CommodityDTO.class);
for (CommodityDTO commodityDTO : commodityDTOList) {
//修改审核状态
this.update(new LambdaUpdateWrapper<Commodity>()
.eq(Commodity::getLiveGoodsId, commodityDTO.getGoods_id())
.set(Commodity::getAuditStatus, commodityDTO.getAudit_status()));
}
}
}
@Override
public IPage<CommodityVO> commodityList(PageVO pageVO, String name, String auditStatus) {
return this.baseMapper.commodityVOList(PageUtil.initPage(pageVO),
new QueryWrapper<CommodityVO>().like(name != null, "c.name", name)
.eq(auditStatus != null, "c.audit_status", auditStatus)
.eq(Objects.requireNonNull(UserContext.getCurrentUser()).getRole().equals(UserEnums.STORE), "c.store_id", UserContext.getCurrentUser().getStoreId())
.orderByDesc("create_time"));
}
@Override
public List<Commodity> getCommodityByRoomId(Integer roomId) {
return this.baseMapper.getCommodityByRoomId(roomId);
}
@Override
public List<String> getSimpleCommodityByRoomId(Integer roomId) {
return this.baseMapper.getSimpleCommodityByRoomId(roomId);
}
}
|
String storeId = Objects.requireNonNull(UserContext.getCurrentUser()).getStoreId();
for (Commodity commodity : commodityList) {
//检测直播商品
checkCommodity(commodity);
commodity.setStoreId(storeId);
//添加直播商品
JSONObject json = wechatLivePlayerUtil.addGoods(commodity);
if (!"0".equals(json.getStr("errcode"))) {
log.error(json.getStr("errmsg"));
throw new ServiceException(ResultCode.COMMODITY_ERROR);
}
commodity.setLiveGoodsId(Convert.toInt(json.getStr("goodsId")));
commodity.setAuditId(json.getStr("auditId"));
//默认为待审核状态
commodity.setAuditStatus("0");
this.save(commodity);
}
return true;
| 1,038
| 235
| 1,273
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/DraftGoodsServiceImpl.java
|
DraftGoodsServiceImpl
|
saveGoodsDraft
|
class DraftGoodsServiceImpl extends ServiceImpl<DraftGoodsMapper, DraftGoods> implements DraftGoodsService {
/**
* 分类
*/
@Autowired
private CategoryService categoryService;
/**
* 商品相册
*/
@Autowired
private GoodsGalleryService goodsGalleryService;
/**
* 规格商品
*/
@Autowired
private GoodsSkuService goodsSkuService;
@Autowired
private WholesaleService wholesaleService;
@Override
public boolean addGoodsDraft(DraftGoodsDTO draftGoods) {
draftGoods.setGoodsGalleryListJson(JSONUtil.toJsonStr(draftGoods.getGoodsGalleryList()));
draftGoods.setSkuListJson(JSONUtil.toJsonStr(draftGoods.getSkuList()));
draftGoods.setGoodsParamsListJson(JSONUtil.toJsonStr(draftGoods.getGoodsParamsDTOList()));
return this.save(draftGoods);
}
@Override
public boolean updateGoodsDraft(DraftGoodsDTO draftGoods) {
draftGoods.setGoodsGalleryListJson(JSONUtil.toJsonStr(draftGoods.getGoodsGalleryList()));
draftGoods.setSkuListJson(JSONUtil.toJsonStr(draftGoods.getSkuList()));
draftGoods.setGoodsParamsListJson(JSONUtil.toJsonStr(draftGoods.getGoodsParamsDTOList()));
return this.updateById(draftGoods);
}
@Override
public void saveGoodsDraft(DraftGoodsDTO draftGoods) {<FILL_FUNCTION_BODY>}
@Override
public void deleteGoodsDraft(String id) {
this.removeById(id);
this.wholesaleService.removeByTemplateId(id);
}
@Override
public DraftGoodsVO getDraftGoods(String id) {
DraftGoods draftGoods = this.getById(id);
DraftGoodsVO draftGoodsVO = new DraftGoodsVO();
BeanUtil.copyProperties(draftGoods, draftGoodsVO);
//商品分类名称赋值
List<String> categoryName = new ArrayList<>();
String[] strArray = draftGoods.getCategoryPath().split(",");
List<Category> categories = categoryService.listByIds(Arrays.asList(strArray));
for (Category category : categories) {
categoryName.add(category.getName());
}
draftGoodsVO.setCategoryName(categoryName);
draftGoodsVO.setGoodsParamsDTOList(JSONUtil.toList(JSONUtil.parseArray(draftGoods.getGoodsParamsListJson()), GoodsParamsDTO.class));
draftGoodsVO.setGoodsGalleryList(JSONUtil.toList(JSONUtil.parseArray(draftGoods.getGoodsGalleryListJson()), String.class));
JSONArray jsonArray = JSONUtil.parseArray(draftGoods.getSkuListJson());
List<GoodsSku> list = JSONUtil.toList(jsonArray, GoodsSku.class);
draftGoodsVO.setSkuList(goodsSkuService.getGoodsSkuVOList(list));
List<Wholesale> wholesaleList = wholesaleService.findByTemplateId(draftGoods.getId());
if (CollUtil.isNotEmpty(wholesaleList)) {
draftGoodsVO.setWholesaleList(wholesaleList);
}
return draftGoodsVO;
}
@Override
public IPage<DraftGoods> getDraftGoods(DraftGoodsSearchParams searchParams) {
return this.page(PageUtil.initPage(searchParams), searchParams.queryWrapper());
}
}
|
if (draftGoods.getGoodsGalleryList() != null && !draftGoods.getGoodsGalleryList().isEmpty()) {
GoodsGallery goodsGallery = goodsGalleryService.getGoodsGallery(draftGoods.getGoodsGalleryList().get(0));
draftGoods.setOriginal(goodsGallery.getOriginal());
draftGoods.setSmall(goodsGallery.getSmall());
draftGoods.setThumbnail(goodsGallery.getThumbnail());
}
// 商品图片
draftGoods.setGoodsGalleryListJson(JSONUtil.toJsonStr(draftGoods.getGoodsGalleryList()));
// 商品参数
draftGoods.setGoodsParamsListJson(JSONUtil.toJsonStr(draftGoods.getGoodsParamsDTOList()));
boolean result = this.saveOrUpdate(draftGoods);
if (result && draftGoods.getSkuList() != null && !draftGoods.getSkuList().isEmpty()) {
List<GoodsSku> goodsSkus = GoodsSkuBuilder.buildBatch(new Goods(draftGoods), draftGoods.getSkuList());
GoodsOperationDTO.GoodsOperationDTOBuilder goodsOperationDTOBuilder = GoodsOperationDTO.builder().goodsTemplateFlag(true).salesModel(draftGoods.getSalesModel());
if (draftGoods.getWholesaleList() != null && !draftGoods.getWholesaleList().isEmpty()) {
for (WholesaleDTO wholesaleDTO : draftGoods.getWholesaleList()) {
wholesaleDTO.setTemplateId(draftGoods.getId());
}
goodsOperationDTOBuilder.wholesaleList(draftGoods.getWholesaleList());
}
goodsSkuService.renderGoodsSkuList(goodsSkus, goodsOperationDTOBuilder.build());
LambdaUpdateWrapper<DraftGoods> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(DraftGoods::getId, draftGoods.getId());
updateWrapper.set(DraftGoods::getSkuListJson, JSONUtil.toJsonStr(goodsSkus));
this.update(updateWrapper);
}
| 991
| 582
| 1,573
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/GoodsGalleryServiceImpl.java
|
GoodsGalleryServiceImpl
|
getUrl
|
class GoodsGalleryServiceImpl extends ServiceImpl<GoodsGalleryMapper, GoodsGallery> implements GoodsGalleryService {
/**
* 设置
*/
@Autowired
private SettingService settingService;
@Override
@Transactional(rollbackFor = Exception.class)
public void add(List<String> goodsGalleryList, String goodsId) {
//删除原来商品相册信息
this.baseMapper.delete(new QueryWrapper<GoodsGallery>().eq("goods_id", goodsId));
//确定好图片选择器后进行处理
int i = 0;
for (String origin : goodsGalleryList) {
//获取带所有缩略的相册
GoodsGallery galley = this.getGoodsGallery(origin);
galley.setGoodsId(goodsId);
//默认第一个为默认图片
galley.setIsDefault(i == 0 ? 1 : 0);
i++;
this.baseMapper.insert(galley);
}
}
@Override
public GoodsGallery getGoodsGallery(String origin) {
GoodsGallery goodsGallery = new GoodsGallery();
//获取商品系统配置决定是否审核
Setting setting = settingService.get(SettingEnum.GOODS_SETTING.name());
GoodsSetting goodsSetting = JSONUtil.toBean(setting.getSettingValue(), GoodsSetting.class);
//缩略图
String thumbnail = this.getUrl(origin, goodsSetting.getAbbreviationPictureWidth(), goodsSetting.getAbbreviationPictureHeight());
//小图
String small = this.getUrl(origin, goodsSetting.getSmallPictureWidth(), goodsSetting.getSmallPictureHeight());
//赋值
goodsGallery.setSmall(small);
goodsGallery.setThumbnail(thumbnail);
goodsGallery.setOriginal(origin);
return goodsGallery;
}
@Override
public List<GoodsGallery> goodsGalleryList(String goodsId) {
//根据商品id查询商品相册
return this.baseMapper.selectList(new QueryWrapper<GoodsGallery>().eq("goods_id", goodsId));
}
/**
* 根据商品 id删除商品相册缩略图
*
* @param goodsId 商品ID
*/
@Override
public void removeByGoodsId(String goodsId) {
this.baseMapper.delete(new QueryWrapper<GoodsGallery>().eq("goods_id", goodsId));
}
/**
* 根据原图生成规定尺寸的图片
*
* @param url 连接
* @param width 宽
* @param height 高
* @return
*/
private String getUrl(String url, Integer width, Integer height) {<FILL_FUNCTION_BODY>}
}
|
Setting setting = settingService.get(SettingEnum.OSS_SETTING.name());
OssSetting ossSetting = JSONUtil.toBean(setting.getSettingValue(), OssSetting.class);
switch (OssEnum.valueOf(ossSetting.getType())) {
case MINIO:
//缩略图全路径
return url;
case ALI_OSS:
//缩略图全路径
return url + "?x-oss-process=style/" + width + "X" + height;
case HUAWEI_OBS:
//缩略图全路径
return url + "?image/resize,m_fixed,h_" + height + ",w_" + width;
case TENCENT_COS:
//缩略图全路径
return url + "?imageMogr2/thumbnail/" + width + "x" + height;
}
return url;
| 751
| 230
| 981
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/ParametersServiceImpl.java
|
ParametersServiceImpl
|
setGoodsItemDTO
|
class ParametersServiceImpl extends ServiceImpl<ParametersMapper, Parameters> implements ParametersService {
@Autowired
private GoodsService goodsService;
@Autowired
private RocketmqCustomProperties rocketmqCustomProperties;
@Autowired
private RocketMQTemplate rocketMQTemplate;
/**
* 更新参数组信息
*
* @param parameters 参数组信息
* @return 是否更新成功
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateParameter(Parameters parameters) {
Parameters origin = this.getById(parameters.getId());
if (origin == null) {
throw new ServiceException(ResultCode.CATEGORY_NOT_EXIST);
}
List<String> goodsIds = new ArrayList<>();
LambdaQueryWrapper<Goods> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.select(Goods::getId, Goods::getParams);
queryWrapper.like(Goods::getParams, parameters.getGroupId());
List<Map<String, Object>> goodsList = this.goodsService.listMaps(queryWrapper);
if (!goodsList.isEmpty()) {
for (Map<String, Object> goods : goodsList) {
String params = (String) goods.get("params");
List<GoodsParamsDTO> goodsParamsDTOS = JSONUtil.toList(params, GoodsParamsDTO.class);
List<GoodsParamsDTO> goodsParamsDTOList = goodsParamsDTOS.stream().filter(i -> i.getGroupId() != null && i.getGroupId().equals(parameters.getGroupId())).collect(Collectors.toList());
this.setGoodsItemDTOList(goodsParamsDTOList, parameters);
this.goodsService.updateGoodsParams(goods.get("id").toString(), JSONUtil.toJsonStr(goodsParamsDTOS));
goodsIds.add(goods.get("id").toString());
}
String destination = rocketmqCustomProperties.getGoodsTopic() + ":" + GoodsTagsEnum.UPDATE_GOODS_INDEX.name();
//发送mq消息
rocketMQTemplate.asyncSend(destination, JSONUtil.toJsonStr(goodsIds), RocketmqSendCallbackBuilder.commonCallback());
}
return this.updateById(parameters);
}
/**
* 更新商品参数信息
*
* @param goodsParamsDTOList 商品参数项列表
* @param parameters 参数信息
*/
private void setGoodsItemDTOList(List<GoodsParamsDTO> goodsParamsDTOList, Parameters parameters) {
for (GoodsParamsDTO goodsParamsDTO : goodsParamsDTOList) {
List<GoodsParamsItemDTO> goodsParamsItemDTOList = goodsParamsDTO.getGoodsParamsItemDTOList().stream().filter(i -> i.getParamId() != null && i.getParamId().equals(parameters.getId())).collect(Collectors.toList());
for (GoodsParamsItemDTO goodsParamsItemDTO : goodsParamsItemDTOList) {
this.setGoodsItemDTO(goodsParamsItemDTO, parameters);
}
}
}
/**
* 更新商品参数详细信息
*
* @param goodsParamsItemDTO 商品参数项信息
* @param parameters 参数信息
*/
private void setGoodsItemDTO(GoodsParamsItemDTO goodsParamsItemDTO, Parameters parameters) {<FILL_FUNCTION_BODY>}
}
|
if (goodsParamsItemDTO.getParamId().equals(parameters.getId())) {
goodsParamsItemDTO.setParamId(parameters.getId());
goodsParamsItemDTO.setParamName(parameters.getParamName());
goodsParamsItemDTO.setRequired(parameters.getRequired());
goodsParamsItemDTO.setIsIndex(parameters.getIsIndex());
goodsParamsItemDTO.setSort(parameters.getSort());
if (CharSequenceUtil.isNotEmpty(parameters.getOptions()) && CharSequenceUtil.isNotEmpty(goodsParamsItemDTO.getParamValue()) && !parameters.getOptions().contains(goodsParamsItemDTO.getParamValue())) {
if (parameters.getOptions().contains(",")) {
goodsParamsItemDTO.setParamValue(parameters.getOptions().substring(0, parameters.getOptions().indexOf(",")));
} else {
goodsParamsItemDTO.setParamValue(parameters.getOptions());
}
}
}
| 905
| 243
| 1,148
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/SpecificationServiceImpl.java
|
SpecificationServiceImpl
|
deleteSpecification
|
class SpecificationServiceImpl extends ServiceImpl<SpecificationMapper, Specification> implements SpecificationService {
/**
* 分类-规格绑定
*/
@Autowired
private CategorySpecificationService categorySpecificationService;
/**
* 分类
*/
@Autowired
private CategoryServiceImpl categoryService;
@Override
public boolean deleteSpecification(List<String> ids) {<FILL_FUNCTION_BODY>}
}
|
boolean result = false;
for (String id : ids) {
//如果此规格绑定分类则不允许删除
List<CategorySpecification> list = categorySpecificationService.list(new QueryWrapper<CategorySpecification>().eq("specification_id", id));
if (!list.isEmpty()) {
List<String> categoryIds = new ArrayList<>();
list.forEach(item -> categoryIds.add(item.getCategoryId()));
throw new ServiceException(ResultCode.SPEC_DELETE_ERROR,
JSONUtil.toJsonStr(categoryService.getCategoryNameByIds(categoryIds)));
}
//删除规格
result = this.removeById(id);
}
return result;
| 121
| 183
| 304
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/StoreGoodsLabelServiceImpl.java
|
StoreGoodsLabelServiceImpl
|
removeStoreGoodsLabel
|
class StoreGoodsLabelServiceImpl extends ServiceImpl<StoreGoodsLabelMapper, StoreGoodsLabel> implements StoreGoodsLabelService {
/**
* 缓存
*/
@Autowired
private Cache cache;
@Override
public List<StoreGoodsLabelVO> listByStoreId(String storeId) {
//从缓存中获取店铺分类
if (cache.hasKey(CachePrefix.STORE_CATEGORY.getPrefix() + storeId)) {
return (List<StoreGoodsLabelVO>) cache.get(CachePrefix.STORE_CATEGORY.getPrefix() + storeId);
}
List<StoreGoodsLabel> list = list(storeId);
List<StoreGoodsLabelVO> storeGoodsLabelVOList = new ArrayList<>();
//循环列表判断是否为顶级，如果为顶级获取下级数据
list.stream()
.filter(storeGoodsLabel -> storeGoodsLabel.getLevel() == 0)
.forEach(storeGoodsLabel -> {
StoreGoodsLabelVO storeGoodsLabelVO = new StoreGoodsLabelVO(storeGoodsLabel.getId(), storeGoodsLabel.getLabelName(), storeGoodsLabel.getLevel(), storeGoodsLabel.getSortOrder());
List<StoreGoodsLabelVO> storeGoodsLabelVOChildList = new ArrayList<>();
list.stream()
.filter(label -> label.getParentId() != null && label.getParentId().equals(storeGoodsLabel.getId()))
.forEach(storeGoodsLabelChild -> storeGoodsLabelVOChildList.add(new StoreGoodsLabelVO(storeGoodsLabelChild.getId(), storeGoodsLabelChild.getLabelName(), storeGoodsLabelChild.getLevel(), storeGoodsLabelChild.getSortOrder())));
storeGoodsLabelVOChildList.sort(Comparator.comparing(StoreGoodsLabelVO::getSortOrder));
storeGoodsLabelVO.setChildren(storeGoodsLabelVOChildList);
storeGoodsLabelVOList.add(storeGoodsLabelVO);
});
//调整店铺分类排序
storeGoodsLabelVOList.sort(Comparator.comparing(StoreGoodsLabelVO::getSortOrder));
if (!storeGoodsLabelVOList.isEmpty()) {
cache.put(CachePrefix.CATEGORY.getPrefix() + storeId, storeGoodsLabelVOList);
}
return storeGoodsLabelVOList;
}
/**
* 根据分类id集合获取所有店铺分类根据层级排序
*
* @param ids 商家ID
* @return 店铺分类列表
*/
@Override
public List<StoreGoodsLabel> listByStoreIds(List<String> ids) {
return this.list(new LambdaQueryWrapper<StoreGoodsLabel>().in(StoreGoodsLabel::getId, ids).orderByAsc(StoreGoodsLabel::getLevel));
}
@Override
public List<Map<String, Object>> listMapsByStoreIds(List<String> ids, String columns) {
QueryWrapper<StoreGoodsLabel> queryWrapper = new QueryWrapper<StoreGoodsLabel>().in("id", ids).orderByAsc("level");
queryWrapper.select(columns);
return this.listMaps(queryWrapper);
}
@Override
@Transactional(rollbackFor = Exception.class)
public StoreGoodsLabel addStoreGoodsLabel(StoreGoodsLabel storeGoodsLabel) {
//获取当前登录商家账号
AuthUser tokenUser = UserContext.getCurrentUser();
if (tokenUser == null || CharSequenceUtil.isEmpty(tokenUser.getStoreId())) {
throw new ServiceException(ResultCode.USER_NOT_LOGIN);
}
storeGoodsLabel.setStoreId(tokenUser.getStoreId());
//保存店铺分类
this.save(storeGoodsLabel);
//清除缓存
removeCache(storeGoodsLabel.getStoreId());
return storeGoodsLabel;
}
@Override
@Transactional(rollbackFor = Exception.class)
public StoreGoodsLabel editStoreGoodsLabel(StoreGoodsLabel storeGoodsLabel) {
//修改当前店铺的商品分类
AuthUser tokenUser = UserContext.getCurrentUser();
if (tokenUser == null || CharSequenceUtil.isEmpty(tokenUser.getStoreId())) {
throw new ServiceException(ResultCode.USER_NOT_LOGIN);
}
LambdaUpdateWrapper<StoreGoodsLabel> lambdaUpdateWrapper = Wrappers.lambdaUpdate();
lambdaUpdateWrapper.eq(StoreGoodsLabel::getStoreId, tokenUser.getStoreId());
lambdaUpdateWrapper.eq(StoreGoodsLabel::getId, storeGoodsLabel.getId());
//修改店铺分类
this.update(storeGoodsLabel, lambdaUpdateWrapper);
//清除缓存
removeCache(storeGoodsLabel.getStoreId());
return storeGoodsLabel;
}
@Override
public void removeStoreGoodsLabel(String storeLabelId) {<FILL_FUNCTION_BODY>}
/**
* 获取店铺商品分类列表
*
* @param storeId 店铺ID
* @return 店铺商品分类列表
*/
private List<StoreGoodsLabel> list(String storeId) {
LambdaQueryWrapper<StoreGoodsLabel> queryWrapper = Wrappers.lambdaQuery();
queryWrapper.eq(StoreGoodsLabel::getStoreId, storeId);
queryWrapper.orderByDesc(StoreGoodsLabel::getSortOrder);
return this.baseMapper.selectList(queryWrapper);
}
/**
* 清除缓存
*/
private void removeCache(String storeId) {
cache.remove(CachePrefix.STORE_CATEGORY.getPrefix() + storeId);
}
}
|
AuthUser tokenUser = UserContext.getCurrentUser();
if (tokenUser == null || CharSequenceUtil.isEmpty(tokenUser.getStoreId())) {
throw new ServiceException(ResultCode.USER_NOT_LOGIN);
}
//删除店铺分类
this.removeById(storeLabelId);
//清除缓存
removeCache(tokenUser.getStoreId());
| 1,470
| 100
| 1,570
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/serviceimpl/WholesaleServiceImpl.java
|
WholesaleServiceImpl
|
removeByTemplateId
|
class WholesaleServiceImpl extends ServiceImpl<WholesaleMapper, Wholesale> implements WholesaleService {
@Autowired
private Cache<List<Wholesale>> cache;
@Override
@Cacheable(key = "#goodsId")
public List<Wholesale> findByGoodsId(String goodsId) {
LambdaQueryWrapper<Wholesale> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Wholesale::getGoodsId, goodsId);
return this.list(queryWrapper).stream().sorted(Comparator.comparing(Wholesale::getNum)).collect(Collectors.toList());
}
@Override
@Cacheable(key = "#templateId+'_template'")
public List<Wholesale> findByTemplateId(String templateId) {
LambdaQueryWrapper<Wholesale> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Wholesale::getTemplateId, templateId);
return this.list(queryWrapper).stream().sorted(Comparator.comparing(Wholesale::getNum)).collect(Collectors.toList());
}
@Override
@CacheEvict(key = "#templateId+'_template'")
public Boolean removeByTemplateId(String templateId) {<FILL_FUNCTION_BODY>}
@Override
@CacheEvict(key = "#goodsId")
public Boolean removeByGoodsId(String goodsId) {
LambdaQueryWrapper<Wholesale> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Wholesale::getGoodsId, goodsId);
cache.remove("{wholesale}_" + goodsId);
return this.remove(queryWrapper);
}
@Override
public Wholesale match(String goodsId, Integer num) {
List<Wholesale> wholesaleList = cache.get("{wholesale}_" + goodsId);
if (wholesaleList == null) {
wholesaleList = this.findByGoodsId(goodsId);
cache.put("{wholesale}_" + goodsId, wholesaleList);
}
List<Wholesale> matchList = wholesaleList.stream()
.filter(wholesale -> wholesale.getNum() <= num)
.collect(Collectors.toList());
if (CollUtil.isNotEmpty(matchList)) {
return matchList.get(matchList.size() - 1);
} else if (CollUtil.isNotEmpty(wholesaleList) && CollUtil.isEmpty(matchList)) {
throw new ServiceException(ResultCode.DO_NOT_MATCH_WHOLESALE);
}
return null;
}
}
|
LambdaQueryWrapper<Wholesale> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Wholesale::getTemplateId, templateId);
cache.remove("{wholesale}_" + templateId + "_template");
return this.remove(queryWrapper);
| 677
| 71
| 748
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/sku/GoodsSkuBuilder.java
|
GoodsSkuBuilder
|
builderSingle
|
class GoodsSkuBuilder {
private static final String IMAGES_KEY = "images";
/**
* 构建商品sku
*
* @param goods 商品
* @param skuInfo sku信息列表
* @return 商品sku
*/
public static GoodsSku build(Goods goods, Map<String, Object> skuInfo) {
GoodsSku goodsSku = new GoodsSku(goods);
builderSingle(goodsSku, skuInfo);
return goodsSku;
}
/**
* 批量构建商品sku
*
* @param goods 商品
* @return 商品sku
*/
public static List<GoodsSku> buildBatch(Goods goods, List<Map<String, Object>> skuList) {
Assert.notEmpty(skuList, "skuList不能为空");
Assert.notNull(goods, "goods不能为空");
List<GoodsSku> goodsSkus = new ArrayList<>();
for (Map<String, Object> skuInfo : skuList) {
GoodsSku goodsSku = new GoodsSku(goods);
builderSingle(goodsSku, skuInfo);
goodsSkus.add(goodsSku);
}
return goodsSkus;
}
private static void builderSingle(GoodsSku goodsSku, Map<String, Object> skuInfo) {<FILL_FUNCTION_BODY>}
}
|
Assert.notNull(goodsSku, "goodsSku不能为空");
Assert.notEmpty(skuInfo, "skuInfo不能为空");
//规格简短信息
StringBuilder simpleSpecs = new StringBuilder();
//商品名称
StringBuilder goodsName = new StringBuilder(goodsSku.getGoodsName());
//规格值
Map<String, Object> specMap = new LinkedHashMap<>();
// 原始规格项
String[] ignoreOriginKeys = {"id", "sn", "cost", "price", "quantity", "weight", "alertQuantity"};
//获取规格信息
for (Map.Entry<String, Object> spec : skuInfo.entrySet()) {
//保存新增规格信息
if (!CollUtil.contains(Arrays.asList(ignoreOriginKeys), spec.getKey()) && spec.getValue() != null) {
specMap.put(spec.getKey(), spec.getValue());
if (!spec.getKey().equals(IMAGES_KEY)) {
//设置商品名称
goodsName.append(" ").append(spec.getValue());
//规格简短信息
simpleSpecs.append(" ").append(spec.getValue());
}
}
}
//设置规格信息
goodsSku.setGoodsName(goodsName.toString());
//规格信息
goodsSku.setId(Convert.toStr(skuInfo.get("id"), ""));
goodsSku.setSn(Convert.toStr(skuInfo.get("sn")));
goodsSku.setWeight(Convert.toDouble(skuInfo.get("weight"), 0D));
goodsSku.setPrice(Convert.toDouble(skuInfo.get("price"), 0D));
goodsSku.setCost(Convert.toDouble(skuInfo.get("cost"), 0D));
goodsSku.setQuantity(Convert.toInt(skuInfo.get("quantity"), 0));
goodsSku.setSpecs(JSONUtil.toJsonStr(specMap));
goodsSku.setSimpleSpecs(simpleSpecs.toString());
goodsSku.setAlertQuantity(Convert.toInt(skuInfo.get("alertQuantity"), 0));
| 387
| 568
| 955
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/sku/render/impl/WholesaleSaleModelRenderImpl.java
|
WholesaleSaleModelRenderImpl
|
checkWholesaleList
|
class WholesaleSaleModelRenderImpl implements SalesModelRender {
/**
* 批发商品
*/
@Autowired
private WholesaleService wholesaleService;
@Override
@Transactional(rollbackFor = Exception.class)
public void renderSingle(GoodsSku goodsSku, GoodsOperationDTO goodsOperationDTO) {
Assert.notEmpty(goodsOperationDTO.getWholesaleList(), "批发规则不能为空");
this.checkWholesaleList(goodsOperationDTO.getWholesaleList(), goodsSku);
List<Wholesale> collect = goodsOperationDTO.getWholesaleList().stream().sorted(Comparator.comparing(Wholesale::getPrice)).collect(Collectors.toList());
wholesaleService.removeByGoodsId(goodsSku.getGoodsId());
wholesaleService.saveOrUpdateBatch(collect);
goodsSku.setPrice(collect.get(0).getPrice());
goodsSku.setCost(collect.get(0).getPrice());
}
@Override
@Transactional(rollbackFor = Exception.class)
public void renderBatch(List<GoodsSku> goodsSkus, GoodsOperationDTO goodsOperationDTO) {
Assert.notEmpty(goodsOperationDTO.getWholesaleList(), "批发规则不能为空");
this.checkWholesaleList(goodsOperationDTO.getWholesaleList(), goodsSkus.get(0));
List<Wholesale> collect = goodsOperationDTO.getWholesaleList().stream().sorted(Comparator.comparing(Wholesale::getPrice)).collect(Collectors.toList());
for (GoodsSku skus : goodsSkus) {
skus.setPrice(collect.get(0).getPrice());
skus.setCost(collect.get(0).getPrice());
}
if (Boolean.TRUE.equals(goodsOperationDTO.getGoodsTemplateFlag())) {
wholesaleService.removeByTemplateId(goodsSkus.get(0).getGoodsId());
} else {
wholesaleService.removeByGoodsId(goodsSkus.get(0).getGoodsId());
}
wholesaleService.saveOrUpdateBatch(collect);
}
private void checkWholesaleList(List<WholesaleDTO> wholesaleList, GoodsSku goodsSku) {<FILL_FUNCTION_BODY>}
@Override
public String getSalesMode() {
return GoodsSalesModeEnum.WHOLESALE.name();
}
}
|
if (CollUtil.isEmpty(wholesaleList)) {
throw new ServiceException(ResultCode.MUST_HAVE_SALES_MODEL);
}
for (WholesaleDTO wholesaleDTO : wholesaleList) {
if (wholesaleDTO.getPrice() == null || wholesaleDTO.getPrice() <= 0 || wholesaleDTO.getNum() == null || wholesaleDTO.getNum() <= 0) {
throw new ServiceException(ResultCode.HAVE_INVALID_SALES_MODEL);
}
if (CharSequenceUtil.isEmpty(wholesaleDTO.getGoodsId())) {
wholesaleDTO.setGoodsId(goodsSku.getGoodsId());
}
}
| 652
| 188
| 840
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/goods/util/WechatMediaUtil.java
|
WechatMediaUtil
|
uploadMedia
|
class WechatMediaUtil {
@Autowired
private WechatAccessTokenUtil wechatAccessTokenUtil;
/**
* 上传多媒体数据到微信服务器
*
* @param mediaFileUrl 来自网络上面的媒体文件地址
* @return
*/
public String uploadMedia(String type, String mediaFileUrl) {<FILL_FUNCTION_BODY>}
/**
* 通过传过来的contentType判断是哪一种类型
*
* @param contentType 获取来自连接的contentType
* @return
*/
public String judgeType(String contentType) {
String fileExt = "";
switch (contentType) {
case "image/png":
fileExt = ".png";
break;
case "image/jpeg":
fileExt = ".jpeg";
break;
case "image/jpg":
fileExt = ".jpg";
break;
default:
throw new ServiceException(ResultCode.IMAGE_FILE_EXT_ERROR);
}
return fileExt;
}
}
|
//获取token
String accessToken = wechatAccessTokenUtil.cgiAccessToken(ClientTypeEnum.WECHAT_MP);
/*
* 上传媒体文件到微信服务器需要请求的地址
*/
String MEDIA_URL = "https://api.weixin.qq.com/cgi-bin/media/upload?access_token=ACCESS_TOKEN&type=TYPE";
StringBuffer resultStr = null;
//拼装url地址
String mediaStr = MEDIA_URL.replace("ACCESS_TOKEN", accessToken).replace("TYPE", type);
URL mediaUrl;
try {
String boundary = "----WebKitFormBoundaryOYXo8heIv9pgpGjT";
URL url = new URL(mediaStr);
HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
//让输入输出流开启
urlConn.setDoInput(true);
urlConn.setDoOutput(true);
//使用post方式请求的时候必须关闭缓存
urlConn.setUseCaches(false);
//设置请求头的Content-Type属性
urlConn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
urlConn.setRequestMethod("POST");
//获取输出流，使用输出流拼接请求体
OutputStream out = urlConn.getOutputStream();
//读取文件的数据,构建一个GET请求，然后读取指定地址中的数据
mediaUrl = new URL(mediaFileUrl);
HttpURLConnection mediaConn = (HttpURLConnection) mediaUrl.openConnection();
//设置请求方式
mediaConn.setRequestMethod("GET");
//设置可以打开输入流
mediaConn.setDoInput(true);
//获取传输的数据类型
String contentType = mediaConn.getHeaderField("Content-Type");
//将获取大到的类型转换成扩展名
String fileExt = judgeType(contentType);
//获取输入流，从mediaURL里面读取数据
InputStream in = mediaConn.getInputStream();
BufferedInputStream bufferedIn = new BufferedInputStream(in);
//数据读取到这个数组里面
byte[] bytes = new byte[1024];
int size = 0;
//使用outputStream流输出信息到请求体当中去
out.write(("--" + boundary + "\r\n").getBytes());
out.write(("Content-Disposition: form-data; name=\"media\";\r\n"
+ "filename=\"" + (System.currentTimeMillis()) + fileExt + "\"\r\n"
+ "Content-Type: " + contentType + "\r\n\r\n").getBytes());
while ((size = bufferedIn.read(bytes)) != -1) {
out.write(bytes, 0, size);
}
//切记，这里的换行符不能少，否则将会报41005错误
out.write(("\r\n--" + boundary + "--\r\n").getBytes());
bufferedIn.close();
in.close();
mediaConn.disconnect();
InputStream resultIn = urlConn.getInputStream();
InputStreamReader reader = new InputStreamReader(resultIn);
BufferedReader bufferedReader = new BufferedReader(reader);
String tempStr = null;
resultStr = new StringBuffer();
while ((tempStr = bufferedReader.readLine()) != null) {
resultStr.append(tempStr);
}
bufferedReader.close();
reader.close();
resultIn.close();
urlConn.disconnect();
} catch (Exception e) {
log.error("微信媒体上传失败", e);
}
assert resultStr != null;
JSONObject jsonObject = new JSONObject(resultStr.toString());
log.info("微信媒体上传:" + jsonObject);
//判断是否传递成功，如果token过期则重新获取
if (jsonObject.get("errcode") != null && ("40001").equals(jsonObject.get("errcode"))) {
wechatAccessTokenUtil.removeAccessToken(ClientTypeEnum.WECHAT_MP);
return this.uploadMedia(type, mediaFileUrl);
} else if (jsonObject.get("errcode") != null) {
throw new ServiceException(jsonObject.get("errmsg").toString());
} else {
return jsonObject.get("media_id").toString();
}
| 269
| 1,131
| 1,400
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/im/config/WebSocketConfigurator.java
|
WebSocketConfigurator
|
customSpringConfigurator
|
class WebSocketConfigurator {
@Bean
public CustomSpringConfigurator customSpringConfigurator() {<FILL_FUNCTION_BODY>}
}
|
// This is just to get context
return new CustomSpringConfigurator();
| 44
| 23
| 67
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/im/entity/dto/ImQueryParams.java
|
ImQueryParams
|
queryWrapper
|
class ImQueryParams extends PageVO {
private static final long serialVersionUID = 5792718094087541134L;
@ApiModelProperty("用户Id")
private String memberId;
@ApiModelProperty("店铺Id")
private String storeId;
public <T> QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
if (CharSequenceUtil.isNotEmpty(memberId)) {
queryWrapper.eq("member_id", memberId);
}
if (CharSequenceUtil.isNotEmpty(storeId)) {
queryWrapper.eq("store_id", storeId);
}
queryWrapper.eq("delete_flag", false);
queryWrapper.orderByDesc("create_time");
return queryWrapper;
| 108
| 116
| 224
|
<methods>public non-sealed void <init>() ,public java.lang.String getSort() <variables>private java.lang.Boolean notConvert,private java.lang.String order,private java.lang.Integer pageNumber,private java.lang.Integer pageSize,private static final long serialVersionUID,private java.lang.String sort
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/im/entity/dto/MessageQueryParams.java
|
MessageQueryParams
|
initQueryWrapper
|
class MessageQueryParams extends PageVO {
private static final long serialVersionUID = 3504156704697214077L;
/**
* 聊天窗口
*/
private String talkId;
/**
* 最后一个消息
*/
private String lastMessageId;
/**
* 获取消息数量
*/
private Integer num;
public LambdaQueryWrapper<ImMessage> initQueryWrapper() {<FILL_FUNCTION_BODY>}
}
|
if (CharSequenceUtil.isEmpty(talkId)) {
throw new ServiceException(ResultCode.ERROR);
}
if (num == null || num > 50) {
num = 50;
}
LambdaQueryWrapper<ImMessage> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ImMessage::getTalkId, talkId);
if (CharSequenceUtil.isNotEmpty(lastMessageId)) {
lambdaQueryWrapper.lt(ImMessage::getId, lastMessageId);
}
lambdaQueryWrapper.orderByDesc(ImMessage::getCreateTime);
// lambdaQueryWrapper.last("limit " + num);
return lambdaQueryWrapper;
| 134
| 178
| 312
|
<methods>public non-sealed void <init>() ,public java.lang.String getSort() <variables>private java.lang.Boolean notConvert,private java.lang.String order,private java.lang.Integer pageNumber,private java.lang.Integer pageSize,private static final long serialVersionUID,private java.lang.String sort
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/im/serviceimpl/ImMessageServiceImpl.java
|
ImMessageServiceImpl
|
ListSort
|
class ImMessageServiceImpl extends ServiceImpl<ImMessageMapper, ImMessage> implements ImMessageService {
@Autowired
private ImTalkService imTalkService;
@Override
public void read(String talkId, String accessToken) {
LambdaUpdateWrapper<ImMessage> updateWrapper = new LambdaUpdateWrapper<>();
String userId = UserContext.getAuthUser(accessToken).getId();
updateWrapper.eq(ImMessage::getTalkId, talkId);
updateWrapper.eq(ImMessage::getToUser, userId);
updateWrapper.set(ImMessage::getIsRead, true);
this.update(updateWrapper);
}
@Override
public List<ImMessage> unReadMessages(String accessToken) {
String userId = UserContext.getAuthUser(accessToken).getId();
LambdaQueryWrapper<ImMessage> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ImMessage::getToUser, userId);
queryWrapper.eq(ImMessage::getIsRead, false);
return this.list(queryWrapper);
}
@Override
public List<ImMessage> historyMessage(String accessToken, String to) {
String userId = UserContext.getAuthUser(accessToken).getId();
LambdaQueryWrapper<ImMessage> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.and(i -> i.eq(ImMessage::getToUser, userId).and(j -> j.eq(ImMessage::getFromUser, to)));
queryWrapper.or(i -> i.eq(ImMessage::getToUser, to).and(j -> j.eq(ImMessage::getFromUser, userId)));
queryWrapper.orderByDesc(ImMessage::getCreateTime);
return this.list(queryWrapper);
}
@Override
public Boolean hasNewMessage(String accessToken) {
String userId = UserContext.getAuthUser(accessToken).getId();
LambdaQueryWrapper<ImMessage> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ImMessage::getIsRead, false);
queryWrapper.eq(ImMessage::getToUser, userId);
return this.list(queryWrapper).size() > 0;
}
@Override
public List<ImMessage> getList(MessageQueryParams messageQueryParams) {
List<ImMessage> messageList = this.page(PageUtil.initPage(messageQueryParams), messageQueryParams.initQueryWrapper()).getRecords();
ListSort(messageList);
readMessage(messageList);
return messageList;
}
@Override
public Long unreadMessageCount() {
AuthUser currentUser = UserContext.getCurrentUser();
if(currentUser == null){
throw new ServiceException(ResultCode.USER_NOT_LOGIN);
}
return this.count(new LambdaQueryWrapper<ImMessage>().eq(ImMessage::getToUser,currentUser.getId()).eq(ImMessage::getIsRead,false));
}
@Override
public void cleanUnreadMessage() {
AuthUser currentUser = UserContext.getCurrentUser();
if(currentUser == null){
throw new ServiceException(ResultCode.USER_NOT_LOGIN);
}
this.update(new LambdaUpdateWrapper<ImMessage>().eq(ImMessage::getToUser,currentUser.getId()).set(ImMessage::getIsRead,true));
}
/**
* 根据时间倒叙
*
* @param list
*/
private static void ListSort(List<ImMessage> list) {<FILL_FUNCTION_BODY>}
/**
* 阅读消息
*
* @param messageList 消息列表
*/
private void readMessage(List<ImMessage> messageList) {
if (!messageList.isEmpty()) {
//判断用户类型
AuthUser authUser = Objects.requireNonNull(UserContext.getCurrentUser());
String toUserId = "";
if(UserEnums.MEMBER.equals(authUser.getRole())){
toUserId = authUser.getId();
}else if(UserEnums.STORE.equals(authUser.getRole())){
toUserId = authUser.getStoreId();
}
//发送给自己的未读信息进行已读操作
for (ImMessage imMessage : messageList) {
if(Boolean.FALSE.equals(imMessage.getIsRead()) && imMessage.getToUser().equals(toUserId)){
imMessage.setIsRead(true);
}
}
}
this.updateBatchById(messageList);
}
}
|
list.sort(new Comparator<ImMessage>() {
@Override
public int compare(ImMessage e1, ImMessage e2) {
try {
if (e1.getCreateTime().before(e2.getCreateTime())) {
return -1;
} else {
return 1;
}
} catch (Exception e) {
e.printStackTrace();
}
return 0;
}
});
| 1,147
| 117
| 1,264
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/im/serviceimpl/QAServiceImpl.java
|
QAServiceImpl
|
getStoreQA
|
class QAServiceImpl extends ServiceImpl<QAMapper, QA> implements QAService {
@Override
public IPage<QA> getStoreQA(String word, PageVO pageVo) {<FILL_FUNCTION_BODY>}
}
|
LambdaQueryWrapper<QA> qaLambdaQueryWrapper = new LambdaQueryWrapper<>();
qaLambdaQueryWrapper.eq(QA::getTenantId, UserContext.getCurrentUser().getTenantId());
qaLambdaQueryWrapper.like(QA::getQuestion, word);
return this.page(PageUtil.initPage(pageVo), qaLambdaQueryWrapper);
| 66
| 97
| 163
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/im/serviceimpl/SeatServiceImpl.java
|
SeatServiceImpl
|
usernameLogin
|
class SeatServiceImpl extends ServiceImpl<SeatMapper, Seat> implements SeatService {
@Autowired
private SeatTokenGenerate seatTokenGenerate;
@Autowired
private Cache<String> cache;
/**
* 快捷登录缓存前缀
*/
private static String prefix = "{quick_login}_";
@Override
public List<SeatVO> seatVoList(String storeId) {
LambdaQueryWrapper<Seat> seatLambdaQueryWrapper = new LambdaQueryWrapper<>();
seatLambdaQueryWrapper.eq(Seat::getTenantId, storeId);
List<Seat> list = this.list(seatLambdaQueryWrapper);
//转换模型为VO
List<SeatVO> results = list.stream().map(item -> (SeatVO) item).collect(Collectors.toList());
//填充坐席当前状态
//todo
results.forEach(item -> {
item.setOnlineStatus(OnlineStatusEnum.ONLINE.name());
});
return results;
}
@Override
public Token usernameLogin(String username, String password) {<FILL_FUNCTION_BODY>}
@Override
public String createQuickLoginCode(String username) {
String code = UUID.randomUUID().toString();
cache.put(prefix + code, username, 20L);
return code;
}
@Override
public Token quickLogin(String code) {
String username = cache.get(prefix + code);
cache.remove(prefix + code);
if (StringUtils.isEmpty(username)) {
throw new ServiceException(ResultCode.ERROR);
}
return seatTokenGenerate.createToken(findByUsername(username), true);
}
/**
* 查询坐席
*
* @param username
* @return
*/
@Override
public Seat findByUsername(String username) {
LambdaQueryWrapper<Seat> seatLambdaQueryWrapper = new LambdaQueryWrapper<>();
seatLambdaQueryWrapper.eq(Seat::getUsername, username);
return this.getOne(seatLambdaQueryWrapper);
}
}
|
Seat seat = this.findByUsername(username);
//判断用户是否存在
if (seat == null || !seat.getDisabled()) {
throw new ServiceException(ResultCode.ERROR);
}
//判断密码是否输入正确
if (!new BCryptPasswordEncoder().matches(password, seat.getPassword())) {
throw new ServiceException(ResultCode.ERROR);
}
return seatTokenGenerate.createToken(seat, true);
| 561
| 121
| 682
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/im/serviceimpl/SeatSettingServiceImpl.java
|
SeatSettingServiceImpl
|
updateByStore
|
class SeatSettingServiceImpl extends ServiceImpl<SeatSettingMapper, SeatSetting> implements SeatSettingService {
@Override
public SeatSetting getSetting(String storeId) {
LambdaQueryWrapper<SeatSetting> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SeatSetting::getTenantId, storeId);
SeatSetting seatSetting = this.baseMapper.selectOne(queryWrapper);
if (seatSetting == null) {
seatSetting = new SeatSetting();
seatSetting.setOutLineAutoReply("您好，我现在不在线，请您留下关键内容和联系方式，我看到后会立马回电。");
seatSetting.setLongTermAutoReply("您好，我正在查阅相关资料，请您稍等。");
seatSetting.setWelcome("您好，请问有什么可以帮您？");
seatSetting.setTenantId(storeId);
this.save(seatSetting);
}
return seatSetting;
}
@Override
public SeatSetting updateByStore(SeatSetting seatSetting) {<FILL_FUNCTION_BODY>}
}
|
SeatSetting oldSetting = this.baseMapper.selectById(seatSetting.getId());
if (oldSetting.getTenantId().equals(seatSetting.getTenantId())) {
this.updateById(seatSetting);
} else {
throw new ServiceException(ResultCode.ERROR);
}
return seatSetting;
| 281
| 86
| 367
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/im/token/SeatTokenGenerate.java
|
SeatTokenGenerate
|
createToken
|
class SeatTokenGenerate extends AbstractTokenGenerate<Seat> {
@Autowired
private TokenUtil tokenUtil;
@Override
public Token createToken(Seat seat, Boolean longTerm) {<FILL_FUNCTION_BODY>}
@Override
public Token refreshToken(String refreshToken) {
return tokenUtil.refreshToken(refreshToken);
}
}
|
AuthUser authUser = AuthUser.builder()
.username(seat.getUsername())
.id(seat.getId())
.nickName(seat.getNickName())
.face(seat.getFace())
.role(UserEnums.SEAT)
.longTerm(longTerm)
.tenantId(seat.getTenantId())
.build();
//登陆成功生成token
return tokenUtil.createToken(authUser);
| 104
| 126
| 230
|
<methods>public non-sealed void <init>() ,public abstract cn.lili.common.security.token.Token createToken(cn.lili.modules.im.entity.dos.Seat, java.lang.Boolean) ,public abstract cn.lili.common.security.token.Token refreshToken(java.lang.String) <variables>public cn.lili.common.security.enums.UserEnums role
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/logistics/LogisticsPluginFactory.java
|
LogisticsPluginFactory
|
filePlugin
|
class LogisticsPluginFactory {
@Autowired
private SettingService settingService;
/**
* 获取logistics client
*
* @return
*/
public LogisticsPlugin filePlugin() {<FILL_FUNCTION_BODY>}
}
|
LogisticsSetting logisticsSetting = null;
try {
Setting setting = settingService.get(SettingEnum.LOGISTICS_SETTING.name());
logisticsSetting = JSONUtil.toBean(setting.getSettingValue(), LogisticsSetting.class);
switch (LogisticsEnum.valueOf(logisticsSetting.getType())) {
case KDNIAO:
return new KdniaoPlugin(logisticsSetting);
case KUAIDI100:
return new Kuaidi100Plugin(logisticsSetting);
case SHUNFENG:
return new ShunfengPlugin(logisticsSetting);
default:
throw new ServiceException();
}
} catch (Exception e) {
throw new ServiceException();
}
| 73
| 191
| 264
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/logistics/plugin/kuaidi100/Kuaidi100Plugin.java
|
Kuaidi100Plugin
|
pollQuery
|
class Kuaidi100Plugin implements LogisticsPlugin {
@Autowired
private LogisticsSetting logisticsSetting;
public Kuaidi100Plugin(LogisticsSetting logisticsSetting) {
this.logisticsSetting = logisticsSetting;
}
@Override
public LogisticsEnum pluginName() {
return LogisticsEnum.KUAIDI100;
}
@Override
public Traces pollQuery(Logistics logistics, String expNo, String phone) {<FILL_FUNCTION_BODY>}
@Override
public Traces pollMapTrack(Logistics logistics, String expNo, String phone, String from, String to) {
try {
QueryTrackReq queryTrackReq = new QueryTrackReq();
QueryTrackParam queryTrackParam = new QueryTrackParam();
queryTrackParam.setCom(logistics.getCode());
queryTrackParam.setNum(expNo);
queryTrackParam.setPhone(phone);
queryTrackParam.setFrom(from);
queryTrackParam.setTo(to);
queryTrackParam.setResultv2("5");
String param = new Gson().toJson(queryTrackParam);
queryTrackReq.setParam(param);
queryTrackReq.setCustomer(logisticsSetting.getKuaidi100Customer());
queryTrackReq.setSign(SignUtils.querySign(param, logisticsSetting.getKuaidi100Key(), logisticsSetting.getKuaidi100Customer()));
IBaseClient baseClient = new QueryTrackMap();
HttpResult result = baseClient.execute(queryTrackReq);
QueryTrackMapResp queryTrackMapResp = new Gson().fromJson(result.getBody(), QueryTrackMapResp.class);
System.out.println(queryTrackMapResp);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
public Map<String, Object> labelOrder(LabelOrderDTO labelOrderDTO) {
try {
//订单
Order order = labelOrderDTO.getOrder();
//订单货物
List<OrderItem> orderItems = labelOrderDTO.getOrderItems();
//获取对应物流
Logistics logistics = labelOrderDTO.getLogistics();
//收件人地址
String[] consigneeAddress = order.getConsigneeAddressPath().split(",");
//获取店家信息
StoreDeliverGoodsAddressDTO storeDeliverGoodsAddressDTO = labelOrderDTO.getStoreDeliverGoodsAddressDTO();
//发件人地址
String[] consignorAddress = storeDeliverGoodsAddressDTO.getSalesConsignorAddressPath().split(",");
//店铺-物流公司设置
StoreLogistics storeLogistics = labelOrderDTO.getStoreLogistics();
ManInfo recManInfo = new ManInfo();
recManInfo.setName(order.getConsigneeName());
recManInfo.setMobile(order.getConsigneeMobile());
recManInfo.setPrintAddr(consigneeAddress[0] + consigneeAddress[1] + consigneeAddress[2] + consigneeAddress[3] + order.getConsigneeDetail());
ManInfo sendManInfo = new ManInfo();
sendManInfo.setName(storeDeliverGoodsAddressDTO.getSalesConsignorName());
sendManInfo.setMobile(storeDeliverGoodsAddressDTO.getSalesConsignorMobile());
sendManInfo.setPrintAddr(consignorAddress[0] + consignorAddress[1] + consignorAddress[2] + consignorAddress[3] + storeDeliverGoodsAddressDTO.getSalesConsignorDetail());
OrderReq orderReq = new OrderReq();
orderReq.setKuaidicom(logistics.getCode());
orderReq.setCount(1);
// orderReq.setSiid(siid);
//orderReq.setTempId("60f6c17c7c223700131d8bc3");
orderReq.setSendMan(sendManInfo);
orderReq.setRecMan(recManInfo);
orderReq.setPrintType(PrintType.CLOUD);
String param = new Gson().toJson(orderReq);
String t = System.currentTimeMillis() + "";
PrintReq printReq = new PrintReq();
printReq.setT(t);
printReq.setKey(logisticsSetting.getKuaidi100Key());
printReq.setSign(SignUtils.printSign(param, t, logisticsSetting.getKuaidi100Key(), logisticsSetting.getKuaidi100Customer()));
printReq.setMethod(ApiInfoConstant.ORDER);
printReq.setParam(param);
IBaseClient baseClient = new LabelV2();
HttpResult result = baseClient.execute(printReq);
System.out.println(result.getBody());
QueryTrackMapResp queryTrackMapResp = new Gson().fromJson(result.getBody(), QueryTrackMapResp.class);
OrderResp orderResp = new Gson().fromJson(result.getBody(), OrderResp.class);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
public String createOrder(OrderDetailVO orderDetailVO) {
return null;
}
}
|
try {
QueryTrackReq queryTrackReq = new QueryTrackReq();
QueryTrackParam queryTrackParam = new QueryTrackParam();
queryTrackParam.setCom(logistics.getCode());
queryTrackParam.setNum(expNo);
queryTrackParam.setPhone(phone);
String param = new Gson().toJson(queryTrackParam);
queryTrackReq.setParam(param);
queryTrackReq.setCustomer(logisticsSetting.getKuaidi100Customer());
queryTrackReq.setSign(Kuaidi100SignUtils.querySign(param, logisticsSetting.getKuaidi100Key(), logisticsSetting.getKuaidi100Customer()));
IBaseClient baseClient = new QueryTrack();
HttpResult httpResult = baseClient.execute(queryTrackReq);
QueryTrackResp queryTrackResp = new Gson().fromJson(httpResult.getBody(), QueryTrackResp.class);
log.info(String.valueOf(queryTrackResp.getData()));
List<Map> traces = new ArrayList<>();
for (QueryTrackData queryTrackData : queryTrackResp.getData()) {
Map map = new HashMap<String, String>();
map.put("AcceptTime", queryTrackData.getTime());
map.put("AcceptStation", queryTrackData.getContext());
map.put("Remark", null);
traces.add(map);
}
return new Traces(logistics.getName(), expNo, traces);
} catch (Exception e) {
e.printStackTrace();
}
return null;
| 1,390
| 401
| 1,791
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/aop/interceptor/PointLogInterceptor.java
|
PointLogInterceptor
|
doAfter
|
class PointLogInterceptor {
@Autowired
private MemberPointsHistoryService memberPointsHistoryService;
@Autowired
private MemberService memberService;
@After("@annotation(cn.lili.modules.member.aop.annotation.PointLogPoint)")
public void doAfter(JoinPoint pjp) {<FILL_FUNCTION_BODY>}
}
|
//参数
Object[] obj = pjp.getArgs();
try {
//变动积分
Long point = 0L;
if (obj[0] != null) {
point = Long.valueOf(obj[0].toString());
}
//变动类型
String type = PointTypeEnum.INCREASE.name();
if (obj[1] != null) {
type = obj[1].toString();
}
// 会员ID
String memberId = "";
if (obj[2] != null) {
memberId = obj[2].toString();
}
// 变动积分为0，则直接返回
if (point == 0) {
return;
}
//根据会员id查询会员信息
Member member = memberService.getById(memberId);
if (member != null) {
MemberPointsHistory memberPointsHistory = new MemberPointsHistory();
memberPointsHistory.setMemberId(member.getId());
memberPointsHistory.setMemberName(member.getUsername());
memberPointsHistory.setPointType(type);
memberPointsHistory.setVariablePoint(point);
if (type.equals(PointTypeEnum.INCREASE.name())) {
memberPointsHistory.setBeforePoint(member.getPoint() - point);
} else {
memberPointsHistory.setBeforePoint(member.getPoint() + point);
}
memberPointsHistory.setPoint(member.getPoint());
memberPointsHistory.setContent(obj[3] == null ? "" : obj[3].toString());
memberPointsHistory.setCreateBy("系统");
memberPointsHistoryService.save(memberPointsHistory);
}
} catch (Exception e) {
log.error("积分操作错误", e);
}
| 99
| 448
| 547
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/entity/dto/EvaluationQueryParams.java
|
EvaluationQueryParams
|
queryWrapper
|
class EvaluationQueryParams extends PageVO {
private static final long serialVersionUID = 2038158669175297129L;
@ApiModelProperty(value = "ID")
private String id;
@ApiModelProperty(value = "买家ID")
private String memberId;
@ApiModelProperty(value = "skuID")
private String skuId;
@ApiModelProperty(value = "会员名称")
private String memberName;
@ApiModelProperty(value = "卖家名称")
private String storeName;
@ApiModelProperty(value = "卖家ID")
private String storeId;
@ApiModelProperty(value = "商品名称")
private String goodsName;
@ApiModelProperty(value = "商品ID")
private String goodsId;
@ApiModelProperty(value = "好中差评 , GOOD：好评，MODERATE：中评，WORSE：差评", allowableValues = "GOOD,MODERATE,WORSE")
private String grade;
@ApiModelProperty(value = "是否有图")
private String haveImage;
@ApiModelProperty(value = "评论日期--开始时间")
private String startTime;
@ApiModelProperty(value = "评论日期--结束时间")
private String endTime;
@ApiModelProperty(value = "状态")
private String status;
public <T> QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
if (CharSequenceUtil.isNotEmpty(id)) {
queryWrapper.eq("id", id);
}
if (CharSequenceUtil.isNotEmpty(startTime) && CharSequenceUtil.isNotEmpty(endTime)) {
queryWrapper.between("create_time", startTime, endTime);
}
if (CharSequenceUtil.isNotEmpty(grade)) {
queryWrapper.eq("grade", grade);
}
if (CharSequenceUtil.isNotEmpty(goodsName)) {
queryWrapper.like("goods_name", goodsName);
}
if (CharSequenceUtil.isNotEmpty(storeName)) {
queryWrapper.like("store_name", storeName);
}
if (CharSequenceUtil.isNotEmpty(memberName)) {
queryWrapper.like("member_name", memberName);
}
if (CharSequenceUtil.isNotEmpty(goodsId)) {
queryWrapper.eq("goods_id", goodsId);
}
if (CharSequenceUtil.isNotEmpty(skuId)) {
queryWrapper.eq("sku_id", skuId);
}
if (CharSequenceUtil.isNotEmpty(storeId)) {
queryWrapper.eq("store_id", storeId);
}
if (CharSequenceUtil.isNotEmpty(memberId)) {
queryWrapper.eq("member_id", memberId);
}
if (CharSequenceUtil.isNotEmpty(haveImage)) {
queryWrapper.eq("have_image", haveImage);
}
if (CharSequenceUtil.isNotEmpty(status)) {
queryWrapper.eq("status", status);
}
queryWrapper.eq("delete_flag", false);
queryWrapper.orderByDesc("create_time");
return queryWrapper;
| 398
| 456
| 854
|
<methods>public non-sealed void <init>() ,public java.lang.String getSort() <variables>private java.lang.Boolean notConvert,private java.lang.String order,private java.lang.Integer pageNumber,private java.lang.Integer pageSize,private static final long serialVersionUID,private java.lang.String sort
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/entity/dto/FootPrintQueryParams.java
|
FootPrintQueryParams
|
queryWrapper
|
class FootPrintQueryParams extends PageVO {
@ApiModelProperty("用户Id")
private String memberId;
@ApiModelProperty("店铺Id")
private String storeId;
public <T> QueryWrapper<T> queryWrapper() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
if (CharSequenceUtil.isNotEmpty(memberId)) {
queryWrapper.eq("member_id", memberId);
}
if (CharSequenceUtil.isNotEmpty(storeId)) {
queryWrapper.eq("store_id", storeId);
}
queryWrapper.eq("delete_flag",false);
queryWrapper.orderByDesc("create_time");
return queryWrapper;
| 77
| 116
| 193
|
<methods>public non-sealed void <init>() ,public java.lang.String getSort() <variables>private java.lang.Boolean notConvert,private java.lang.String order,private java.lang.Integer pageNumber,private java.lang.Integer pageSize,private static final long serialVersionUID,private java.lang.String sort
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/entity/vo/MemberReceiptVO.java
|
MemberReceiptVO
|
lambdaQueryWrapper
|
class MemberReceiptVO {
private static final long serialVersionUID = -8210927982915677995L;
@ApiModelProperty(value = "会员ID")
private String memberId;
@ApiModelProperty(value = "会员名称")
private String memberName;
/**
* @see cn.lili.modules.member.entity.enums.MemberReceiptEnum
*/
@ApiModelProperty(value = "发票类型")
private String receiptType;
public LambdaQueryWrapper<MemberReceipt> lambdaQueryWrapper() {<FILL_FUNCTION_BODY>}
}
|
LambdaQueryWrapper<MemberReceipt> queryWrapper = new LambdaQueryWrapper<>();
//会员名称查询
if (StringUtils.isNotEmpty(memberName)) {
queryWrapper.like(MemberReceipt::getMemberName, memberName);
}
//会员id查询
if (StringUtils.isNotEmpty(memberId)) {
queryWrapper.eq(MemberReceipt::getMemberId, memberId);
}
//会员id查询
if (StringUtils.isNotEmpty(receiptType)) {
queryWrapper.eq(MemberReceipt::getReceiptType, receiptType);
}
queryWrapper.eq(MemberReceipt::getDeleteFlag, true);
queryWrapper.orderByDesc(MemberReceipt::getCreateTime);
return queryWrapper;
| 172
| 205
| 377
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/entity/vo/StoreMenuVO.java
|
StoreMenuVO
|
getChildren
|
class StoreMenuVO extends StoreMenu {
@ApiModelProperty(value = "子菜单")
private List<StoreMenuVO> children = new ArrayList<>();
public StoreMenuVO() {
}
public StoreMenuVO(StoreMenu storeMenu) {
BeanUtil.copyProperties(storeMenu, this);
}
public List<StoreMenuVO> getChildren() {<FILL_FUNCTION_BODY>}
}
|
if (children != null) {
children.sort(new Comparator<StoreMenuVO>() {
@Override
public int compare(StoreMenuVO o1, StoreMenuVO o2) {
return o1.getSortOrder().compareTo(o2.getSortOrder());
}
});
return children;
}
return null;
| 111
| 92
| 203
|
<methods>public non-sealed void <init>() <variables>private java.lang.String frontRoute,private java.lang.Integer level,private java.lang.String name,private java.lang.String parentId,private java.lang.String path,private java.lang.String permission,private static final long serialVersionUID,private java.lang.Double sortOrder,private java.lang.String title
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/FootprintServiceImpl.java
|
FootprintServiceImpl
|
footPrintPage
|
class FootprintServiceImpl extends ServiceImpl<FootprintMapper, FootPrint> implements FootprintService {
@Autowired
private GoodsSkuService goodsSkuService;
@Override
public FootPrint saveFootprint(FootPrint footPrint) {
LambdaQueryWrapper<FootPrint> queryWrapper = Wrappers.lambdaQuery();
queryWrapper.eq(FootPrint::getMemberId, footPrint.getMemberId());
queryWrapper.eq(FootPrint::getGoodsId, footPrint.getGoodsId());
//如果已存在某商品记录，则更新其修改时间
//如果不存在则添加记录
//为了保证足迹的排序,将原本足迹删除后重新添加
List<FootPrint> oldPrints = list(queryWrapper);
if (oldPrints != null && !oldPrints.isEmpty()) {
FootPrint oldPrint = oldPrints.get(0);
this.removeById(oldPrint.getId());
}
footPrint.setCreateTime(new Date());
this.save(footPrint);
//删除超过100条后的记录
this.baseMapper.deleteLastFootPrint(footPrint.getMemberId());
return footPrint;
}
@Override
public boolean clean() {
LambdaQueryWrapper<FootPrint> lambdaQueryWrapper = Wrappers.lambdaQuery();
lambdaQueryWrapper.eq(FootPrint::getMemberId, UserContext.getCurrentUser().getId());
return this.remove(lambdaQueryWrapper);
}
@Override
public boolean deleteByIds(List<String> ids) {
LambdaQueryWrapper<FootPrint> lambdaQueryWrapper = Wrappers.lambdaQuery();
lambdaQueryWrapper.eq(FootPrint::getMemberId, UserContext.getCurrentUser().getId());
lambdaQueryWrapper.in(FootPrint::getGoodsId, ids);
return this.remove(lambdaQueryWrapper);
}
@Override
public IPage<EsGoodsIndex> footPrintPage(FootPrintQueryParams params) {<FILL_FUNCTION_BODY>}
@Override
public long getFootprintNum() {
LambdaQueryWrapper<FootPrint> lambdaQueryWrapper = Wrappers.lambdaQuery();
lambdaQueryWrapper.eq(FootPrint::getMemberId, Objects.requireNonNull(UserContext.getCurrentUser()).getId());
lambdaQueryWrapper.eq(FootPrint::getDeleteFlag, false);
return this.count(lambdaQueryWrapper);
}
}
|
params.setSort("createTime");
Page<FootPrint> footPrintPages = this.page(PageUtil.initPage(params), params.queryWrapper());
//定义结果
Page<EsGoodsIndex> esGoodsIndexIPage = new Page<>();
if (footPrintPages.getRecords() != null && !footPrintPages.getRecords().isEmpty()) {
List<String> skuIds = footPrintPages.getRecords().stream().map(FootPrint::getSkuId).collect(Collectors.toList());
List<GoodsSku> goodsSkuByIdFromCache = goodsSkuService.getGoodsSkuByIdFromCache(skuIds);
List<EsGoodsIndex> collect = IntStream.range(0, goodsSkuByIdFromCache.size())
.mapToObj(i -> {
if (goodsSkuByIdFromCache.get(i) == null) {
EsGoodsIndex esGoodsIndex = new EsGoodsIndex();
FootPrint footPrint = footPrintPages.getRecords().get(i);
esGoodsIndex.setGoodsId(footPrint.getGoodsId());
esGoodsIndex.setId(footPrint.getSkuId());
esGoodsIndex.setReleaseTime(footPrintPages.getRecords().get(i).getCreateTime().getTime());
return esGoodsIndex;
}
Optional<FootPrint> first = footPrintPages.getRecords().stream().filter(j -> j.getSkuId().equals(goodsSkuByIdFromCache.get(i).getId())).findFirst();
return first.map(footPrint -> new EsGoodsIndex(goodsSkuByIdFromCache.get(i), footPrint.getCreateTime())).orElseGet(() -> new EsGoodsIndex(goodsSkuByIdFromCache.get(i)));
})
.collect(Collectors.toList());
esGoodsIndexIPage.setPages(footPrintPages.getPages());
esGoodsIndexIPage.setRecords(collect);
esGoodsIndexIPage.setTotal(footPrintPages.getTotal());
esGoodsIndexIPage.setSize(footPrintPages.getSize());
esGoodsIndexIPage.setCurrent(footPrintPages.getCurrent());
return esGoodsIndexIPage;
}
return esGoodsIndexIPage;
| 615
| 582
| 1,197
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/GoodsCollectionServiceImpl.java
|
GoodsCollectionServiceImpl
|
deleteGoodsCollection
|
class GoodsCollectionServiceImpl extends ServiceImpl<GoodsCollectionMapper, GoodsCollection> implements GoodsCollectionService {
@Override
public IPage<GoodsCollectionVO> goodsCollection(PageVO pageVo) {
QueryWrapper<GoodsCollectionVO> queryWrapper = new QueryWrapper();
queryWrapper.eq("gc.member_id", UserContext.getCurrentUser().getId());
queryWrapper.groupBy("gc.id");
queryWrapper.orderByDesc("gc.create_time");
return this.baseMapper.goodsCollectionVOList(PageUtil.initPage(pageVo), queryWrapper);
}
@Override
public boolean isCollection(String skuId) {
QueryWrapper<GoodsCollection> queryWrapper = new QueryWrapper();
queryWrapper.eq("member_id", UserContext.getCurrentUser().getId());
queryWrapper.eq(skuId != null, "sku_id", skuId);
return Optional.ofNullable(this.getOne(queryWrapper)).isPresent();
}
@Override
public GoodsCollection addGoodsCollection(String skuId) {
GoodsCollection goodsCollection = this.getOne(new LambdaUpdateWrapper<GoodsCollection>()
.eq(GoodsCollection::getMemberId, UserContext.getCurrentUser().getId())
.eq(GoodsCollection::getSkuId, skuId));
if (goodsCollection == null) {
goodsCollection = new GoodsCollection(UserContext.getCurrentUser().getId(), skuId);
this.save(goodsCollection);
return goodsCollection;
}
throw new ServiceException(ResultCode.USER_COLLECTION_EXIST);
}
@Override
public boolean deleteGoodsCollection(String skuId) {<FILL_FUNCTION_BODY>}
@Override
public boolean deleteGoodsCollection(List<String> goodsIds) {
QueryWrapper<GoodsCollection> queryWrapper = new QueryWrapper();
queryWrapper.in("sku_id", goodsIds);
return this.remove(queryWrapper);
}
@Override
public boolean deleteSkuCollection(List<String> skuIds) {
QueryWrapper<GoodsCollection> queryWrapper = new QueryWrapper();
queryWrapper.in("sku_id", skuIds);
return this.remove(queryWrapper);
}
}
|
QueryWrapper<GoodsCollection> queryWrapper = new QueryWrapper();
queryWrapper.eq("member_id", UserContext.getCurrentUser().getId());
queryWrapper.eq(skuId != null, "sku_id", skuId);
return this.remove(queryWrapper);
| 582
| 73
| 655
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/MemberAddressServiceImpl.java
|
MemberAddressServiceImpl
|
updateMemberAddress
|
class MemberAddressServiceImpl extends ServiceImpl<MemberAddressMapper, MemberAddress> implements MemberAddressService {
@Override
public IPage<MemberAddress> getAddressByMember(PageVO page, String memberId) {
return this.page(PageUtil.initPage(page),
new QueryWrapper<MemberAddress>()
.eq("member_id", memberId));
}
@Override
public MemberAddress getMemberAddress(String id) {
return this.getOne(
new QueryWrapper<MemberAddress>()
.eq("member_id", Objects.requireNonNull(UserContext.getCurrentUser()).getId())
.eq("id", id));
}
/**
* 根据地址ID获取当前会员地址信息
*
* @return 当前会员的地址信息
*/
@Override
public MemberAddress getDefaultMemberAddress() {
return this.getOne(
new QueryWrapper<MemberAddress>()
.eq("member_id", Objects.requireNonNull(UserContext.getCurrentUser()).getId())
.eq("is_default", true));
}
@Override
@Transactional(rollbackFor = Exception.class)
public MemberAddress saveMemberAddress(MemberAddress memberAddress) {
//判断当前地址是否为默认地址，如果为默认需要将其他的地址修改为非默认
removeDefaultAddress(memberAddress);
//添加会员地址
this.save(memberAddress);
return memberAddress;
}
@Override
@Transactional(rollbackFor = Exception.class)
public MemberAddress updateMemberAddress(MemberAddress memberAddress) {<FILL_FUNCTION_BODY>}
@Override
public boolean removeMemberAddress(String id) {
return this.remove(new QueryWrapper<MemberAddress>()
.eq("id", id));
}
/**
* 修改会员默认收件地址
*
* @param memberAddress 收件地址
*/
private void removeDefaultAddress(MemberAddress memberAddress) {
//如果不是默认地址不需要处理
if (Boolean.TRUE.equals(memberAddress.getIsDefault())) {
//将会员的地址修改为非默认地址
LambdaUpdateWrapper<MemberAddress> lambdaUpdateWrapper = Wrappers.lambdaUpdate();
lambdaUpdateWrapper.set(MemberAddress::getIsDefault, false);
lambdaUpdateWrapper.eq(MemberAddress::getMemberId, memberAddress.getMemberId());
this.update(lambdaUpdateWrapper);
}
}
}
|
MemberAddress originalMemberAddress = this.getMemberAddress(memberAddress.getId());
if (originalMemberAddress != null) {
if (memberAddress.getIsDefault() == null) {
memberAddress.setIsDefault(false);
}
//判断当前地址是否为默认地址，如果为默认需要将其他的地址修改为非默认
removeDefaultAddress(memberAddress);
this.saveOrUpdate(memberAddress);
}
return memberAddress;
| 625
| 120
| 745
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/MemberNoticeSenterServiceImpl.java
|
MemberNoticeSenterServiceImpl
|
customSave
|
class MemberNoticeSenterServiceImpl extends ServiceImpl<MemberNoticeSenterMapper, MemberNoticeSenter> implements MemberNoticeSenterService {
/**
* 会员
*/
@Autowired
private MemberService memberService;
/**
* 会员站内信
*/
@Autowired
private MemberNoticeService memberNoticeService;
@Override
@Transactional(rollbackFor = Exception.class)
public boolean customSave(MemberNoticeSenter memberNoticeSenter) {<FILL_FUNCTION_BODY>}
}
|
if (this.saveOrUpdate(memberNoticeSenter)) {
List<MemberNotice> memberNotices = new ArrayList<>();
//如果是选中会员发送
if (memberNoticeSenter.getSendType().equals(SendTypeEnum.SELECT.name())) {
//判定消息是否有效
if (!CharSequenceUtil.isEmpty(memberNoticeSenter.getMemberIds())) {
String[] ids = memberNoticeSenter.getMemberIds().split(",");
MemberNotice memberNotice;
for (String id : ids) {
memberNotice = new MemberNotice();
memberNotice.setIsRead(false);
memberNotice.setContent(memberNoticeSenter.getContent());
memberNotice.setMemberId(id);
memberNotice.setTitle(memberNoticeSenter.getTitle());
memberNotices.add(memberNotice);
}
} else {
return true;
}
} //否则是全部会员发送
else {
List<Member> members = memberService.list();
MemberNotice memberNotice;
for (Member member : members) {
memberNotice = new MemberNotice();
memberNotice.setIsRead(false);
memberNotice.setContent(memberNoticeSenter.getContent());
memberNotice.setMemberId(member.getId());
memberNotice.setTitle(memberNoticeSenter.getTitle());
memberNotices.add(memberNotice);
}
}
//防止没有会员导致报错
if (!memberNotices.isEmpty()) {
//批量保存
if (memberNoticeService.saveBatch(memberNotices)) {
return true;
} else {
throw new ServiceException(ResultCode.NOTICE_SEND_ERROR);
}
}
}
return true;
| 136
| 435
| 571
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/MemberPointsHistoryServiceImpl.java
|
MemberPointsHistoryServiceImpl
|
MemberPointsHistoryList
|
class MemberPointsHistoryServiceImpl extends ServiceImpl<MemberPointsHistoryMapper, MemberPointsHistory> implements MemberPointsHistoryService {
@Autowired
private MemberService memberService;
@Override
public MemberPointsHistoryVO getMemberPointsHistoryVO(String memberId) {
//获取会员积分历史
Member member = memberService.getById(memberId);
MemberPointsHistoryVO memberPointsHistoryVO = new MemberPointsHistoryVO();
if (member != null) {
memberPointsHistoryVO.setPoint(member.getPoint());
memberPointsHistoryVO.setTotalPoint(member.getTotalPoint());
return memberPointsHistoryVO;
}
return new MemberPointsHistoryVO();
}
@Override
public IPage<MemberPointsHistory> MemberPointsHistoryList(PageVO page, String memberId, String memberName) {<FILL_FUNCTION_BODY>}
}
|
LambdaQueryWrapper<MemberPointsHistory> lambdaQueryWrapper = new LambdaQueryWrapper<MemberPointsHistory>()
.eq(CharSequenceUtil.isNotEmpty(memberId), MemberPointsHistory::getMemberId, memberId)
.like(CharSequenceUtil.isNotEmpty(memberName), MemberPointsHistory::getMemberName, memberName);
//如果排序为空，则默认创建时间倒序
if (CharSequenceUtil.isEmpty(page.getSort())) {
page.setSort("createTime");
page.setOrder("desc");
}
return this.page(PageUtil.initPage(page), lambdaQueryWrapper);
| 217
| 158
| 375
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/MemberReceiptServiceImpl.java
|
MemberReceiptServiceImpl
|
addMemberReceipt
|
class MemberReceiptServiceImpl extends ServiceImpl<MemberReceiptMapper, MemberReceipt> implements MemberReceiptService {
@Autowired
private MemberService memberService;
@Override
public IPage<MemberReceipt> getPage(MemberReceiptVO memberReceiptVO, PageVO pageVO) {
return this.page(PageUtil.initPage(pageVO), memberReceiptVO.lambdaQueryWrapper());
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean addMemberReceipt(MemberReceiptAddVO memberReceiptAddVO, String memberId) {<FILL_FUNCTION_BODY>}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean editMemberReceipt(MemberReceiptAddVO memberReceiptAddVO, String memberId) {
//根据会员id查询发票信息
MemberReceipt memberReceiptDb = this.baseMapper.selectById(memberReceiptAddVO.getId());
if (memberReceiptDb != null) {
//检验是否有权限修改
if (!memberReceiptDb.getMemberId().equals(memberId)) {
throw new ServiceException(ResultCode.USER_AUTHORITY_ERROR);
}
//校验发票抬头是否重复
List<MemberReceipt> receipts = this.baseMapper.selectList(new QueryWrapper<MemberReceipt>()
.eq("member_id", memberId)
.eq("receipt_title", memberReceiptAddVO.getReceiptTitle())
.ne("id", memberReceiptAddVO.getId())
);
if (!receipts.isEmpty()) {
throw new ServiceException(ResultCode.USER_RECEIPT_REPEAT_ERROR);
}
BeanUtil.copyProperties(memberReceiptAddVO, memberReceiptDb);
//对发票默认进行处理 如果参数传递新添加的发票信息为默认，则需要把其他发票置为非默认
if (memberReceiptAddVO.getIsDefault().equals(1)) {
this.update(new UpdateWrapper<MemberReceipt>().eq("member_id", memberId));
}
return this.baseMapper.updateById(memberReceiptDb) > 0 ? true : false;
}
throw new ServiceException(ResultCode.USER_RECEIPT_NOT_EXIST);
}
@Override
public Boolean deleteMemberReceipt(String id) {
//根据会员id查询发票信息
MemberReceipt memberReceiptDb = this.baseMapper.selectById(id);
if (memberReceiptDb != null) {
//如果会员发票信息不为空 则逻辑删除此发票信息
memberReceiptDb.setDeleteFlag(false);
this.baseMapper.updateById(memberReceiptDb);
}
return true;
}
}
|
//校验发票抬头是否重复
List<MemberReceipt> receipts = this.baseMapper.selectList(new QueryWrapper<MemberReceipt>()
.eq("member_id", memberId)
.eq("receipt_title", memberReceiptAddVO.getReceiptTitle())
);
if (!receipts.isEmpty()) {
throw new ServiceException(ResultCode.USER_RECEIPT_REPEAT_ERROR);
}
//参数封装
MemberReceipt memberReceipt = new MemberReceipt();
BeanUtil.copyProperties(memberReceiptAddVO, memberReceipt);
//根据会员信息查询会员
Member member = memberService.getById(memberId);
if (member != null) {
memberReceipt.setMemberId(memberId);
memberReceipt.setMemberName(member.getUsername());
//设置发票默认
List<MemberReceipt> list = this.baseMapper.selectList(new QueryWrapper<MemberReceipt>().eq("member_id", memberId));
//如果当前会员只有一个发票则默认为默认发票，反之需要校验参数默认值，做一些处理
if (list.isEmpty()) {
memberReceipt.setIsDefault(1);
} else {
if (memberReceiptAddVO.getIsDefault().equals(1)) {
//如果参数传递新添加的发票信息为默认，则需要把其他发票置为非默认
this.update(new UpdateWrapper<MemberReceipt>().eq("member_id", memberId));
//设置当前发票信息为默认
memberReceipt.setIsDefault(memberReceiptAddVO.getIsDefault());
} else {
memberReceiptAddVO.setIsDefault(0);
}
}
return this.baseMapper.insert(memberReceipt) > 0 ? true : false;
}
throw new ServiceException(ResultCode.USER_RECEIPT_NOT_EXIST);
| 741
| 510
| 1,251
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/MemberSignServiceImpl.java
|
MemberSignServiceImpl
|
memberSign
|
class MemberSignServiceImpl extends ServiceImpl<MemberSignMapper, MemberSign> implements MemberSignService {
/**
* RocketMQ
*/
@Autowired
private RocketMQTemplate rocketMQTemplate;
/**
* RocketMQ 配置
*/
@Autowired
private RocketmqCustomProperties rocketmqCustomProperties;
/**
* 配置
*/
@Autowired
private SettingService settingService;
/**
* 会员
*/
@Autowired
private MemberService memberService;
@Override
public Boolean memberSign() {<FILL_FUNCTION_BODY>}
@Override
public List<MemberSign> getMonthSignDay(String time) {
//获取当前会员
AuthUser authUser = UserContext.getCurrentUser();
if (authUser != null) {
return this.baseMapper.getMonthMemberSign(authUser.getId(), time);
}
throw new ServiceException(ResultCode.USER_NOT_LOGIN);
}
@Override
public void memberSignSendPoint(String memberId, Integer day) {
try {
//获取签到积分赠送设置
Setting setting = settingService.get(SettingEnum.POINT_SETTING.name());
if (setting != null) {
PointSetting pointSetting = new Gson().fromJson(setting.getSettingValue(), PointSetting.class);
String content = "";
//赠送积分
Long point = null;
List<PointSettingItem> pointSettingItems = pointSetting.getPointSettingItems();
if (!pointSettingItems.isEmpty()) {
for (PointSettingItem item : pointSettingItems) {
if (item.getDay().equals(day)) {
point = item.getPoint().longValue();
content = "会员连续签到" + day + "天，赠送积分" + point + "分";
}
}
}
//如果他不处于连续赠送阶段，则只赠送签到积分数
if (point == null && pointSetting.getSignIn() != null) {
point = Long.valueOf(pointSetting.getSignIn().toString());
content = "会员签到第" + day + "天，赠送积分" + point + "分";
}
//赠送会员积分
memberService.updateMemberPoint(point, PointTypeEnum.INCREASE.name(), memberId, content);
}
} catch (Exception e) {
log.error("会员签到错误", e);
}
}
}
|
//获取当前会员信息
AuthUser authUser = UserContext.getCurrentUser();
if (ObjectUtil.isNotNull(authUser)) {
//获取当前用户当日签到日信息
LambdaQueryWrapper<MemberSign> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(MemberSign::getMemberId, authUser.getId());
queryWrapper.eq(MemberSign::getDay,DateUtil.getDayOfStart().intValue());
List<MemberSign> signSize = this.baseMapper.getTodayMemberSign(queryWrapper);
//当日签到信息不为空
if (!signSize.isEmpty()) {
throw new ServiceException(ResultCode.MEMBER_SIGN_REPEAT);
}
//当前签到天数的前一天日期
List<MemberSign> signs = this.baseMapper.getBeforeMemberSign(authUser.getId());
//构建参数
MemberSign memberSign = new MemberSign();
memberSign.setMemberId(authUser.getId());
memberSign.setMemberName(authUser.getUsername());
//如果size大于0 说明昨天已经签到过，获取昨天的签到数，反之新签到
if (!signs.isEmpty()) {
//截止目前为止 签到总天数 不带今天
Integer signDay = signs.get(0).getSignDay();
memberSign.setSignDay(CurrencyUtil.add(signDay, 1).intValue());
} else {
memberSign.setSignDay(1);
}
memberSign.setDay(DateUtil.getDayOfStart().intValue());
try {
this.baseMapper.insert(memberSign);
//签到成功后发送消息赠送积分
String destination = rocketmqCustomProperties.getMemberTopic() + ":" + MemberTagsEnum.MEMBER_SING.name();
rocketMQTemplate.asyncSend(destination, memberSign, RocketmqSendCallbackBuilder.commonCallback());
return true;
} catch (Exception e) {
throw new ServiceException(ResultCode.MEMBER_SIGN_REPEAT);
}
}
throw new ServiceException(ResultCode.USER_NOT_LOGIN);
| 643
| 545
| 1,188
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/StoreClerkRoleServiceImpl.java
|
StoreClerkRoleServiceImpl
|
listId
|
class StoreClerkRoleServiceImpl extends ServiceImpl<StoreClerkRoleMapper, StoreClerkRole> implements StoreClerkRoleService {
@Override
public List<StoreClerkRole> listByUserId(String clerkId) {
QueryWrapper<StoreClerkRole> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("clerk_id", clerkId);
return this.baseMapper.selectList(queryWrapper);
}
@Override
public List<String> listId(String clerkId) {<FILL_FUNCTION_BODY>}
@Override
public void updateClerkRole(String clerkId, List<StoreClerkRole> storeClerkRoles) {
//删除
QueryWrapper<StoreClerkRole> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("clerk_id", clerkId);
this.remove(queryWrapper);
//保存
this.saveBatch(storeClerkRoles);
}
}
|
List<StoreClerkRole> userRoleList = this.listByUserId(clerkId);
List<String> strings = new ArrayList<>();
userRoleList.forEach(item -> strings.add(item.getRoleId()));
return strings;
| 240
| 65
| 305
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/StoreCollectionServiceImpl.java
|
StoreCollectionServiceImpl
|
deleteStoreCollection
|
class StoreCollectionServiceImpl extends ServiceImpl<StoreCollectionMapper, StoreCollection> implements StoreCollectionService {
@Autowired
private StoreService storeService;
@Override
public IPage<StoreCollectionVO> storeCollection(PageVO pageVo) {
QueryWrapper<StoreCollectionVO> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("sc.member_id", UserContext.getCurrentUser().getId());
queryWrapper.orderByDesc("sc.create_time");
return this.baseMapper.storeCollectionVOList(PageUtil.initPage(pageVo), queryWrapper);
}
@Override
public boolean isCollection(String storeId) {
QueryWrapper<StoreCollection> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("member_id", UserContext.getCurrentUser().getId());
queryWrapper.eq("store_id", storeId);
return Optional.ofNullable(this.getOne(queryWrapper, false)).isPresent();
}
@Override
@Transactional(rollbackFor = Exception.class)
public StoreCollection addStoreCollection(String storeId) {
if (this.getOne(new LambdaUpdateWrapper<StoreCollection>()
.eq(StoreCollection::getMemberId, UserContext.getCurrentUser().getId())
.eq(StoreCollection::getStoreId, storeId)) == null) {
StoreCollection storeCollection = new StoreCollection(UserContext.getCurrentUser().getId(), storeId);
this.save(storeCollection);
storeService.updateStoreCollectionNum(new CollectionDTO(storeId, 1));
return storeCollection;
}
throw new ServiceException(ResultCode.USER_COLLECTION_EXIST);
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean deleteStoreCollection(String storeId) {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<StoreCollection> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("member_id", UserContext.getCurrentUser().getId());
queryWrapper.eq("store_id", storeId);
storeService.updateStoreCollectionNum(new CollectionDTO(storeId, -1));
return this.remove(queryWrapper);
| 459
| 84
| 543
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/StoreDepartmentRoleServiceImpl.java
|
StoreDepartmentRoleServiceImpl
|
updateByDepartmentId
|
class StoreDepartmentRoleServiceImpl extends ServiceImpl<StoreDepartmentRoleMapper, StoreDepartmentRole> implements StoreDepartmentRoleService {
@Autowired
private Cache cache;
@Override
public List<StoreDepartmentRole> listByDepartmentId(String storeDepartmentId) {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper.eq("department_id", storeDepartmentId);
return this.baseMapper.selectList(queryWrapper);
}
@Override
public void updateByDepartmentId(String storeDepartmentId, List<StoreDepartmentRole> storeDepartmentRoles) {<FILL_FUNCTION_BODY>}
@Override
public void deleteByDepartment(List<String> ids) {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper.in("department_id", ids);
this.remove(queryWrapper);
cache.vagueDel(CachePrefix.PERMISSION_LIST.getPrefix(UserEnums.STORE));
cache.vagueDel(CachePrefix.STORE_USER_MENU.getPrefix());
}
}
|
if (!storeDepartmentRoles.isEmpty()) {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper.eq("department_id", storeDepartmentId);
this.remove(queryWrapper);
this.saveBatch(storeDepartmentRoles);
cache.vagueDel(CachePrefix.PERMISSION_LIST.getPrefix(UserEnums.STORE));
cache.vagueDel(CachePrefix.STORE_USER_MENU.getPrefix());
}
| 282
| 123
| 405
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/StoreDepartmentServiceImpl.java
|
StoreDepartmentServiceImpl
|
initChild
|
class StoreDepartmentServiceImpl extends ServiceImpl<StoreDepartmentMapper, StoreDepartment> implements StoreDepartmentService {
@Autowired
private StoreDepartmentRoleService storeDepartmentRoleService;
@Autowired
private ClerkService clerkService;
@Override
public void deleteByIds(List<String> ids) {
//校验是否有操作店铺部门权限
List<StoreDepartment> storeDepartments = this.list(new QueryWrapper<StoreDepartment>()
.in("id", ids)
.eq("store_id", UserContext.getCurrentUser().getStoreId()));
if (storeDepartments.size() != ids.size()) {
throw new ServiceException(ResultCode.USER_AUTHORITY_ERROR);
}
//校验店员是否绑定部门
if (clerkService.count(new QueryWrapper<Clerk>().in("department_id", ids)) > 0) {
throw new ServiceException(ResultCode.PERMISSION_DEPARTMENT_DELETE_ERROR);
}
//删除店铺部门
this.removeByIds(ids);
//删除店铺部门角色
storeDepartmentRoleService.deleteByDepartment(ids);
}
@Override
public List<StoreDepartmentVO> tree(QueryWrapper<StoreDepartment> initWrapper) {
try {
List<StoreDepartment> departments = this.list(initWrapper);
List<StoreDepartmentVO> all = new ArrayList<>();
departments.forEach(item -> all.add(new StoreDepartmentVO(item)));
List<StoreDepartmentVO> tree = new ArrayList<>();
all.forEach(item -> {
if ("0".equals(item.getParentId())) {
initChild(item, all);
tree.add(item);
}
});
return tree;
} catch (Exception e) {
log.error("部门业务错误", e);
return null;
}
}
/**
* 递归初始化子树
*
* @param tree 树结构
* @param departmentVOS 数据库对象集合
*/
private void initChild(StoreDepartmentVO tree, List<StoreDepartmentVO> departmentVOS) {<FILL_FUNCTION_BODY>}
@Override
public Boolean update(StoreDepartment storeDepartment) {
StoreDepartment temp = this.getById(storeDepartment);
//校验部门是否存在
if (temp == null) {
throw new ServiceException(ResultCode.PERMISSION_NOT_FOUND_ERROR);
}
//校验店铺权限
if (!temp.getStoreId().equals(UserContext.getCurrentUser().getStoreId())) {
throw new ServiceException(ResultCode.USER_AUTHORITY_ERROR);
}
return this.updateById(storeDepartment);
}
}
|
departmentVOS.stream()
.filter(item -> (item.getParentId().equals(tree.getId())))
.forEach(child -> {
StoreDepartmentVO childTree = new StoreDepartmentVO(child);
initChild(childTree, departmentVOS);
tree.getChildren().add(childTree);
});
| 729
| 86
| 815
|
<no_super_class>
|
lilishop_lilishop
|
lilishop/framework/src/main/java/cn/lili/modules/member/serviceimpl/StoreLogisticsServiceImpl.java
|
StoreLogisticsServiceImpl
|
add
|
class StoreLogisticsServiceImpl extends ServiceImpl<StoreLogisticsMapper, StoreLogistics> implements StoreLogisticsService {
@Override
public List<StoreLogisticsVO> getStoreLogistics(String storeId) {
return this.baseMapper.getStoreLogistics(storeId);
}
@Override
public List<StoreLogisticsVO> getStoreSelectedLogistics(String storeId) {
return this.baseMapper.getSelectedStoreLogistics(storeId);
}
@Override
public List<String> getStoreSelectedLogisticsName(String storeId) {
return this.baseMapper.getSelectedStoreLogisticsName(storeId);
}
@Override
public List<StoreLogisticsVO> getStoreSelectedLogisticsUseFaceSheet(String storeId) {
return this.baseMapper.getSelectedStoreLogisticsUseFaceSheet(storeId);
}
@Override
public StoreLogistics update(String logisticsId, String storeId, StoreLogisticsCustomerDTO storeLogisticsCustomerDTO) {
LambdaQueryWrapper<StoreLogistics> lambdaQueryWrapper = Wrappers.lambdaQuery();
lambdaQueryWrapper.eq(StoreLogistics::getLogisticsId, logisticsId);
lambdaQueryWrapper.eq(StoreLogistics::getStoreId, storeId);
this.remove(lambdaQueryWrapper);
StoreLogistics ResultstoreLogistics = new StoreLogistics(storeLogisticsCustomerDTO);
ResultstoreLogistics.setStoreId(storeId);
ResultstoreLogistics.setLogisticsId(logisticsId);
this.save(ResultstoreLogistics);
return ResultstoreLogistics;
}
@Override
public StoreLogistics getStoreLogisticsInfo(String logisticsId) {
String storeId = Objects.requireNonNull(UserContext.getCurrentUser()).getStoreId();
return this.getOne(new LambdaQueryWrapper<StoreLogistics>().eq(StoreLogistics::getStoreId, storeId).eq(StoreLogistics::getLogisticsId, logisticsId));
}
@Override
public List<StoreLogisticsVO> getOpenStoreLogistics(String storeId) {
List<StoreLogisticsVO> openStoreLogistics = this.baseMapper.getOpenStoreLogistics(storeId);
for (StoreLogisticsVO storeLogisticsVO : openStoreLogistics) {
storeLogisticsVO.setSelected("1");
}
return openStoreLogistics;
}
@Override
public List<StoreLogisticsVO> getCloseStoreLogistics(String storeId) {
return this.baseMapper.getCloseStroreLogistics(storeId);
}
@Override
public StoreLogistics add(String logisticsId, String storeId, StoreLogisticsCustomerDTO storeLogisticsCustomerDTO) {<FILL_FUNCTION_BODY>}
}
|
//判断是否已经选择过，如果没有选择则进行添加
LambdaQueryWrapper<StoreLogistics> lambdaQueryWrapper = Wrappers.lambdaQuery();
lambdaQueryWrapper.eq(StoreLogistics::getLogisticsId, logisticsId);
lambdaQueryWrapper.eq(StoreLogistics::getStoreId, storeId);
StoreLogistics storeLogistics = null;
if (this.getOne(lambdaQueryWrapper) == null) {
storeLogistics = new StoreLogistics(storeLogisticsCustomerDTO);
storeLogistics.setStoreId(storeId);
storeLogistics.setLogisticsId(logisticsId);
this.save(storeLogistics);
return storeLogistics;
}
return null;
| 697
| 182
| 879
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.