repo stringclasses 1k values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 6 values | commit_sha stringclasses 1k values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/tingyu/excepiton/LockException.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/tingyu/excepiton/LockException.java | package redisson.config.tingyu.excepiton;
/**
* 分布式锁异常
*/
public class LockException extends RuntimeException {
public LockException() {
}
public LockException(String message) {
super(message);
}
public LockException(String message, Throwable cause) {
super(message, cause);
}
public LockException(Throwable cause) {
super(cause);
}
public LockException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/tingyu/enums/Model.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/tingyu/enums/Model.java | package redisson.config.tingyu.enums;
public enum Model {
//哨兵
SENTINEL,
//主从
MASTERSLAVE,
//单例
SINGLE,
//集群
CLUSTER,
//云托管模式
REPLICATED
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/tingyu/enums/LockModel.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/tingyu/enums/LockModel.java | package redisson.config.tingyu.enums;
/**
* 锁的模式
*/
public enum LockModel {
//可重入锁
REENTRANT,
//公平锁
FAIR,
//联锁
MULTIPLE,
//红锁
REDLOCK,
//读锁
READ,
//写锁
WRITE,
//自动模式,当参数只有一个.使用 REENTRANT 参数多个 REDLOCK
AUTO
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/tingyu/enums/MQModel.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/tingyu/enums/MQModel.java | package redisson.config.tingyu.enums;
public enum MQModel {
//精准的匹配
PRECISE,
//模糊的匹配
PATTERN
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/SecurityConfiguration.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/SecurityConfiguration.java | package redisson.config.security;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests().antMatchers(HttpMethod.OPTIONS).permitAll().anyRequest().authenticated().and()
.httpBasic().and().csrf().disable();
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/MyAuthenticationFailureHandler.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/MyAuthenticationFailureHandler.java | package redisson.config.security;
import com.alibaba.fastjson.JSONObject;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;
import redisson.bean.vo.ResultVO;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@Component
public class MyAuthenticationFailureHandler implements AuthenticationFailureHandler {
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
AuthenticationException exception) throws IOException, ServletException {
String code = exception.getMessage().substring(0, exception.getMessage().indexOf("-"));
String msg = exception.getMessage().substring(exception.getMessage().indexOf("-") + 1);
// token非本人
ResultVO<?> resultVO = new ResultVO<>(Integer.valueOf(code), msg);
response.setContentType("application/json;charset=UTF-8");
response.getWriter().write(JSONObject.toJSONString(resultVO).toCharArray());
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/ResourceServerConfiguration.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/ResourceServerConfiguration.java | package redisson.config.security;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.ResourceServerTokenServices;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
import org.springframework.security.web.AuthenticationEntryPoint;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
@Configuration
@EnableResourceServer
public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter {
@Autowired
private MyAccessDeniedHandler myAccessDeniedHandler;
@Autowired
private Auth2ResponseExceptionTranslator auth2ResponseExceptionTranslator;
@Autowired
private SecurityAuthenticationEntryPoint securityAuthenticationEntryPoint;
@Override
public void configure(ResourceServerSecurityConfigurer resources) {
resources.resourceId("client1");
resources.tokenServices(defaultTokenServices());
// 定义异常转换类生效
AuthenticationEntryPoint authenticationEntryPoint = new OAuth2AuthenticationEntryPoint();
((OAuth2AuthenticationEntryPoint) authenticationEntryPoint)
.setExceptionTranslator(this.auth2ResponseExceptionTranslator);
resources.authenticationEntryPoint(authenticationEntryPoint);
}
@Override
public void configure(HttpSecurity http) throws Exception {
// 放行路径在这写
http.csrf().disable().exceptionHandling().authenticationEntryPoint(this.securityAuthenticationEntryPoint)
.accessDeniedHandler(myAccessDeniedHandler).and().authorizeRequests()
.antMatchers("/swagger-resources/**", "/v2/**", "/swagger/**", "/swagger**", "/webjars/**",
"/backstage/**")
.permitAll().anyRequest().authenticated().and().httpBasic().disable();
// ifream的跨域设置
http.headers().frameOptions().sameOrigin();
}
// ===================================================以下代码与认证服务器一致=========================================
/**
* token存储,这里使用jwt方式存储
*
* @param accessTokenConverter
* @return
*/
@Bean
public TokenStore tokenStore() {
TokenStore tokenStore = new JwtTokenStore(accessTokenConverter());
return tokenStore;
}
/**
* 创建一个默认的资源服务token
*
* @return
*/
@Bean
public ResourceServerTokenServices defaultTokenServices() {
final DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
defaultTokenServices.setTokenEnhancer(accessTokenConverter());
defaultTokenServices.setTokenStore(tokenStore());
return defaultTokenServices;
}
/**
* Token转换器必须与认证服务一致
*
* @return
*/
@Bean
public JwtAccessTokenConverter accessTokenConverter() {
JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter() {
};
Resource resource = new ClassPathResource("public_key.txt");
String publicKey = null;
try {
publicKey = inputStream2String(resource.getInputStream());
} catch (final IOException e) {
throw new RuntimeException(e);
}
accessTokenConverter.setVerifierKey(publicKey);
return accessTokenConverter;
}
// ===================================================以上代码与认证服务器一致=========================================
private String inputStream2String(InputStream is) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(is));
StringBuffer buffer = new StringBuffer();
String line = "";
while ((line = in.readLine()) != null) {
buffer.append(line);
}
return buffer.toString();
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/SecurityAuthenticationEntryPoint.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/SecurityAuthenticationEntryPoint.java | package redisson.config.security;
import com.alibaba.fastjson.JSONObject;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
import redisson.bean.vo.ResultVO;
import redisson.contants.Codes;
import redisson.contants.Messages;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@Component
public class SecurityAuthenticationEntryPoint implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response,
AuthenticationException authException) throws IOException, ServletException {
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
response.getWriter().append(JSONObject.toJSONString(new ResultVO<>(Codes.CODE_601, Messages.USER_TOKEN_ERROR)));
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/MyAccessDeniedHandler.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/MyAccessDeniedHandler.java | package redisson.config.security;
import com.alibaba.fastjson.JSONObject;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;
import redisson.bean.vo.ResultVO;
import redisson.contants.Codes;
import redisson.contants.Messages;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest request, HttpServletResponse response,
AccessDeniedException accessDeniedException) throws IOException, ServletException {
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
response.getWriter().append(JSONObject.toJSONString(new ResultVO<>(Codes.CODE_602, Messages.AUTH_FAIL)));
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/Auth2ResponseExceptionTranslator.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/config/security/Auth2ResponseExceptionTranslator.java | package redisson.config.security;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.oauth2.common.exceptions.InvalidTokenException;
import org.springframework.security.oauth2.provider.error.WebResponseExceptionTranslator;
import org.springframework.stereotype.Component;
import redisson.contants.Codes;
import redisson.contants.Datas;
import redisson.contants.Messages;
import redisson.exception.BusinessException;
@Component
public class Auth2ResponseExceptionTranslator implements WebResponseExceptionTranslator<BusinessException> {
@Override
public ResponseEntity<BusinessException> translate(Exception e) throws Exception {
Throwable throwable = e.getCause();
if (throwable.getMessage().indexOf(Datas.ACCESS_TOKEN_EXPIRED) != -1) {
return new ResponseEntity<BusinessException>(
new BusinessException(Codes.CODE_602, Messages.USER_TOKEN_EXPIRED), HttpStatus.OK);
}
if (throwable instanceof InvalidTokenException) {
return new ResponseEntity<BusinessException>(
new BusinessException(Codes.CODE_601, Messages.USER_TOKEN_ERROR), HttpStatus.OK);
}
return new ResponseEntity<BusinessException>(new BusinessException(Codes.CODE_405, Messages.METHED_NOT_ALLOW),
HttpStatus.METHOD_NOT_ALLOWED);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/validator/SuperValidator.java | 分布式锁redisson多节点+附加源码和压测脚本/redisson.tingyu/src/main/java/redisson/validator/SuperValidator.java | package redisson.validator;
import org.springframework.util.StringUtils;
import redisson.contants.Codes;
import redisson.contants.Messages;
import redisson.exception.BusinessException;
import java.lang.reflect.Field;
import java.math.BigDecimal;
public class SuperValidator {
/**
* 验证对象每个属性都不为空值
*
* @param t
*/
public static <T> void validateParams(T t) {
try {
for (Field f : t.getClass().getDeclaredFields()) {
f.setAccessible(true);
if (f.get(t) == null || f.get(t).equals("")) {
throw new BusinessException(Codes.CODE_500, Messages.PARAMS_NULL);
}
}
} catch (BusinessException e) {
throw new BusinessException(Codes.CODE_500, e.getMessage());
} catch (Exception e) {
throw new BusinessException(Codes.CODE_500, Messages.SYSTEM_EXCEPTION);
}
}
/**
* 验证参数空值
*
* @param map
*/
public static void validateParams(Object... obj) {
for (Object o : obj) {
if (o == null) {
throw new BusinessException(Codes.CODE_500, Messages.PARAMS_NULL);
}
}
}
/**
* 验证参数空值
*
* @param map
*/
public static void validateParams(String... strs) {
for (String s : strs) {
if (StringUtils.isEmpty(s)) {
throw new BusinessException(Codes.CODE_500, Messages.PARAMS_NULL);
}
}
}
/**
* 验证数字有效性（不能小于等于0）
*
* @param map
*/
public static <T> void validateNumber(Object... obj) {
for (Object o : obj) {
if (o instanceof BigDecimal) {
if (new BigDecimal(o.toString()).compareTo(BigDecimal.ZERO) != 1) {
throw new BusinessException(Codes.CODE_500, Messages.NUMBER_INVALID);
}
} else if (o instanceof Integer) {
if (Integer.parseInt(o.toString()) <= 0) {
throw new BusinessException(Codes.CODE_500, Messages.NUMBER_INVALID);
}
} else if (o instanceof Double) {
if (Double.parseDouble(o.toString()) <= 0) {
throw new BusinessException(Codes.CODE_500, Messages.NUMBER_INVALID);
}
} else {
throw new BusinessException(Codes.CODE_500, Messages.NUMBER_INVALID);
}
}
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/eureka/src/main/java/org/distributed/eureka/EurekaApplication.java | 分布式锁redisson多节点+附加源码和压测脚本/eureka/src/main/java/org/distributed/eureka/EurekaApplication.java | package org.distributed.eureka;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/**
* 服务注册与发现
*
* @author tingyu
* @since 2020-08-05
*/
@EnableEurekaServer
@SpringBootApplication
public class EurekaApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaApplication.class, args);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/test/java/org/bifu/distributed/gateway/AppTest.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/test/java/org/bifu/distributed/gateway/AppTest.java | package org.bifu.distributed.gateway;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Unit test for simple App.
*/
public class AppTest
extends TestCase
{
/**
* Create the test case
*
* @param testName name of the test case
*/
public AppTest( String testName )
{
super( testName );
}
/**
* @return the suite of tests being tested
*/
public static Test suite()
{
return new TestSuite( AppTest.class );
}
/**
* Rigourous Test :-)
*/
public void testApp()
{
assertTrue( true );
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/GateWayApplication.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/GateWayApplication.java | package org.distributed.gateway;
import java.time.Duration;
import org.distributed.gateway.filter.limit.RateLimitByIpFilter;
import org.distributed.gateway.filter.url.SafeUrlFilter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
/**
* API网关
*
* @author ybc
* @since 2018-9-6
*/
@SpringBootApplication
public class GateWayApplication {
@Value(value = "${ip.internal}")
private String internalIps;
@Value(value = "${safe.url.assetsweb}")
private String assetswebSafeUrls;
public static void main(String[] args) {
SpringApplication.run(GateWayApplication.class, args);
}
@Bean
public RouteLocator routeLocator(RouteLocatorBuilder builder) {
return builder.routes()
// 认证中心
.route(r -> r.path("/BIFU-AUTH/**")
.filters(f -> f.stripPrefix(1).filter(new RateLimitByIpFilter(1000, 50, Duration.ofSeconds(1))))
.uri("lb://BIFU-AUTH").id("BIFU-AUTH"))
// 用户中心
.route(r -> r.path("/BIFU-USERCENTER/**")
.filters(f -> f.stripPrefix(1).filter(new RateLimitByIpFilter(1000, 50, Duration.ofSeconds(1))))
.uri("lb://BIFU-USERCENTER").id("BIFU-USERCENTER"))
// 市场
.route(r -> r.path("/MARKET/api/small/**")
.filters(f -> f.stripPrefix(1).filter(new RateLimitByIpFilter(1000, 20, Duration.ofSeconds(1))))
.uri("lb://MARKET").id("MARKET"))
.route(r -> r.path("/MARKET/**")
.filters(f -> f.stripPrefix(1).filter(new RateLimitByIpFilter(1000, 50, Duration.ofSeconds(1))))
.uri("lb://MARKET").id("MARKET"))
// 资产
.route(r -> r.path("/ASSETSWEB/**")
.filters(f -> f.stripPrefix(1)
.filter(new SafeUrlFilter(this.assetswebSafeUrls, this.internalIps))
.filter(new RateLimitByIpFilter(1000, 50, Duration.ofSeconds(1))))
.uri("lb://ASSETSWEB").id("ASSETSWEB"))
.build();
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/util/IpUtil.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/util/IpUtil.java | package org.distributed.gateway.util;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.util.StringUtils;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class IpUtil {
private IpUtil() {
}
private static class IpUtilHolder {
private final static IpUtil instance = new IpUtil();
}
public static IpUtil getInstance() {
return IpUtilHolder.instance;
}
// 获取用户真实IP
public String getIpAddr(ServerHttpRequest request) {
String ip = "";
String ips = request.getHeaders().getFirst("x-forwarded-for");
log.info("IpUtil get header ips : {}",ips);
if (StringUtils.isEmpty(ips)) {
ip = request.getRemoteAddress().getAddress().getHostAddress();
log.info("IpUtil get request ip : {}",ip);
return ip;
} else {
return ips.indexOf(",") != -1 ? ips.substring(0, ips.indexOf(",")) : ips;
}
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/util/ProtoStuffSerializerUtil.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/util/ProtoStuffSerializerUtil.java | package org.distributed.gateway.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.List;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
/**
* classnmae 序列话工具
*
* @author zhuoligang
*/
public class ProtoStuffSerializerUtil {
/**
* 序列化对象
*
* @param obj
* @return
*/
public static <T> byte[] serialize(T obj) {
if (obj == null) {
throw new RuntimeException("序列化对象(" + obj + ")!");
}
@SuppressWarnings("unchecked")
Schema<T> schema = (Schema<T>) RuntimeSchema.getSchema(obj.getClass());
LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);
byte[] protostuff = null;
try {
protostuff = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
} catch (Exception e) {
throw new RuntimeException("序列化(" + obj.getClass() + ")对象(" + obj + ")发生异常!", e);
} finally {
buffer.clear();
}
return protostuff;
}
/**
* 反序列化对象
*
* @param paramArrayOfByte
* @param targetClass
* @return
*/
public static <T> T deserialize(byte[] paramArrayOfByte, Class<T> targetClass) {
if (paramArrayOfByte == null || paramArrayOfByte.length == 0) {
throw new RuntimeException("反序列化对象发生异常,byte序列为空!");
}
T instance = null;
try {
instance = targetClass.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
throw new RuntimeException("反序列化过程中依据类型创建对象失败!", e);
}
Schema<T> schema = RuntimeSchema.getSchema(targetClass);
ProtostuffIOUtil.mergeFrom(paramArrayOfByte, instance, schema);
return instance;
}
/**
* 序列化列表
*
* @param objList
* @return
*/
public static <T> byte[] serializeList(List<T> objList) {
if (objList == null || objList.isEmpty()) {
throw new RuntimeException("序列化对象列表(" + objList + ")参数异常!");
}
@SuppressWarnings("unchecked")
Schema<T> schema = (Schema<T>) RuntimeSchema.getSchema(objList.get(0).getClass());
LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);
byte[] protostuff = null;
ByteArrayOutputStream bos = null;
try {
bos = new ByteArrayOutputStream();
ProtostuffIOUtil.writeListTo(bos, objList, schema, buffer);
protostuff = bos.toByteArray();
} catch (Exception e) {
throw new RuntimeException("序列化对象列表(" + objList + ")发生异常!", e);
} finally {
buffer.clear();
try {
if (bos != null) {
bos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return protostuff;
}
/**
* 反序列化列表
*
* @param paramArrayOfByte
* @param targetClass
* @return
*/
public static <T> List<T> deserializeList(byte[] paramArrayOfByte, Class<T> targetClass) {
if (paramArrayOfByte == null || paramArrayOfByte.length == 0) {
throw new RuntimeException("反序列化对象发生异常,byte序列为空!");
}
Schema<T> schema = RuntimeSchema.getSchema(targetClass);
List<T> result = null;
try {
result = ProtostuffIOUtil.parseListFrom(new ByteArrayInputStream(paramArrayOfByte), schema);
} catch (IOException e) {
throw new RuntimeException("反序列化对象列表发生异常!", e);
}
return result;
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/util/RedisUtil.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/util/RedisUtil.java | package org.distributed.gateway.util;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
/**
* redis工具类
*
* @author lsj
*
*/
@Component
public class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
public <T> boolean putCache(String key, T obj) {
final byte[] bkey = key.getBytes();
final byte[] bvalue = ProtoStuffSerializerUtil.serialize(obj);
boolean result = this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
return connection.setNX(bkey, bvalue);
}
});
return result;
}
public <T> void putCacheWithExpireTime(String key, T obj, final long expireTime) {
final byte[] bkey = key.getBytes();
final byte[] bvalue = ProtoStuffSerializerUtil.serialize(obj);
this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
connection.setEx(bkey, expireTime, bvalue);
return true;
}
});
}
public void putMemberCache(String key, String value, final long offset) {
this.redisTemplate.opsForValue().set(key, value, offset);
}
public <T> boolean putListCache(String key, List<T> objList) {
final byte[] bkey = key.getBytes();
final byte[] bvalue = ProtoStuffSerializerUtil.serializeList(objList);
boolean result = this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
return connection.setNX(bkey, bvalue);
}
});
return result;
}
// 存入消息
public <T> boolean putHashCache(String key, HashMap<String, T> object) {
final byte[] bkey = key.getBytes();
final HashMap<byte[], byte[]> ham = new HashMap<>();
for (Entry<String, T> entry : object.entrySet()) {
ham.put(ProtoStuffSerializerUtil.serialize(entry.getKey()),
ProtoStuffSerializerUtil.serialize(entry.getValue()));
}
boolean result = this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
connection.hMSet(bkey, ham);
return true;
}
});
return result;
}
// 获取消息
public <T> HashMap<String, T> getHashCache(final String key, Class<T> targetClass) {
final byte[] bkey = key.getBytes();
HashMap<String, T> ham = new HashMap<>();
Map<byte[], byte[]> result = this.redisTemplate.execute(new RedisCallback<Map<byte[], byte[]>>() {
@Override
public Map<byte[], byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
return connection.hGetAll(bkey);
}
});
if (result == null) {
return null;
}
for (Entry<byte[], byte[]> entry : result.entrySet()) {
ham.put(ProtoStuffSerializerUtil.deserialize(entry.getKey(), String.class),
ProtoStuffSerializerUtil.deserialize(entry.getValue(), targetClass));
}
return ham;
}
// 删除消息
public Long deleteHashCache(final String key, final String field) {
final byte[] bkey = key.getBytes();
return this.redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
Map<byte[], byte[]> result = connection.hGetAll(bkey);
for (Entry<byte[], byte[]> entry : result.entrySet()) {
if (field.equals(ProtoStuffSerializerUtil.deserialize(entry.getKey(), String.class))) {
connection.hDel(bkey, entry.getKey());
}
}
return 0L;
}
});
}
public <T> boolean putListCacheWithExpireTime(String key, List<T> objList, final long expireTime) {
final byte[] bkey = key.getBytes();
final byte[] bvalue = ProtoStuffSerializerUtil.serializeList(objList);
boolean result = this.redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
connection.setEx(bkey, expireTime, bvalue);
return true;
}
});
return result;
}
public <T> T getCache(final String key, Class<T> targetClass) {
byte[] result = this.redisTemplate.execute(new RedisCallback<byte[]>() {
@Override
public byte[] doInRedis(RedisConnection connection) throws DataAccessException {
return connection.get(key.getBytes());
}
});
if (result == null) {
return null;
}
return ProtoStuffSerializerUtil.deserialize(result, targetClass);
}
public String getCache(final String key) {
//如果返回null，说明key不存在；如果返回""，说明key存在，值为""----业务上需要判断
return redisTemplate.opsForValue().get(key)==null ? "":redisTemplate.opsForValue().get(key).toString();
}
public <T> List<T> getListCache(final String key, Class<T> targetClass) {
byte[] result = this.redisTemplate.execute(new RedisCallback<byte[]>() {
@Override
public byte[] doInRedis(RedisConnection connection) throws DataAccessException {
return connection.get(key.getBytes());
}
});
if (result == null) {
return null;
}
return ProtoStuffSerializerUtil.deserializeList(result, targetClass);
}
/**
* 精确删除key
*
* @param key
*/
public void deleteCache(String key) {
this.redisTemplate.delete(key);
}
/**
* 模糊删除key
*
* @param pattern
*/
public void deleteCacheWithPattern(String pattern) {
Set<String> keys = this.redisTemplate.keys(pattern);
this.redisTemplate.delete(keys);
}
/**
* 清空所有缓存
*/
public void clearCache() {
deleteCacheWithPattern("user:|*");
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/util/UserAgentUtil.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/util/UserAgentUtil.java | package org.distributed.gateway.util;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class UserAgentUtil {
// public static void main(String[] args) {
//
// String ua = request.getHeader("User-Agent").toLowerCase();
// String deviceType = this.check(ua) ? "mobile" : "pc";
// String deviceName = this.getDeviceName(ua);
// }
// \b 是单词边界(连着的两个(字母字符 与 非字母字符) 之间的逻辑上的间隔),
// 字符串在编译时会被转码一次,所以是 "\\b"
// \B 是单词内部逻辑间隔(连着的两个字母字符之间的逻辑上的间隔)
static String phoneReg = "\\b(ip(hone|od)|android|opera m(ob|in)i" + "|windows (phone|ce)|blackberry" + "|s(ymbian|eries60|amsung)|p(laybook|alm|rofile/midp"
+ "|laystation portable)|nokia|fennec|htc[-_]" + "|mobile|up.browser|[1-4][0-9]{2}x[1-4][0-9]{2})\\b";
static String tableReg = "\\b(ipad|tablet|(Nexus 7)|up.browser" + "|[1-4][0-9]{2}x[1-4][0-9]{2})\\b";
// 移动设备正则匹配：手机端、平板
static Pattern phonePat = Pattern.compile(phoneReg, Pattern.CASE_INSENSITIVE);
static Pattern tablePat = Pattern.compile(tableReg, Pattern.CASE_INSENSITIVE);
/**
* 检测是否是移动设备访问
*
* @Title: check
* @Date : 2014-7-7 下午01:29:07
* @param userAgent
* 浏览器标识
* @return true:移动设备接入，false:pc端接入
*/
public static boolean check(String userAgent) {
if (null == userAgent) {
userAgent = "";
}
// 匹配
Matcher matcherPhone = phonePat.matcher(userAgent);
Matcher matcherTable = tablePat.matcher(userAgent);
if (matcherPhone.find() || matcherTable.find()) {
return true;
} else {
return false;
}
}
/**
* 获取设备名称
* @param userAgent
* @return
*/
public static String getDeviceName(String userAgent) {
if (null == userAgent) {
userAgent = "";
}
// 匹配
Matcher matcherPhone = phonePat.matcher(userAgent);
Matcher matcherTable = tablePat.matcher(userAgent);
if (matcherPhone.find()) {
return matcherPhone.group();
} else if (matcherTable.find()) {
return matcherTable.group();
} else {
return "pc";
}
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/global/OrginGlobalFilter.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/global/OrginGlobalFilter.java | package org.distributed.gateway.filter.global;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.net.URI;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR;
/**
* @author ransong
* @version 1.0
* @date 2020/7/16 0016 9:11
*/
@Component
public class OrginGlobalFilter implements GlobalFilter, Ordered {
private final static Logger logger = LoggerFactory.getLogger(OrginGlobalFilter.class);
private static final String ALL = "x-requested-with, authorization, Content-Type, Authorization, credential, X-XSRF-TOKEN, token, username, client, devicetype, userId";
private static final String MAX_AGE = "18000L";
@Override
public int getOrder() {
return -300;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
ServerHttpRequest request = exchange.getRequest();
ServerHttpResponse response = exchange.getResponse();
HttpHeaders headers = response.getHeaders();
logger.info("处理跨域开始");
headers.add(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
headers.add(HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, "POST, GET, PUT, OPTIONS, DELETE, PATCH");
headers.add(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");
headers.add(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, "*");
headers.add(HttpHeaders.ACCESS_CONTROL_EXPOSE_HEADERS, ALL);
headers.add(HttpHeaders.ACCESS_CONTROL_MAX_AGE, MAX_AGE);
if (request.getMethod() == HttpMethod.OPTIONS) {
logger.info("处理options");
response.setStatusCode(HttpStatus.NO_CONTENT);
return Mono.empty();
}
logger.info("处理跨域完成");
return chain.filter(exchange);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/global/SchemeGlobalFilter.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/global/SchemeGlobalFilter.java | package org.distributed.gateway.filter.global;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;
import java.net.URI;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR;
//@Component
public class SchemeGlobalFilter implements GlobalFilter, Ordered {
@Override
public int getOrder() {
return 10101;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
Object uriObj = exchange.getAttributes().get(GATEWAY_REQUEST_URL_ATTR);
if (uriObj != null) {
URI uri = (URI) uriObj;
uri = this.upgradeConnection(uri, "http");
exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, uri);
}
return chain.filter(exchange);
}
private URI upgradeConnection(URI uri, String scheme) {
UriComponentsBuilder uriComponentsBuilder = UriComponentsBuilder.fromUri(uri).scheme(scheme);
if (uri.getRawQuery() != null) {
// When building the URI, UriComponentsBuilder verify the allowed characters and does not
// support the '+' so we replace it for its equivalent '%20'.
// See issue https://jira.spring.io/browse/SPR-10172
uriComponentsBuilder.replaceQuery(uri.getRawQuery().replace("+", "%20"));
}
return uriComponentsBuilder.build(true).toUri();
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/global/TokenGlobalFilter.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/global/TokenGlobalFilter.java | package org.distributed.gateway.filter.global;
import java.util.Arrays;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.distributed.gateway.bean.vo.ResultVO;
import org.distributed.gateway.contants.Codes;
import org.distributed.gateway.contants.Datas;
import org.distributed.gateway.contants.Messages;
import org.distributed.gateway.util.IpUtil;
import org.distributed.gateway.util.RedisUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import com.alibaba.fastjson.JSONObject;
import reactor.core.publisher.Mono;
@Component
public class TokenGlobalFilter implements GlobalFilter, Ordered {
private final static Logger logger = LoggerFactory.getLogger(TokenGlobalFilter.class);
@Autowired
private RedisUtil redisUtil;
@Value("${route.hold.routenames}")
private String routenames;
@Override
public int getOrder() {
return 10101;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
ServerHttpResponse response = exchange.getResponse();
// 路由判断
boolean b = validateRoute(exchange);
if (b) {
return chain.filter(exchange);
}
// token验证
b = validateToken(exchange);
if (b) {
return chain.filter(exchange);
}
// 用户冻结验证
String result = validateFreeze(exchange);
if (result != null) {
return response.writeWith(Mono.just(getDataBuffer(response, result)));
}
// 用户token验证
result = validateUserToken(exchange);
if (result != null) {
return response.writeWith(Mono.just(getDataBuffer(response, result)));
}
// 全部通过
return chain.filter(exchange);
}
private boolean validateRoute(ServerWebExchange exchange) {
Route route = (Route) exchange.getAttributes().get(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
String routeName = route.getId().indexOf(Datas.EUREKA_SUB_PFIX) == -1 ? route.getId()
: route.getId().substring(Datas.EUREKA_SUB_PFIX.length());
logger.info("来访的路由地址和连接T：" + routeName + "/" + exchange.getRequest().getURI());
// 路由模块
List<String> routes = Arrays.asList(this.routenames.split(","));
if (routes.contains(routeName)) {
return false;
}
return true;
}
private boolean validateToken(ServerWebExchange exchange) {
List<String> tokens = exchange.getRequest().getHeaders().get(Datas.AUTHORIZATION);
List<String> userIds = exchange.getRequest().getHeaders().get(Datas.USERID);
// 前端约定，header没有携带token和userId的请求，则在token是否本人生成过滤器中放行，由后续过滤器验证是否真正为放行资源和token的正确性
if ((tokens == null || tokens.size() <= 0) && (userIds == null || userIds.size() <= 0)) {
return true;
}
return false;
}
private String validateFreeze(ServerWebExchange exchange) {
String userId = exchange.getRequest().getHeaders().get(Datas.USERID).get(0);
// 验证用户是否在redis中存在禁用信息
String freeze = this.redisUtil.getCache(Datas.FREEZE_MAIN + userId);
if (StringUtils.isNotEmpty(freeze)) {
logger.info("请求用户被冻结，用户userId为：" + userId);
return JSONObject.toJSONString(new ResultVO<>(Codes.CODE_501, Messages.USER_FREEZE));
}
return null;
}
private String validateUserToken(ServerWebExchange exchange) {
String userId = exchange.getRequest().getHeaders().get(Datas.USERID).get(0);
String deviceType = exchange.getRequest().getHeaders().get(Datas.DEVICETYPE).get(0);
// 获取redisToken
String redisToken = this.redisUtil.getCache(Datas.TOKEN_SAFE + deviceType + Datas.CABLE + userId);
if (StringUtils.isEmpty(redisToken)) {
return JSONObject.toJSONString(new ResultVO<>(Codes.CODE_502, Messages.PLEASE_LOGIN));
}
// 截取redisToken
String tokenString = redisToken.substring(0, redisToken.lastIndexOf(Datas.CABLE));
// 获取用户token
String token = exchange.getRequest().getHeaders().get(Datas.AUTHORIZATION).get(0);
logger.info("前端传送的token'：" + token);
logger.info("截取到的token：" + tokenString);
if (!token.equals(tokenString)) {
// 截取此次登录ip
String ipString = redisToken.substring(redisToken.lastIndexOf(Datas.CABLE) + 1, redisToken.length());
String ip = IpUtil.getInstance().getIpAddr(exchange.getRequest());
if (ip.equals(ipString)) {
return JSONObject.toJSONString(new ResultVO<>(Codes.CODE_503, Messages.LOING_INVALID));
} else {
return JSONObject.toJSONString(new ResultVO<>(Codes.CODE_504, Messages.INVALID_ACCOUNT_LOGIN));
}
}
return null;
}
private DataBuffer getDataBuffer(ServerHttpResponse response, String result) {
return response.bufferFactory().wrap(result.getBytes());
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/limit/RateLimitByIpFilter.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/limit/RateLimitByIpFilter.java | package org.distributed.gateway.filter.limit;
import java.time.Duration;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import io.github.bucket4j.Bandwidth;
import io.github.bucket4j.Bucket;
import io.github.bucket4j.Bucket4j;
import io.github.bucket4j.Refill;
import reactor.core.publisher.Mono;
@Component
public class RateLimitByIpFilter implements GatewayFilter, Ordered {
private final static Logger logger = LoggerFactory.getLogger(RateLimitByIpFilter.class);
private int capacity;
private int refillTokens;
private Duration refillDuration;
private static final Map<String, Bucket> CACHE = new ConcurrentHashMap<>();
public RateLimitByIpFilter() {
}
public RateLimitByIpFilter(int capacity, int refillTokens, Duration refillDuration) {
this.capacity = capacity;
this.refillTokens = refillTokens;
this.refillDuration = refillDuration;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String ip = getIpAddr(exchange.getRequest());
if (ip.indexOf("192.168") != -1 || ip.indexOf("172.31.202") != -1) {
return chain.filter(exchange);
}
Bucket bucket = CACHE.computeIfAbsent(ip, k -> createNewBucket());
// logger.info("限频来访ip: " + ip + ", 可用令牌数量：" + bucket.getAvailableTokens());
if (bucket.tryConsume(1)) {
return chain.filter(exchange);
} else {
// 不合法(超过限流)
ServerHttpResponse response = exchange.getResponse();
// 设置headers
HttpHeaders httpHeaders = response.getHeaders();
httpHeaders.add("Content-Type", "application/json; charset=UTF-8");
httpHeaders.add("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
// 设置body
String warningStr = "{\"code\":\"500\",\"message\":\"超过限流\"}";
DataBuffer bodyDataBuffer = response.bufferFactory().wrap(warningStr.getBytes());
return response.writeWith(Mono.just(bodyDataBuffer));
}
}
@Override
public int getOrder() {
return -1000;
}
private Bucket createNewBucket() {
Refill refill = Refill.of(refillTokens, refillDuration);
Bandwidth limit = Bandwidth.classic(capacity, refill);
return Bucket4j.builder().addLimit(limit).build();
}
public static String getIpAddr(ServerHttpRequest request) {
String ip = "";
String str = request.getHeaders().getFirst("x-forwarded-for");
if (StringUtils.isEmpty(str)) {
ip = request.getRemoteAddress().getAddress().getHostAddress();
// logger.info("通过address方式限流获取到的IP为：" + ip);
return ip;
} else {
String[] ips = str.split(",");
for (String s : ips) {
if (s.indexOf("192.168") != -1 || s.indexOf("172.31.202") != -1) {
continue;
}
ip = ip + s + ",";
}
ip = ip.substring(0, ip.length() - 1);
// logger.info("通过x-forwarded-for限流获取到的IP，且过滤掉内网后的地址为：" + ip);
if (ip.indexOf(",") != -1) {
ip = ip.substring(0, ip.indexOf(","));
return ip.trim();
}
return ip.trim();
}
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/url/SafeUrlFilter.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/filter/url/SafeUrlFilter.java | package org.distributed.gateway.filter.url;
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
/**
* 资产受保护url过滤器
*
* @author lsj
*
*/
@Component
public class SafeUrlFilter implements GatewayFilter, Ordered {
private final static Logger logger = LoggerFactory.getLogger(SafeUrlFilter.class);
@Value(value = "${safe.url.assetsweb}")
private String safeUrls;
@Value(value = "${ip.internal}")
private String internalIps;
public SafeUrlFilter() {
}
public SafeUrlFilter(String safeUrls, String internalIps) {
this.safeUrls = safeUrls;
this.internalIps = internalIps;
}
@Override
public int getOrder() {
return 0;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
if (StringUtils.isEmpty(this.safeUrls)) {
return chain.filter(exchange);
}
ServerHttpRequest request = exchange.getRequest();
String url = request.getURI().getPath();
// 将url的字符串转换成数组
String[] urls = this.safeUrls.split(",");
// 内部通行ip地址转换成数组
String[] ips = this.internalIps.split(",");
// 获取来访ip地址x-forwarded-for
String ip1 = request.getHeaders().getFirst("x-forwarded-for");
// 获取nginx转发ip
String ip2 = request.getRemoteAddress().getAddress().getHostAddress();
logger.info("x-forwarded-for获取的ip:" + ip1 + ", hostAddress获取的ip:" + ip2 + "; 判断结果：" + Arrays.asList(ips).contains(ip2));
// 判断
if (Arrays.asList(urls).contains(url)) {
if (StringUtils.isEmpty(ip1) && Arrays.asList(ips).contains(ip2)) {
// 成功继续下一链条
return chain.filter(exchange);
}
// 不合法(响应ip不正确的异常)
ServerHttpResponse response = exchange.getResponse();
// 设置headers
HttpHeaders httpHeaders = response.getHeaders();
httpHeaders.add("Content-Type", "application/json; charset=UTF-8");
httpHeaders.add("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
// 设置body
String warningStr = "{\"code\":\"500\",\"message\":\"请求地址不被允许\"}";
DataBuffer bodyDataBuffer = response.bufferFactory().wrap(warningStr.getBytes());
return response.writeWith(Mono.just(bodyDataBuffer));
} else {
// 成功继续下一链条
return chain.filter(exchange);
}
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/contants/Codes.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/contants/Codes.java | package org.distributed.gateway.contants;
public class Codes {
public static final int CODE_501 = 501;
public static final int CODE_502 = 502;
public static final int CODE_503 = 503;
public static final int CODE_504 = 504;
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/contants/Messages.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/contants/Messages.java | package org.distributed.gateway.contants;
public class Messages {
public static final String USER_FREEZE = "用户已被冻结，如有疑问，请联客服人员";
public static final String PLEASE_LOGIN = "请登录";
public static final String LOING_INVALID = "登录已失效，请重新登录";
public static final String INVALID_ACCOUNT_LOGIN = "您的帐号已在其他地方登录，请确认是否是本人操作，如非本人操作，请及时修改密码";
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/contants/Datas.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/contants/Datas.java | package org.distributed.gateway.contants;
public class Datas {
// Eureka获取的服务名会带有前缀(暂时在OTC项目发现有此情况)
public static final String EUREKA_SUB_PFIX = "CompositeDiscoveryClient_";
public static final String AUTHORIZATION = "Authorization";
public static final String USERID = "userId";
public static final String DEVICETYPE = "deviceType";
public static final String FREEZE_MAIN = "freeze_main:";
public static final String TOKEN_SAFE = "token_safe:";
public static final String CABLE = "-";
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/bean/vo/ResultVO.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/bean/vo/ResultVO.java | package org.distributed.gateway.bean.vo;
public class ResultVO<T> {
/**
* 状态码
*/
private Integer code;
/**
* 信息
*/
private String message;
/**
* 返回数据
*/
private T data;
public ResultVO() {
}
public ResultVO(int code, String message, T data) {
this.code = code;
this.message = message;
this.data = data;
}
public ResultVO(int code, String message) {
this.code = code;
this.message = message;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/config/RedisCacheConfig.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/config/RedisCacheConfig.java | package org.distributed.gateway.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
/**
*
* @author lsj
*
*/
@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {
private static final Logger log = LoggerFactory.getLogger(RedisCacheConfig.class);
@Value("${spring.redis.database0}")
private Integer database0;
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.port}")
private int port;
// @Value("${spring.redis.sentinel.master}")
// private String sentinelMaster;
@Value("${spring.redis.sentinel.nodes:0.0.0.0}")
private String sentinelNodes;
public RedisStandaloneConfiguration getRedisStandaloneConfiguration(Integer database) {
RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration(host, port);
configuration.setPassword(RedisPassword.of(password));
configuration.setDatabase(database);
return configuration;
}
//多个哨兵
public RedisSentinelConfiguration getRedisSentinelConfiguration() {
RedisSentinelConfiguration sentinelconfiguration = new RedisSentinelConfiguration();
RedisNode masterRedisNode = new RedisNode(host, port);
// masterRedisNode.setName(sentinelMaster);
sentinelconfiguration.setMaster(masterRedisNode);
String[] host = sentinelNodes.split(",");
for(String redisHost : host){
String[] item = redisHost.split(":");
String ip = item[0];
String port = item[1];
sentinelconfiguration.addSentinel(new RedisNode(ip, Integer.parseInt(port)));
}
return sentinelconfiguration;
}
@SuppressWarnings("deprecation")
public JedisConnectionFactory jedisConnectionFactory(Integer database) {
if (sentinelNodes.equals("0.0.0.0")) {
RedisStandaloneConfiguration configuration = getRedisStandaloneConfiguration(database);
log.info("Create JedisConnectionFactory no Sentinel successful");
return new JedisConnectionFactory(configuration);
} else {
RedisSentinelConfiguration sentinelConfiguration = getRedisSentinelConfiguration();
JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(sentinelConfiguration,this.getPoolConfig());
jedisConnectionFactory.setHostName(host);
jedisConnectionFactory.setPort(port);
jedisConnectionFactory.setDatabase(database);
jedisConnectionFactory.setPassword(password);
jedisConnectionFactory.afterPropertiesSet();
log.info("Create JedisConnectionFactory Sentinel successful");
return jedisConnectionFactory;
}
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
// 配置redisTemplate
JedisConnectionFactory jedisConnectionFactory = jedisConnectionFactory(database0);
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
redisTemplate.setConnectionFactory(jedisConnectionFactory);
RedisSerializer<?> stringSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringSerializer); // key序列化
redisTemplate.setValueSerializer(stringSerializer); // value序列化
redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
redisTemplate.setHashValueSerializer(stringSerializer); // Hash value序列化
redisTemplate.afterPropertiesSet();
log.info("Create redisTemplate successful");
return redisTemplate;
}
public JedisPoolConfig getPoolConfig() {
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxTotal(1024);
jedisPoolConfig.setMaxIdle(100);
jedisPoolConfig.setMinEvictableIdleTimeMillis(60000);
jedisPoolConfig.setTimeBetweenEvictionRunsMillis(30000);
jedisPoolConfig.setNumTestsPerEvictionRun(-1);
jedisPoolConfig.setSoftMinEvictableIdleTimeMillis(10000);
jedisPoolConfig.setMaxWaitMillis(1000);
jedisPoolConfig.setTestOnBorrow(true);
jedisPoolConfig.setTestWhileIdle(true);
jedisPoolConfig.setTestOnReturn(false);
jedisPoolConfig.setJmxEnabled(true);
jedisPoolConfig.setBlockWhenExhausted(false);
return jedisPoolConfig;
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/config/SwaggerHandler.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/config/SwaggerHandler.java | package org.distributed.gateway.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;
import springfox.documentation.swagger.web.*;
import java.util.Optional;
@RestController
public class SwaggerHandler {
@Autowired(required = false)
private SecurityConfiguration securityConfiguration;
@Autowired(required = false)
private UiConfiguration uiConfiguration;
private final SwaggerResourcesProvider swaggerResources;
@Autowired
public SwaggerHandler(SwaggerResourcesProvider swaggerResources) {
this.swaggerResources = swaggerResources;
}
@GetMapping("/swagger-resources/configuration/security")
public Mono<ResponseEntity<SecurityConfiguration>> securityConfiguration() {
return Mono.just(new ResponseEntity<>(
Optional.ofNullable(securityConfiguration).orElse(SecurityConfigurationBuilder.builder().build()), HttpStatus.OK));
}
@GetMapping("/swagger-resources/configuration/ui")
public Mono<ResponseEntity<UiConfiguration>> uiConfiguration() {
return Mono.just(new ResponseEntity<>(
Optional.ofNullable(uiConfiguration).orElse(UiConfigurationBuilder.builder().build()), HttpStatus.OK));
}
@GetMapping("/swagger-resources")
public Mono<ResponseEntity> swaggerResources() {
return Mono.just((new ResponseEntity<>(swaggerResources.get(), HttpStatus.OK)));
}
@GetMapping("/")
public Mono<ResponseEntity> swaggerResourcesN() {
return Mono.just((new ResponseEntity<>(swaggerResources.get(), HttpStatus.OK)));
}
@GetMapping("/csrf")
public Mono<ResponseEntity> swaggerResourcesCsrf() {
return Mono.just((new ResponseEntity<>(swaggerResources.get(), HttpStatus.OK)));
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/config/SwaggerProvider.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/config/SwaggerProvider.java | package org.distributed.gateway.config;
import lombok.AllArgsConstructor;
import org.springframework.cloud.gateway.config.GatewayProperties;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.support.NameUtils;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import springfox.documentation.swagger.web.SwaggerResource;
import springfox.documentation.swagger.web.SwaggerResourcesProvider;
import java.util.ArrayList;
import java.util.List;
@Component
@Primary
@AllArgsConstructor
public class SwaggerProvider implements SwaggerResourcesProvider {
public static final String API_URI = "/v2/api-docs";
private final RouteLocator routeLocator;
private final GatewayProperties gatewayProperties;
@Override
public List<SwaggerResource> get() {
List<SwaggerResource> resources = new ArrayList<>();
List<String> routes = new ArrayList<>();
routeLocator.getRoutes().subscribe(route -> routes.add(route.getId()));
gatewayProperties.getRoutes().stream().filter(routeDefinition -> routes.contains(routeDefinition.getId()))
.forEach(routeDefinition -> routeDefinition.getPredicates().stream()
.filter(predicateDefinition -> ("Path").equalsIgnoreCase(predicateDefinition.getName()))
.forEach(predicateDefinition -> resources.add(swaggerResource(routeDefinition.getId(),
predicateDefinition.getArgs().get(NameUtils.GENERATED_NAME_PREFIX + "0")
.replace("/**", API_URI)))));
return resources;
}
private SwaggerResource swaggerResource(String name, String location) {
SwaggerResource swaggerResource = new SwaggerResource();
swaggerResource.setName(name);
swaggerResource.setLocation(location);
swaggerResource.setSwaggerVersion("2.0");
return swaggerResource;
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/config/RouteConfiguration.java | 分布式锁redisson多节点+附加源码和压测脚本/gateway/src/main/java/org/distributed/gateway/config/RouteConfiguration.java | package org.distributed.gateway.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.gateway.discovery.DiscoveryClientRouteDefinitionLocator;
import org.springframework.cloud.gateway.discovery.DiscoveryLocatorProperties;
import org.springframework.cloud.gateway.route.RouteDefinitionLocator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.cors.reactive.CorsUtils;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebFilter;
import org.springframework.web.server.WebFilterChain;
import reactor.core.publisher.Mono;
@Configuration
public class RouteConfiguration {
private static final Logger logger = LoggerFactory.getLogger(RouteConfiguration.class);
// 这里为支持的请求头，如果有自定义的header字段请自己添加（不知道为什么不能使用*）
private static final String ALLOWED_HEADERS = "x-requested-with, authorization, Content-Type, Authorization, credential, X-XSRF-TOKEN, token, username, client, devicetype, userId";
private static final String ALLOWED_METHODS = "*";
private static final String ALLOWED_EXPOSE = "*";
private static final String MAX_AGE = "18000L";
// @Bean
public WebFilter corsFilter() {
return (ServerWebExchange ctx, WebFilterChain chain) -> {
ServerHttpRequest request = ctx.getRequest();
if (CorsUtils.isCorsRequest(request)) {
ServerHttpResponse response = ctx.getResponse();
HttpHeaders headers = response.getHeaders();
String originHeader = request.getHeaders().getOrigin();
headers.add("Access-Control-Allow-Origin", originHeader);
headers.add("Access-Control-Allow-Methods", ALLOWED_METHODS);
headers.add("Access-Control-Max-Age", MAX_AGE);
headers.add("Access-Control-Allow-Headers", ALLOWED_HEADERS);
headers.add("Access-Control-Expose-Headers", ALLOWED_EXPOSE);
headers.add("Access-Control-Allow-Credentials", "true");
if (request.getMethod() == HttpMethod.OPTIONS) {
response.setStatusCode(HttpStatus.OK);
return Mono.empty();
}
}
return chain.filter(ctx);
};
}
/**
* 如果使用了注册中心（如：Eureka），进行控制则需要增加如下配置
*
* @param discoveryClient
* @return
*/
@Bean
public RouteDefinitionLocator discoveryClientRouteDefinitionLocator(DiscoveryClient discoveryClient,
DiscoveryLocatorProperties properties) {
return new DiscoveryClientRouteDefinitionLocator(discoveryClient, properties);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/countdownlatch并发实例/Runner.java | countdownlatch并发实例/Runner.java | package com.aofex.guess;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
* @ClassName Runner
* @Description: TODO
* @Author tingyu
* @Date 2020/8/22
* @Version V1.0
**/
public class Runner implements Callable<Integer> {
private CountDownLatch begin;
private CountDownLatch end;
public Runner(CountDownLatch begin, CountDownLatch end) {
super();
this.begin = begin;
this.end = end;
}
@Override
public Integer call() throws Exception {
int score = new Random().nextInt(1000);
begin.await(); // 裁判
// 跑步
System.out.println(Thread.currentThread().getName());
Thread.sleep(score);
// TimeUnit.MICROSECONDS.sleep(score); // 运动员跑步的时间
end.countDown();
return score;
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/countdownlatch并发实例/TestCountDownLatch.java | countdownlatch并发实例/TestCountDownLatch.java | package com.aofex.guess;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @ClassName TestCountDownLatch
* @Description: TODO
* @Author tingyu
* @Date 2020/8/22
* @Version V1.0
**/
public class TestCountDownLatch {
public static void main(String[] args) throws InterruptedException, ExecutionException {
long start = System.currentTimeMillis();
CountDownLatch begin = new CountDownLatch(1);
CountDownLatch end = new CountDownLatch(800);
ThreadFactory threadFactory = new NameTreadFactory();
RejectedExecutionHandler handler = new MyIgnorePolicy();
// xecutors 返回的线程池对象的弊端如下：1） FixedThreadPool 和 SingleThreadPool：
//允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。2） CachedThreadPool：
//允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(100, 200
, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2000), threadFactory,handler);
List<Future<Integer>> list = new ArrayList<>(); // 记录跑步情况
for (int i = 0 ; i< 800; i++) {
list.add(threadPoolExecutor.submit(new Runner(begin, end)));
}
begin.countDown();// 枪声响起
// 等待任务执行
end.await();
// 统计、
int count = 0 ;
int max = 0;
for(Future<Integer> f: list) {
count += f.get();
if (f.get() > max) {
max = count;
}
}
System.out.println("最高分= "+max +"总分=" + count + "平均分= " + count/8 + "总消耗时间 = " + (System.currentTimeMillis() - start));
}
static class NameTreadFactory implements ThreadFactory {
private final AtomicInteger mThreadNum = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
System.out.println(t.getName() + " has been created");
return t;
}
}
public static class MyIgnorePolicy implements RejectedExecutionHandler {
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
doLog(r, e);
}
private void doLog(Runnable r, ThreadPoolExecutor e) {
// 可做日志记录等
System.err.println( r.toString() + " rejected");
// System.out.println("completedTaskCount: " + e.getCompletedTaskCount());
}
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/yuyong-es-api/src/test/java/com/yong/YuyongEsApiApplicationTests.java | yuyong-es-api/src/test/java/com/yong/YuyongEsApiApplicationTests.java | package com.yong;
import com.alibaba.fastjson.JSON;
import com.yong.pojo.User;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.*;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
* es 7.1.x 高级客户端测试 API
*/
@SpringBootTest
class YuyongEsApiApplicationTests {
@Autowired
@Qualifier("restHighLevelClient")
private RestHighLevelClient client;
/**
* 创建索引 Request
*/
@Test
void createIndex() throws IOException {
// 创建索引请求
CreateIndexRequest request = new CreateIndexRequest("yong_index");
// 执行请求 IndicesClient
CreateIndexResponse createIndexResponse = client.indices()
.create(request, RequestOptions.DEFAULT);
System.out.println(createIndexResponse);
}
// 获取索引,只能判断是否存在
@Test
void getIndex() throws IOException {
GetIndexRequest request = new GetIndexRequest("yong_index");
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
System.out.println(exists);
}
// 测试删除索引
@Test
void deleteIndex() throws IOException {
DeleteIndexRequest request = new DeleteIndexRequest("yuyong_index");
AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
System.out.println(delete.isAcknowledged());
}
// 测试添加文档
// @Test
// void testAddDocument() throws IOException {
// // 创建对象
// User user = new User("zhangsan", 1);
// // 创建请求
// IndexRequest request = new IndexRequest("yong_index");
//
// // 规则 put /yong_index/_doc/1
// request.id("1");
// request.timeout("2s");
//
// // 将数据放入请求 json
// request.source(JSON.toJSONString(user), XContentType.JSON);
// IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
//
// System.out.println(indexResponse.toString());
// System.out.println(indexResponse.status()); // 对应命令返回的 created
// }
//
//
// // 获取文档 判断是否存在
// @Test
// void testIsExists() throws IOException {
// GetRequest getRequest = new GetRequest("yong_index", "1");
// // 不获取返回的 _source 的上下文了
// getRequest.fetchSourceContext(new FetchSourceContext(false));
// getRequest.storedFields("_none_");
//
// boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
// System.out.println(exists);
// }
//
// // 获取文档的信息
@Test
void testDocument() throws IOException {
long start = System.currentTimeMillis();
GetRequest getRequest = new GetRequest("alarm_index", "on3Vx3oBmoCAtdTSGYxp");
GetResponse response = client.get(getRequest, RequestOptions.DEFAULT);
response.getSource();
response.getField("time");
System.out.println(response); // 返回的全部内容
System.out.println("查询时间= "+ (System.currentTimeMillis() - start));
}
@Test
void testDocumentSelect() throws IOException {
long start = System.currentTimeMillis();
//创建搜索对象
SearchRequest searchRequest = new SearchRequest();
//构建查询工具
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//添加查询条件，通过QueryBuilders获取各种查询
searchSourceBuilder.query(QueryBuilders.rangeQuery("time").gte("1627247123741").lte("1628247124741"));
searchRequest.source(searchSourceBuilder);
// 第几页
searchSourceBuilder.from(10);
// 取消1w条限制
searchSourceBuilder.trackTotalHits(true);
// 每页多少条数据
searchSourceBuilder.size(10);
// 设置排序规则
searchSourceBuilder.sort("time", SortOrder.ASC);
// 设置超时时间为2s
searchSourceBuilder.timeout(new TimeValue(2000));
searchRequest.indices("alarm_index");
//查询
SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
//解析
SearchHits hits = search.getHits();
SearchHit[] hits1 = hits.getHits();
int count = 0;
for (SearchHit hit : hits1) {
//获取数据
String sourceAsString = hit.getSourceAsString();
count++;
//打印
System.out.println("结果::"+sourceAsString);
}
System.out.println("查询时间= "+ (System.currentTimeMillis() - start) + "count =" + count + "total=" + hits.getTotalHits().value);
}
@Test
public void scrollQueryTest() throws IOException {
// 1. 创建查询对象
String index = "alarm_index";
// String type = "sms-logs-type";
SearchRequest searchRequest = new SearchRequest(index);//指定索引
// searchRequest.types(type);//指定类型
searchRequest.scroll(TimeValue.timeValueMinutes(1l));//指定存在内存的时长为1分钟
// 2. 封装查询条件
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.sort("fee", SortOrder.DESC);
searchSourceBuilder.size(2);
searchSourceBuilder.query(QueryBuilders.matchAllQuery());
searchRequest.source(searchSourceBuilder);
// 3.执行查询
// client执行
HttpHost httpHost = new HttpHost("192.168.43.30", 9200);
RestClientBuilder restClientBuilder = RestClient.builder(httpHost);
RestHighLevelClient restHighLevelClient = new RestHighLevelClient(restClientBuilder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
String scrollId = searchResponse.getScrollId();
System.out.println(scrollId);//获取scorllId
// 4.获取数据
SearchHit[] hits = searchResponse.getHits().getHits();
for(SearchHit searchHit : hits){
System.out.println(searchHit);
}
//获取全部的下一页, 不过我不知道这种有什么用?????
while (true){
//创建SearchScrollRequest对象
SearchScrollRequest searchScrollRequest = new SearchScrollRequest(scrollId);
searchScrollRequest.scroll(TimeValue.timeValueMinutes(1l));//设置1分钟
SearchResponse scroll = restHighLevelClient.scroll(searchScrollRequest, RequestOptions.DEFAULT);
SearchHit[] hits1 = scroll.getHits().getHits();
if(hits1 != null && hits1.length > 0){
System.out.println("------------下一页--------------");
for(SearchHit searchHit : hits1){
System.out.println(searchHit);
}
}else {
System.out.println("------------结束--------------");
break;
}
}
//删除ScrollId
ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
clearScrollRequest.addScrollId(scrollId);
ClearScrollResponse clearScrollResponse = restHighLevelClient.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);
System.out.println("删除scroll" + clearScrollResponse);
}
//
// // 更新文档测试
// @Test
// void testUpdateDocument() throws IOException {
// UpdateRequest updateRequest = new UpdateRequest("yong_index", "1");
// updateRequest.timeout("1s");
//
// User user = new User("庾雍说", 23);
// updateRequest.doc(JSON.toJSONString(user), XContentType.JSON);
// UpdateResponse response = client.update(updateRequest, RequestOptions.DEFAULT);
// System.out.println(response.status());
// System.out.println(response);
// }
// 删除文档记录
@Test
void testDeleteDocument() throws IOException {
DeleteRequest deleteRequest = new DeleteRequest("yong_index", "1");
deleteRequest.timeout("1s");
DeleteResponse delete = client.delete(deleteRequest, RequestOptions.DEFAULT);
System.out.println(delete.status());
}
// 批量插入
@Test
void testBulkRequest() throws IOException, InterruptedException {
for(int i= 0; i<1000;i++) {
Thread.sleep(2000);
batchIn(i);
}
}
private void batchIn(int num) throws InterruptedException, IOException {
BulkRequest bulkRequest = new BulkRequest();
bulkRequest.timeout("60s");
ArrayList<User> list = new ArrayList<>();
for(int i= 0; i<20000;i++) {
if (i % 2000 ==0) {
Thread.sleep(5);
}
list.add(new User("8127787750964889197"+i*1000*num, System.currentTimeMillis()+i*1000*num,2,1));
}
// 批处理请求
for (int i = 0; i < list.size(); i++) {
// 批量操作 添加或者删除
bulkRequest.add(new IndexRequest("alarm_index")
//.id((i + 1) + "")
.source(JSON.toJSONString(list.get(i)), XContentType.JSON));
}
BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
}
// 查询
// SearchRequest 搜索请求
// SearchSourceBuilder 搜索构造
// HighlightBuilder 构造高亮
//
@Test
void testSearch() throws IOException {
SearchRequest searchRequest = new SearchRequest("yong_index");
// 构建查询构建器
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
// 搜索高亮
sourceBuilder.highlighter();
// 查询条件 我们可以使用 QueryBuilders 工具来实现
// QueryBuilders.termQuery 精确查询
// QueryBuilders.matchAllQuery() 查询所有
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "yuyong1");
sourceBuilder.query(termQueryBuilder);
sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
searchRequest.source(sourceBuilder);
SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
System.out.println(search.getHits());
System.out.println(JSON.toJSONString(search.getHits()));
System.out.println("==============================");
for (SearchHit hit : search.getHits().getHits()) {
Map<String, Object> sourceAsMap = hit.getSourceAsMap();
System.out.println(sourceAsMap);
}
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/yuyong-es-api/src/main/java/com/yong/YuyongEsApiApplication.java | yuyong-es-api/src/main/java/com/yong/YuyongEsApiApplication.java | package com.yong;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class YuyongEsApiApplication {
public static void main(String[] args) {
SpringApplication.run(YuyongEsApiApplication.class, args);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/yuyong-es-api/src/main/java/com/yong/pojo/Test.java | yuyong-es-api/src/main/java/com/yong/pojo/Test.java | package com.yong.pojo;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.zip.ZipInputStream;
/**
* @Classname Test
* @Description TODO
* @Date 2021/8/4 15:24
* @Created by rs
*/
public class Test {
/**
*
* @author: Harry.Shaw
* @desc: 使用zip进行解压缩
* @date: 2015年6月11日 下午4:55:47
* @param compressedStr 压缩后的文本
* @return 解压后的字符串
*/
@SuppressWarnings("restriction")
public static final String unzip(String compressedStr) {
if (compressedStr == null) {
return null;
}
ByteArrayOutputStream out = null;
ByteArrayInputStream in = null;
ZipInputStream zin = null;
String decompressed = null;
try {
byte[] compressed = new sun.misc.BASE64Decoder()
.decodeBuffer(compressedStr);
out = new ByteArrayOutputStream();
in = new ByteArrayInputStream(compressed);
zin = new ZipInputStream(in);
zin.getNextEntry();
byte[] buffer = new byte[1024];
int offset = -1;
while ((offset = zin.read(buffer)) != -1) {
out.write(buffer, 0, offset);
}
decompressed = out.toString("UTF-8");
} catch (IOException e) {
decompressed = null;
} finally {
if (zin != null) {
try {
zin.close();
} catch (IOException e) {
}
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
}
}
if (out != null) {
try {
out.close();
} catch (IOException e) {
}
}
}
return decompressed;
}
// public static void main(String[] args) {
// Thread th1= new Thread("custom"){
// @Override
// public void run(){
// while (true) {
// try {
// int i = 10;
// for(int j = 1; j < 100; j++) {
// i = i/(j % 10);
// }
// } catch (Exception e) {
// System.out.println(e);
// System.out.println(Thread.currentThread().getName());
// Thread.currentThread().interrupt();
// }
// }
// }
//
// };
// th1.start();
//// while (true) {
//// try {
//// int i = 10;
//// for(int j = 1; j < 100; j++) {
//// i = i/(j % 10);
//// }
//// } catch (Exception e) {
//// System.out.println("xxxxx"+e);
//// System.out.println(Thread.currentThread().getName());
//// Thread.currentThread().interrupt();
//// }
//// }
// }
public static void main(String[] args) {
TreeNode treeNode1 = new TreeNode(2);
TreeNode treeNode2 = new TreeNode(3);
TreeNode treeNode3 = new TreeNode(1, treeNode1,treeNode2);
zigzagLevelOrder(treeNode3);
}
public static List<List<Integer>> zigzagLevelOrder(TreeNode root) {
List<List<Integer>> ans = new LinkedList<List<Integer>>();
if (root == null) {
return ans;
}
Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
nodeQueue.offer(root);
boolean isOrderLeft = true;
while (!nodeQueue.isEmpty()) {
Deque<Integer> levelList = new LinkedList<Integer>();
int size = nodeQueue.size();
for (int i = 0; i < size; ++i) {
TreeNode curNode = nodeQueue.poll();
if (isOrderLeft) {
levelList.offerLast(curNode.val);
} else {
levelList.offerFirst(curNode.val);
}
if (curNode.left != null) {
nodeQueue.offer(curNode.left);
}
if (curNode.right != null) {
nodeQueue.offer(curNode.right);
}
}
ans.add(new LinkedList<Integer>(levelList));
isOrderLeft = !isOrderLeft;
}
return ans;
}
}
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
} | java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/yuyong-es-api/src/main/java/com/yong/pojo/User.java | yuyong-es-api/src/main/java/com/yong/pojo/User.java | package com.yong.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private String vid;
private Long time;
private int alarmCode;
private int handResult;
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/yuyong-es-api/src/main/java/com/yong/config/ElasticSearchConfig.java | yuyong-es-api/src/main/java/com/yong/config/ElasticSearchConfig.java | package com.yong.config;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
// spring 两个步骤
// 1、找对象
// 2、放入spring中待使用
// 3、如果是SpringBoot就先分析源码
// xxxx AutoConfiguration xxxProperties
@Configuration
public class ElasticSearchConfig {
@Bean
public RestHighLevelClient restHighLevelClient(){
return new RestHighLevelClient(
RestClient.builder(
new HttpHost("47.104.xx.105",9200,"http")));
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/AuthApplication.java | auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/AuthApplication.java | package org.bifu.distributed.auth;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* 认证模块启动程序
*
*/
@SpringBootApplication
@MapperScan("org.bifu.distributed.auth.dao")
public class AuthApplication {
public static void main(String[] args) {
SpringApplication.run(AuthApplication.class, args);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/RestTemplateConfig.java | auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/RestTemplateConfig.java | package org.bifu.distributed.auth.conf;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class RestTemplateConfig {
private static final String BROWSER_USERNAME = "client1";
private static final String BROWSER_PASSWORD = "secret1";
private static final String APP_USERNAME = "client2";
private static final String APP_PASSWORD = "secret2";
@Bean(name = "browserRestTemplate")
public RestTemplate pcRestTemplate(RestTemplateBuilder builder) {
return builder.basicAuthorization(BROWSER_USERNAME, BROWSER_PASSWORD).build();
}
@Bean(name = "appRestTemplate")
public RestTemplate mobileRestTemplate(RestTemplateBuilder builder) {
return builder.basicAuthorization(APP_USERNAME, APP_PASSWORD).build();
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/RedisConfiguration.java | auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/RedisConfiguration.java | package org.bifu.distributed.auth.conf;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
* Redis配置类
*
*/
@Configuration
@EnableCaching
public class RedisConfiguration extends CachingConfigurerSupport {
private static final Logger logger = LoggerFactory.getLogger(RedisConfiguration.class);
@Autowired
private JedisConnectionFactory jedisConnectionFactory;
@Bean
@Override
public KeyGenerator keyGenerator() {
// 设置自动key的生成规则，配置spring boot的注解，进行方法级别的缓存
// 使用：进行分割，可以很多显示出层级关系
// 这里其实就是new了一个KeyGenerator对象，采用lambda表达式的写法
return (target, method, params) -> {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(":");
sb.append(method.getName());
for (Object obj : params) {
sb.append(":" + String.valueOf(obj));
}
String rsToUse = String.valueOf(sb);
logger.info("自动生成Redis Key -> [{}]", rsToUse);
return rsToUse;
};
}
@Bean
@Override
public CacheManager cacheManager() {
// 初始化缓存管理器，在这里我们可以缓存的整体过期时间什么的，这里默认没有配置
logger.info("初始化 -> [{}]", "CacheManager RedisCacheManager Start");
RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.RedisCacheManagerBuilder
.fromConnectionFactory(jedisConnectionFactory);
return builder.build();
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Bean
public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
// 设置序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置redisTemplate
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
redisTemplate.setConnectionFactory(jedisConnectionFactory);
RedisSerializer<?> stringSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringSerializer); // key序列化
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value序列化
redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer); // Hash value序列化
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
@Override
@Bean
public CacheErrorHandler errorHandler() {
// 异常处理，当Redis发生异常时，打印日志，但是程序正常走
logger.info("初始化 -> [{}]", "Redis CacheErrorHandler");
CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
@Override
public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
logger.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
}
@Override
public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
logger.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
}
@Override
public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
logger.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
}
@Override
public void handleCacheClearError(RuntimeException e, Cache cache) {
logger.error("Redis occur handleCacheClearError：", e);
}
};
return cacheErrorHandler;
}
/**
* 创建JedisConnectionFactory和JedisPool 以供外部类初始化缓存管理器使用
*/
@ConfigurationProperties
class DataJedisProperties {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.timeout}")
private int timeout;
@Value("${spring.redis.jedis.pool.max-idle}")
private int maxIdle;
@Value("${spring.redis.jedis.pool.max-wait}")
private long maxWaitMillis;
@Bean
JedisConnectionFactory jedisConnectionFactory() {
logger.info("Create JedisConnectionFactory successful");
RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration(host, port);
configuration.setPassword(RedisPassword.of(password));
return new JedisConnectionFactory(configuration);
}
@Bean
public JedisPool redisPoolFactory() {
logger.info("JedisPool init successful，host -> [{}]；port -> [{}]", host, port);
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(maxIdle);
jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
return jedisPool;
}
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/SecurityConfiguration.java | auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/SecurityConfiguration.java | package org.bifu.distributed.auth.conf.auth;
import javax.transaction.Transactional;
import org.bifu.distributed.auth.constant.AuthContants;
import org.bifu.distributed.auth.dao.UserMapper;
import org.bifu.distributed.auth.domain.User;
import org.bifu.distributed.auth.dto.SecurityUserDTO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
private final static Logger logger = LoggerFactory.getLogger(SecurityConfiguration.class);
@Autowired
private UserMapper userMapper;
@Autowired
private MyAuthenticationSuccessHandler myAuthenticationSuccessHandler;
@Autowired
private MyAuthenticationFailureHandler myAuthenticationFailureHandler;
@Autowired
public void globalUserDetails(AuthenticationManagerBuilder auth) throws Exception {
// 配置用户来源于数据库
// auth.userDetailsService(userDetailsService()).passwordEncoder(new MyPasswordEncoder());
auth.userDetailsService(userDetailsService()).passwordEncoder(new BCryptPasswordEncoder());
// auth.userDetailsService(userDetailsService()).passwordEncoder(PasswordEncoderFactories.createDelegatingPasswordEncoder());
// auth.userDetailsService(userDetailsService()).passwordEncoder(MyPasswordEncoderFactories.createDelegatingPasswordEncoder());
}
/**
* authorizeRequests()配置路径拦截，表明路径访问所对应的权限，角色，认证信息。
* formLogin()对应表单认证相关的配置
* logout()对应了注销相关的配置
* httpBasic()可以配置basic登录
* 配置登陆页/login并允许访问
* 由于使用的是JWT，我们这里不需要csrf
* @param http
* @throws Exception
*/
@Override
protected void configure(HttpSecurity http) throws Exception {
http.formLogin().loginProcessingUrl("/auth/login").successHandler(myAuthenticationSuccessHandler)
.failureHandler(myAuthenticationFailureHandler)
.and().csrf().disable()
.sessionManagement()
.maximumSessions(1).expiredUrl("/expiredSession");
logger.info("test是否生成token");
}
@Override
@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
/**
* 用户验证
* @return
*/
@Override
@Bean
public UserDetailsService userDetailsService() {
return new UserDetailsService() {
@Override
@Transactional(rollbackOn = Exception.class)
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
logger.info("登录手机号或邮箱：======"+username);
// 查用户
User user = userMapper.selectByPhoneOrEmail(username, username);
if (user == null) {
throw new UsernameNotFoundException(AuthContants.USER_NOT_EXIST);
}
SecurityUserDTO dto = new SecurityUserDTO();
dto.setId(user.getId());
dto.setUsername(username);
dto.setPassword(user.getPassword());
dto.setDisable(user.getDisable());
// 创建securityUserDTO
// SecurityUserDTO securityUserDTO = new SecurityUserDTO(user);
return dto;
}
};
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/AuthorizationServerConfiguration.java | auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/AuthorizationServerConfiguration.java | package org.bifu.distributed.auth.conf.auth;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import com.alibaba.fastjson.JSONObject;
import org.bifu.distributed.auth.constant.AuthContants;
import org.bifu.distributed.auth.dto.SecurityUserDTO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.common.DefaultOAuth2AccessToken;
import org.springframework.security.oauth2.common.OAuth2AccessToken;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.security.oauth2.provider.OAuth2Authentication;
import org.springframework.security.oauth2.provider.client.JdbcClientDetailsService;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
import org.springframework.security.oauth2.provider.token.store.KeyStoreKeyFactory;
/**
* 认证授权服务端
*
*/
@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {
private final static Logger logger = LoggerFactory.getLogger(AuthorizationServerConfiguration.class);
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private DataSource dataSource;
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
endpoints.authenticationManager(this.authenticationManager);
endpoints.accessTokenConverter(accessTokenConverter());
endpoints.tokenStore(tokenStore());
endpoints.reuseRefreshTokens(false);
}
@Override
public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
oauthServer.tokenKeyAccess("isAnonymous() || hasAuthority('ROLE_TRUSTED_CLIENT')");
oauthServer.checkTokenAccess("hasAuthority('ROLE_TRUSTED_CLIENT')");
}
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
// jdbc方式 获取配置信息，oauth_client_details给谁发令牌，有效时间、授权模式、刷新令牌等等
clients.withClientDetails(clientDetails());
}
/**
* token converter
*
* @return
*/
@Bean
public JwtAccessTokenConverter accessTokenConverter() {
JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter() {
/***
* 重写增强token方法,用于自定义一些token返回的信息
*/
@Override
public OAuth2AccessToken enhance(OAuth2AccessToken accessToken,
OAuth2Authentication authentication) {
SecurityUserDTO securityUserDTO =
(SecurityUserDTO) authentication.getUserAuthentication().getPrincipal(); //获取当前用户信息
logger.info("重写增强token方法= {}", JSONObject.toJSONString(securityUserDTO));
final Map<String, Object> additionalInformation = new HashMap<>(16);
additionalInformation.put("userId", securityUserDTO.getId());
// 将用户信息添加到token额外信息中
((DefaultOAuth2AccessToken) accessToken)
.setAdditionalInformation(additionalInformation);
OAuth2AccessToken enhancedToken = super.enhance(accessToken, authentication);
return enhancedToken;
}
};
// 非对称加密
KeyStoreKeyFactory keyStoreKeyFactory =
new KeyStoreKeyFactory(new ClassPathResource(AuthContants.JKS_FILE),
AuthContants.JKS_PASSWORD.toCharArray());
accessTokenConverter.setKeyPair(keyStoreKeyFactory.getKeyPair(AuthContants.JKS_NAME));
logger.info("重写增强token方法结束");
return accessTokenConverter;
}
/**
* 定义clientDetails存储的方式-》Jdbc的方式，注入DataSource
*
* @return
*/
@Bean
public ClientDetailsService clientDetails() {
return new JdbcClientDetailsService(dataSource);
}
/**
* token store
* 返回jwt格式token
* @param
* @return
*/
@Bean
public TokenStore tokenStore() {
TokenStore tokenStore = new JwtTokenStore(accessTokenConverter());
return tokenStore;
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/MyPasswordEncoder.java | auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/MyPasswordEncoder.java | package org.bifu.distributed.auth.conf.auth;
import org.bifu.distributed.auth.util.Md5Util;
import org.springframework.security.crypto.password.PasswordEncoder;
public class MyPasswordEncoder implements PasswordEncoder {
@Override
public String encode(CharSequence rawPassword) {
String encPassword = Md5Util.getMD5(Md5Util.getMD5(rawPassword.toString()) + rawPassword);
return encPassword;
}
@Override
public boolean matches(CharSequence rawPassword, String encodedPassword) {
return encode(rawPassword).equals(encodedPassword);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/MyPasswordEncoderFactories.java | auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/MyPasswordEncoderFactories.java | package org.bifu.distributed.auth.conf.auth;
import java.util.HashMap;
import java.util.Map;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.DelegatingPasswordEncoder;
import org.springframework.security.crypto.password.LdapShaPasswordEncoder;
import org.springframework.security.crypto.password.Md4PasswordEncoder;
import org.springframework.security.crypto.password.MessageDigestPasswordEncoder;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.crypto.password.Pbkdf2PasswordEncoder;
import org.springframework.security.crypto.password.StandardPasswordEncoder;
import org.springframework.security.crypto.scrypt.SCryptPasswordEncoder;
/**
* Used for creating {@link PasswordEncoder} instances
* @author Rob Winch
* @since 5.0
*/
public class MyPasswordEncoderFactories {
/**
* Creates a {@link DelegatingPasswordEncoder} with default mappings. Additional
* mappings may be added and the encoding will be updated to conform with best
* practices. However, due to the nature of {@link DelegatingPasswordEncoder} the
* updates should not impact users. The mappings current are:
*
* <ul>
* <li>bcrypt - {@link BCryptPasswordEncoder} (Also used for encoding)</li>
* <li>ldap - {@link LdapShaPasswordEncoder}</li>
* <li>MD4 - {@link Md4PasswordEncoder}</li>
* <li>MD5 - {@code new MessageDigestPasswordEncoder("MD5")}</li>
* <li>noop - {@link NoOpPasswordEncoder}</li>
* <li>pbkdf2 - {@link Pbkdf2PasswordEncoder}</li>
* <li>scrypt - {@link SCryptPasswordEncoder}</li>
* <li>SHA-1 - {@code new MessageDigestPasswordEncoder("SHA-1")}</li>
* <li>SHA-256 - {@code new MessageDigestPasswordEncoder("SHA-256")}</li>
* <li>sha256 - {@link StandardPasswordEncoder}</li>
* </ul>
*
* @return the {@link PasswordEncoder} to use
*/
public static PasswordEncoder createDelegatingPasswordEncoder() {
String encodingId = "bcrypt";
Map<String, PasswordEncoder> encoders = new HashMap<>();
encoders.put(encodingId, new BCryptPasswordEncoder());
encoders.put("ldap", new LdapShaPasswordEncoder());
encoders.put("MD4", new Md4PasswordEncoder());
encoders.put("MD5", new MessageDigestPasswordEncoder("MD5"));
encoders.put("noop", NoOpPasswordEncoder.getInstance());
encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
encoders.put("scrypt", new SCryptPasswordEncoder());
encoders.put("SHA-1", new MessageDigestPasswordEncoder("SHA-1"));
encoders.put("SHA-256", new MessageDigestPasswordEncoder("SHA-256"));
encoders.put("sha256", new StandardPasswordEncoder());
encoders.put("myencoder", new MyPasswordEncoder());
return new DelegatingPasswordEncoder(encodingId, encoders);
}
private MyPasswordEncoderFactories() {}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/MyAuthenticationFailureHandler.java | auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/MyAuthenticationFailureHandler.java | package org.bifu.distributed.auth.conf.auth;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.bifu.distributed.auth.constant.AuthContants;
import org.bifu.distributed.auth.dto.ResultDTO;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSONObject;
@Component
public class MyAuthenticationFailureHandler implements AuthenticationFailureHandler {
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
AuthenticationException exception) throws IOException, ServletException {
String message = AuthContants.LOGIN_FAILE;
int code = AuthContants.CODE_500;
if (AuthContants.VERIFY_CODE_ERROR.equals(exception.getMessage())) {
message = AuthContants.VERIFY_CODE_ERROR;
code = AuthContants.CODE_603;
}
// 返回
ResultDTO<?> resultDTO = new ResultDTO<>(code, message);
response.setContentType("application/json;charset=UTF-8");
response.getWriter().write(JSONObject.toJSONString(resultDTO).toCharArray());
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/MyAuthenticationSuccessHandler.java | auth2-jwt/auth/src/main/java/org/xxxx/distributed/auth/conf/auth/MyAuthenticationSuccessHandler.java | package org.bifu.distributed.auth.conf.auth;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.bifu.distributed.auth.constant.AuthContants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;
@Component
public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
private final static Logger logger = LoggerFactory.getLogger(MyAuthenticationSuccessHandler.class);
@Value(value = "${prefix.auth}")
private String authPrefix;
@Value(value = "${oauth.redirectUrl}")
private String redirectUrl;
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
Authentication authentication) throws IOException, ServletException {
String deviceType = request.getHeader("deviceType");
logger.info("访问设备-----------》》》" + deviceType);
if (deviceType == null || "".equals(deviceType)) {
deviceType = "browser";
}
// 重定向url到 /token 接口
if ("browser".equals(deviceType)) {
response.sendRedirect(this.authPrefix + AuthContants.BROWSER_AUTHENTICATION_SUCCESS_URL + this.redirectUrl);
} else if ("app".equals(deviceType)) {
response.sendRedirect(this.authPrefix + AuthContants.APP_AUTHENTICATION_SUCCESS_URL + this.redirectUrl);
}
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/test/java/org/bibr/user/center/AppTest.java | auth2-jwt/user/src/test/java/org/bibr/user/center/AppTest.java | package org.bibr.user.center;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Unit test for simple App.
*/
public class AppTest
extends TestCase
{
/**
* Create the test case
*
* @param testName name of the test case
*/
public AppTest( String testName )
{
super( testName );
}
/**
* @return the suite of tests being tested
*/
public static Test suite()
{
return new TestSuite( AppTest.class );
}
/**
* Rigourous Test :-)
*/
public void testApp()
{
assertTrue( true );
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/Swagger.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/Swagger.java | package org.bifu.user.center;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class Swagger {
@Value("${swagger2.enable}")
private boolean swagger2Enable;
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.enable(swagger2Enable)
.apiInfo(apiInfo())
.select()
// 为当前包路径
.apis(RequestHandlerSelectors.basePackage("org.bifu.user.center.controller"))
.paths(PathSelectors.any()).build();
}
// 构建 api文档的详细信息函数,注意这里的注解引用的是哪个
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
// 页面标题
.title("示例API")
// 创建人
.contact(new Contact("Bibr", "http://www.bibr.com", ""))
// 版本号
.version("1.0")
// 描述
.description("API 描述").build();
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/UserCenterApplication.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/UserCenterApplication.java | package org.bifu.user.center;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@EnableScheduling
@EnableAsync
@SpringBootApplication
@EnableTransactionManagement
@MapperScan("org.bifu.user.center.dao")
public class UserCenterApplication {
public static void main(String[] args) {
SpringApplication.run(UserCenterApplication.class, args);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/config/TaskExecutePool.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/config/TaskExecutePool.java | package org.bifu.user.center.config;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.SchedulingTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
/**
* 自定义任务池
*
*/
@Configuration
public class TaskExecutePool {
@Value("${spring.task.pool.corePoolSize}")
private int corePoolSize;
@Value("${spring.task.pool.maxPoolSize}")
private int maxPoolSize;
@Value("${spring.task.pool.keepAliveSeconds}")
private int keepAliveSeconds;
@Value("${spring.task.pool.queueCapacity}")
private int queueCapacity;
@Bean
public Executor initTaskAsyncPool() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(corePoolSize);
executor.setMaxPoolSize(maxPoolSize);
executor.setQueueCapacity(keepAliveSeconds);
executor.setKeepAliveSeconds(queueCapacity);
executor.setThreadNamePrefix("MyExecutor-");
// rejection-policy：当pool已经达到max size的时候，如何处理新任务
// CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.initialize();
return executor;
}
@Bean
public SchedulingTaskExecutor initSchedulingTaskExecutor() {
ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
scheduler.setPoolSize(100);
scheduler.setThreadNamePrefix("MyScheduler-");
return scheduler;
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/config/RedisConfiguration.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/config/RedisConfiguration.java | package org.bifu.user.center.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
@EnableCaching
public class RedisConfiguration extends CachingConfigurerSupport {
private static final Logger logger = LoggerFactory.getLogger(RedisConfiguration.class);
@Autowired
private JedisConnectionFactory jedisConnectionFactory;
@Value("${spring.redis.database0}")
private Integer database0;
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.timeout}")
private int timeout;
@Value("${spring.redis.jedis.pool.max-idle}")
private int maxIdle;
@Value("${spring.redis.jedis.pool.max-wait}")
private long maxWaitMillis;
@Value("${spring.redis.sentinelHost:0.0.0.0}")
private String sentinelHost;
@Value("${spring.redis.sentinelPort:0}")
private int sentinelPort;
public RedisStandaloneConfiguration getRedisStandaloneConfiguration(Integer database) {
RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration(host, port);
configuration.setPassword(RedisPassword.of(password));
configuration.setDatabase(database);
return configuration;
}
public RedisSentinelConfiguration getRedisSentinelConfiguration(Integer database) {
RedisSentinelConfiguration sentinelConfiguration = new RedisSentinelConfiguration();
RedisNode masterRedisNode = new RedisNode(host, port);
masterRedisNode.setName("mymaster");
sentinelConfiguration.setMaster(masterRedisNode);
RedisNode redisSentinelNode = new RedisNode(sentinelHost, sentinelPort);
sentinelConfiguration.addSentinel(redisSentinelNode);
sentinelConfiguration.setDatabase(database);
sentinelConfiguration.setPassword(RedisPassword.of(password));
return sentinelConfiguration;
}
@Scope(scopeName = "prototype")
public JedisConnectionFactory jedisConnectionFactory(Integer database) {
logger.info("Create JedisConnectionFactory successful");
if (sentinelHost.equals("0.0.0.0")) {
RedisStandaloneConfiguration configuration = getRedisStandaloneConfiguration(database);
return new JedisConnectionFactory(configuration);
} else {
RedisSentinelConfiguration sentinelConfiguration = getRedisSentinelConfiguration(database);
// return new JedisConnectionFactory(sentinelConfiguration);
JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(sentinelConfiguration);
jedisConnectionFactory.setHostName(host);
jedisConnectionFactory.setPort(port);
jedisConnectionFactory.setDatabase(database);
jedisConnectionFactory.setPassword(password);
jedisConnectionFactory.afterPropertiesSet();
return jedisConnectionFactory;
}
}
@Bean
@Override
public KeyGenerator keyGenerator() {
// 设置自动key的生成规则，配置spring boot的注解，进行方法级别的缓存
// 使用：进行分割，可以很多显示出层级关系
// 这里其实就是new了一个KeyGenerator对象，采用lambda表达式的写法
return (target, method, params) -> {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(":");
sb.append(method.getName());
for (Object obj : params) {
sb.append(":" + String.valueOf(obj));
}
String rsToUse = String.valueOf(sb);
logger.info("自动生成Redis Key -> [{}]", rsToUse);
return rsToUse;
};
}
@Bean
@Override
public CacheManager cacheManager() {
// 初始化缓存管理器，在这里我们可以缓存的整体过期时间什么的，这里默认没有配置
logger.info("初始化 -> [{}]", "CacheManager RedisCacheManager Start");
RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.RedisCacheManagerBuilder
.fromConnectionFactory(jedisConnectionFactory);
return builder.build();
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
// 配置redisTemplate
JedisConnectionFactory jedisConnectionFactory = jedisConnectionFactory(database0);
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
redisTemplate.setConnectionFactory(jedisConnectionFactory);
RedisSerializer<?> stringSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringSerializer); // key序列化
redisTemplate.setValueSerializer(stringSerializer); // value序列化
redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
redisTemplate.setHashValueSerializer(stringSerializer); // Hash value序列化
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
@Override
@Bean
public CacheErrorHandler errorHandler() {
// 异常处理，当Redis发生异常时，打印日志，但是程序正常走
logger.info("初始化 -> [{}]", "Redis CacheErrorHandler");
CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
@Override
public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
logger.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
}
@Override
public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
logger.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
}
@Override
public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
logger.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
}
@Override
public void handleCacheClearError(RuntimeException e, Cache cache) {
logger.error("Redis occur handleCacheClearError：", e);
}
};
return cacheErrorHandler;
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/SecurityConfiguration.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/SecurityConfiguration.java | package org.bifu.user.center.config.security;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests().antMatchers(HttpMethod.OPTIONS).permitAll().anyRequest().authenticated().and()
.httpBasic().and().csrf().disable();
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/MyAuthenticationFailureHandler.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/MyAuthenticationFailureHandler.java | package org.bifu.user.center.config.security;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.bifu.user.center.bean.vo.ResultVO;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSONObject;
@Component
public class MyAuthenticationFailureHandler implements AuthenticationFailureHandler {
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
AuthenticationException exception) throws IOException, ServletException {
String code = exception.getMessage().substring(0, exception.getMessage().indexOf("-"));
String msg = exception.getMessage().substring(exception.getMessage().indexOf("-")+1);
ResultVO<?> resultDTO = new ResultVO<>(Integer.valueOf(code), msg);//token非本人
response.setContentType("application/json;charset=UTF-8");
response.getWriter().write(JSONObject.toJSONString(resultDTO).toCharArray());
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/ResourceServerConfiguration.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/ResourceServerConfiguration.java | package org.bifu.user.center.config.security;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.ResourceServerTokenServices;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
import org.springframework.security.web.AuthenticationEntryPoint;
/**
* 认证授权资源端
*
*/
@Configuration
@EnableResourceServer
public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter {
@Autowired
private MyAccessDeniedHandler myAccessDeniedHandler;
@Autowired
private Auth2ResponseExceptionTranslator auth2ResponseExceptionTranslator;
@Autowired
private SecurityAuthenticationEntryPoint securityAuthenticationEntryPoint;
@Override
public void configure(ResourceServerSecurityConfigurer resources) {
resources.resourceId("client2");
resources.tokenServices(defaultTokenServices());
// 定义异常转换类生效
AuthenticationEntryPoint authenticationEntryPoint = new OAuth2AuthenticationEntryPoint();
((OAuth2AuthenticationEntryPoint) authenticationEntryPoint)
.setExceptionTranslator(this.auth2ResponseExceptionTranslator);
resources.authenticationEntryPoint(authenticationEntryPoint);
}
@Override
public void configure(HttpSecurity http) throws Exception {
// // 放行路径在这写
http
//自定义校验拦截器----需要验证用户短信验证或者google验证的接口
// .addFilterAfter(new VerifyFilter(new AntPathRequestMatcher("/**/detection/**")),WebAsyncManagerIntegrationFilter.class)
.csrf().disable().exceptionHandling().authenticationEntryPoint(this.securityAuthenticationEntryPoint)
.accessDeniedHandler(myAccessDeniedHandler).and().authorizeRequests()
.antMatchers("/swagger-resources/**", "/v2/**", "/swagger/**", "/swagger**", "/webjars/**",
"/test/**","/api/**",
"/front/instant/**","/home/**","/system/**"
//开发测试
,"/strict/**"
)
.permitAll().anyRequest().authenticated().and().httpBasic().disable();
// ifream的跨域设置
http.headers().frameOptions().sameOrigin();
}
// private static class OauthRequestedMatcher implements RequestMatcher {
// @Override
// public boolean matches(HttpServletRequest request) {
// String auth = request.getHeader("Authorization");
// boolean haveOauth2Token = (auth != null) && auth.startsWith("Bearer");
// boolean haveAccessToken = request.getParameter("access_token") != null;
// return haveOauth2Token || haveAccessToken;
// }
// }
// ===================================================以下代码与认证服务器一致=========================================
/**
* token存储,这里使用jwt方式存储
*
* @param accessTokenConverter
* @return
*/
@Bean
public TokenStore tokenStore() {
TokenStore tokenStore = new JwtTokenStore(accessTokenConverter());
return tokenStore;
}
/**
* 创建一个默认的资源服务token
*
* @return
*/
@Bean
public ResourceServerTokenServices defaultTokenServices() {
final DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
defaultTokenServices.setTokenEnhancer(accessTokenConverter());
defaultTokenServices.setTokenStore(tokenStore());
return defaultTokenServices;
}
/**
* Token转换器必须与认证服务一致
*
* @return
*/
@Bean
public JwtAccessTokenConverter accessTokenConverter() {
JwtAccessTokenConverter accessTokenConverter = new JwtAccessTokenConverter() {
};
Resource resource = new ClassPathResource("public_key.txt");
String publicKey = null;
try {
publicKey = inputStream2String(resource.getInputStream());
} catch (final IOException e) {
throw new RuntimeException(e);
}
accessTokenConverter.setVerifierKey(publicKey);
return accessTokenConverter;
}
// ===================================================以上代码与认证服务器一致=========================================
private String inputStream2String(InputStream is) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(is));
StringBuffer buffer = new StringBuffer();
String line = "";
while ((line = in.readLine()) != null) {
buffer.append(line);
}
return buffer.toString();
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/SecurityAuthenticationEntryPoint.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/SecurityAuthenticationEntryPoint.java | package org.bifu.user.center.config.security;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
/**
* 没有token时的异常处理器
*
*/
@Component
public class SecurityAuthenticationEntryPoint implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response,
AuthenticationException authException) throws IOException, ServletException {
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
response.getWriter().append("{\"code\":601,\"message\":\"用户token不正确\"}");
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/MyAccessDeniedHandler.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/MyAccessDeniedHandler.java | package org.bifu.user.center.config.security;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;
/**
* 没有权限时的异常处理器
*
*/
@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest request, HttpServletResponse response,
AccessDeniedException accessDeniedException) throws IOException, ServletException {
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
response.getWriter().append("{\"code\":\"602\",\"message\":\"认证不通过\"}");
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
tingyunote/Tingyu-Notes | https://github.com/tingyunote/Tingyu-Notes/blob/90219bf94419903f51dac66dd0e13038aa10943d/auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/Auth2ResponseExceptionTranslator.java | auth2-jwt/user/src/main/java/org/xxxx/user/center/config/security/Auth2ResponseExceptionTranslator.java | package org.bifu.user.center.config.security;
import org.bifu.user.center.exception.BusinessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.oauth2.common.exceptions.InvalidTokenException;
import org.springframework.security.oauth2.provider.error.WebResponseExceptionTranslator;
import org.springframework.stereotype.Component;
/**
* token失效时的异常处理器
*
*/
@Component
public class Auth2ResponseExceptionTranslator implements WebResponseExceptionTranslator<BusinessException> {
@Override
public ResponseEntity<BusinessException> translate(Exception e) throws Exception {
Throwable throwable = e.getCause();
if (throwable.getMessage().indexOf("Access token expired") != -1) {
return new ResponseEntity<BusinessException>(new BusinessException(602, "用户token已过期"), HttpStatus.OK);
}
if (throwable instanceof InvalidTokenException) {
return new ResponseEntity<BusinessException>(new BusinessException(601, "用户token不正确"), HttpStatus.OK);
}
return new ResponseEntity<BusinessException>(new BusinessException(405, "方法不被允许"),
HttpStatus.METHOD_NOT_ALLOWED);
}
}
| java | Apache-2.0 | 90219bf94419903f51dac66dd0e13038aa10943d | 2026-01-05T02:42:38.324015Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/InstitutionsSearchTest.java | src/test/java/com/plaid/client/integration/InstitutionsSearchTest.java | package com.plaid.client.integration;
import static junit.framework.TestCase.assertNull;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import com.plaid.client.model.AccountSubtype;
import com.plaid.client.model.CountryCode;
import com.plaid.client.model.InstitutionsSearchAccountFilter;
import com.plaid.client.model.InstitutionsSearchRequest;
import com.plaid.client.model.InstitutionsSearchRequestOptions;
import com.plaid.client.model.InstitutionsSearchResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import retrofit2.Response;
public class InstitutionsSearchTest extends AbstractIntegrationTest {
@Test
public void testSuccess() throws Exception {
InstitutionsSearchRequest request = new InstitutionsSearchRequest()
.countryCodes(Arrays.asList(CountryCode.US))
.products(Arrays.asList(Products.IDENTITY))
.query("t");
Response<InstitutionsSearchResponse> response = client()
.institutionsSearch(request)
.execute();
assertSuccessResponse(response);
}
@Test
public void testSuccessWithIncludeOptionalMetadataTrue() throws Exception {
InstitutionsSearchRequestOptions options = new InstitutionsSearchRequestOptions()
.includeOptionalMetadata(true);
InstitutionsSearchRequest request = new InstitutionsSearchRequest()
.countryCodes(Arrays.asList(CountryCode.US))
.products(Arrays.asList(Products.IDENTITY))
.query("t")
.options(options);
Response<InstitutionsSearchResponse> response = client()
.institutionsSearch(request)
.execute();
assertSuccessResponse(response);
InstitutionsSearchResponse institutionsSearchResponse = response.body();
assertNotNull(institutionsSearchResponse.getInstitutions().get(0).getUrl());
assertNotNull(
institutionsSearchResponse.getInstitutions().get(0).getPrimaryColor()
);
}
@Test
public void testSuccessWithIncludeOptionalMetadataFalse() throws Exception {
InstitutionsSearchRequestOptions options = new InstitutionsSearchRequestOptions()
.includeOptionalMetadata(false);
InstitutionsSearchRequest request = new InstitutionsSearchRequest()
.countryCodes(Arrays.asList(CountryCode.US))
.products(Arrays.asList(Products.IDENTITY))
.query("t")
.options(options);
Response<InstitutionsSearchResponse> response = client()
.institutionsSearch(request)
.execute();
assertSuccessResponse(response);
InstitutionsSearchResponse institutionsSearchResponse = response.body();
assertNull(institutionsSearchResponse.getInstitutions().get(0).getUrl());
assertNull(
institutionsSearchResponse.getInstitutions().get(0).getPrimaryColor()
);
}
@Test
public void testSuccessWithOAuth() throws Exception {
InstitutionsSearchRequestOptions options = new InstitutionsSearchRequestOptions()
.oauth(true);
InstitutionsSearchRequest request = new InstitutionsSearchRequest()
.countryCodes(Arrays.asList(CountryCode.GB))
.products(Arrays.asList(Products.AUTH))
.query("Pl")
.options(options);
Response<InstitutionsSearchResponse> response = client()
.institutionsSearch(request)
.execute();
assertSuccessResponse(response);
InstitutionsSearchResponse institutionsSearchResponse = response.body();
assertTrue(institutionsSearchResponse.getInstitutions().get(0).getOauth());
}
@Test
public void testSuccessWithoutOAuth() throws Exception {
InstitutionsSearchRequestOptions options = new InstitutionsSearchRequestOptions()
.oauth(false);
InstitutionsSearchRequest request = new InstitutionsSearchRequest()
.countryCodes(Arrays.asList(CountryCode.GB))
.products(Arrays.asList(Products.AUTH))
.query("Bank")
.options(options);
Response<InstitutionsSearchResponse> response = client()
.institutionsSearch(request)
.execute();
assertSuccessResponse(response);
InstitutionsSearchResponse institutionsSearchResponse = response.body();
// TODO: reenable once oauth filtering is fixed
// assertFalse(institutionsSearchResponse.getInstitutions().get(0).getOauth());
}
@Test
public void testNoResults() throws Exception {
InstitutionsSearchRequest request = new InstitutionsSearchRequest()
.countryCodes(Arrays.asList(CountryCode.US))
.products(Arrays.asList(Products.AUTH))
.query("zebra");
Response<InstitutionsSearchResponse> response = client()
.institutionsSearch(request)
.execute();
assertSuccessResponse(response);
assertEquals(0, response.body().getInstitutions().size());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AssetReportAuditCopyCreateTest.java | src/test/java/com/plaid/client/integration/AssetReportAuditCopyCreateTest.java | package com.plaid.client.integration;
import com.plaid.client.model.AssetReportAuditCopyCreateRequest;
import com.plaid.client.model.Products;
import com.plaid.client.model.AssetReportAuditCopyCreateResponse;
import com.plaid.client.model.AssetReportCreateResponse;
import org.junit.Test;
import retrofit2.Response;
import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.assertNotNull;
public class AssetReportAuditCopyCreateTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.ASSETS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testAssetReportAuditCopyCreateSuccess() throws Exception {
// Create asset report to get an asset report token
List<String> accessTokens = Arrays.asList(getItemPublicTokenExchangeResponse().getAccessToken());
Response<AssetReportCreateResponse> createResponse = AssetReportCreateTest.createAssetReport(client(), accessTokens);
String assetReportToken = createResponse.body().getAssetReportToken();
AssetReportGetTest.waitTillReady(client(), assetReportToken);
AssetReportAuditCopyCreateRequest request = new AssetReportAuditCopyCreateRequest()
.assetReportToken(assetReportToken)
.auditorId("fannie_mae");
Response<AssetReportAuditCopyCreateResponse> response = client().assetReportAuditCopyCreate(request).execute();
assertNotNull(response.body().getAuditCopyToken());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AssetReportGetTest.java | src/test/java/com/plaid/client/integration/AssetReportGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.google.gson.Gson;
import com.plaid.client.model.AccountAssets;
import com.plaid.client.model.AssetReport;
import com.plaid.client.model.AssetReportCreateResponse;
import com.plaid.client.model.AssetReportGetRequest;
import com.plaid.client.model.AssetReportGetResponse;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.Products;
import com.plaid.client.request.PlaidApi;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import org.json.JSONObject;
import org.junit.Test;
import retrofit2.Response;
public class AssetReportGetTest extends AbstractItemIntegrationTest {
private static final String PRODUCT_NOT_READY = "PRODUCT_NOT_READY";
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.ASSETS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testAssetReportGetSuccess() throws Exception {
// Create asset report to get an asset report token
List<String> accessTokens = Arrays.asList(
getItemPublicTokenExchangeResponse().getAccessToken()
);
Response<AssetReportCreateResponse> createResponse = AssetReportCreateTest.createAssetReport(
client(),
accessTokens
);
String assetReportToken = createResponse.body().getAssetReportToken();
// Wait till asset report is ready
Response<AssetReportGetResponse> response = waitTillReady(
client(),
assetReportToken
);
// Validate the responses
AssetReportGetResponse respBody = response.body();
assertSuccessResponse(response);
assertNotNull(respBody.getReport());
assertNotNull(respBody.getReport().getUser());
assertFalse(respBody.getReport().getItems().isEmpty());
assertNotNull(respBody.getReport().getAssetReportId());
// Retrieve the report as an Asset Report with Insights.
AssetReportGetRequest assetReportGetRequest = new AssetReportGetRequest()
.includeInsights(true)
.assetReportToken(assetReportToken);
response = client().assetReportGet(assetReportGetRequest).execute();
respBody = response.body();
assertSuccessResponse(response);
assertNotNull(respBody.getReport());
// An Asset Report with Insights should include a name (when available).
assertTrue(containsTransactionWithName(respBody.getReport()));
}
private boolean containsTransactionWithName(AssetReport assetReport) {
List<AccountAssets> accounts = assetReport.getItems().get(0).getAccounts();
for (AccountAssets account : accounts) {
if (account.getTransactions().size() > 0) {
return account.getTransactions().get(0).getName() != null;
}
}
return false;
}
/**
* Utility function that polls Plaid till we see the Asset Report is ready
*/
public static Response<AssetReportGetResponse> waitTillReady(
PlaidApi client,
String assetReportToken
)
throws Exception {
int NUM_RETRIES = 20;
int INTER_REQUEST_SLEEP = 2000; // millis
int attempt = 0;
Response<AssetReportGetResponse> response;
JSONObject errorResponse = new JSONObject();
PlaidError error = new PlaidError();
do {
AssetReportGetRequest assetReportGetRequest = new AssetReportGetRequest()
.assetReportToken(assetReportToken);
response = client.assetReportGet(assetReportGetRequest).execute();
try {
Gson gson = new Gson();
error = gson.fromJson(response.errorBody().string(), PlaidError.class);
} catch (Exception e) {
// Dont' want to throw here.
}
attempt++;
Thread.sleep(INTER_REQUEST_SLEEP);
} while (
!response.isSuccessful() &&
response.errorBody() != null &&
error.getErrorType().equals(PlaidErrorType.ASSET_REPORT_ERROR) &&
attempt < NUM_RETRIES
);
if (!response.isSuccessful()) {
throw new Exception(
String.format(
"Could not get asset report. Failed with %s",
errorResponse.getJSONObject("error").getString("error_message")
)
);
}
return response;
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/IncomeVerificationPaystubsGetTest.java | src/test/java/com/plaid/client/integration/IncomeVerificationPaystubsGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.integration.AbstractIntegrationTest;
import com.plaid.client.model.*;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import retrofit2.Response;
public class IncomeVerificationPaystubsGetTest extends AbstractIntegrationTest {
private String accessToken;
@Before
public void setUp() throws Exception {
SandboxPublicTokenCreateRequest request = new SandboxPublicTokenCreateRequest()
.institutionId(INCOME_INSTITUTION_ID)
.initialProducts(Arrays.asList(Products.INCOME_VERIFICATION));
Response<SandboxPublicTokenCreateResponse> createResponse = client()
.sandboxPublicTokenCreate(request)
.execute();
assertSuccessResponse(createResponse);
ItemPublicTokenExchangeRequest exchangeRequest = new ItemPublicTokenExchangeRequest()
.publicToken(createResponse.body().getPublicToken());
Response<ItemPublicTokenExchangeResponse> response = client()
.itemPublicTokenExchange(exchangeRequest)
.execute();
assertSuccessResponse(response);
this.accessToken = response.body().getAccessToken();
}
@Test
// @Ignore
public void testIncomeVerificationPaystubsGet() throws Exception {
IncomeVerificationPaystubsGetRequest request = new IncomeVerificationPaystubsGetRequest()
.accessToken(this.accessToken);
Response<IncomeVerificationPaystubsGetResponse> apiResponse = client().incomeVerificationPaystubsGet(request).execute();
IncomeVerificationPaystubsGetResponse paystubsResponse = apiResponse.body();
assertNotNull(paystubsResponse);
assertNull(paystubsResponse.getError());
assertTrue(paystubsResponse.getPaystubs().size() > 0);
assertTrue(paystubsResponse.getDocumentMetadata().size() > 0);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/LinkTokenGetTest.java | src/test/java/com/plaid/client/integration/LinkTokenGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.AccountFiltersResponse;
import com.plaid.client.model.DepositoryAccountSubtype;
import com.plaid.client.model.CountryCode;
import com.plaid.client.model.DepositoryFilter;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.LinkTokenAccountFilters;
import com.plaid.client.model.LinkTokenCreateRequest;
import com.plaid.client.model.LinkTokenCreateRequestUser;
import com.plaid.client.model.LinkTokenCreateResponse;
import com.plaid.client.model.LinkTokenGetRequest;
import com.plaid.client.model.LinkTokenGetResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import retrofit2.Response;
public class LinkTokenGetTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.AUTH);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testInvalidToken() throws Exception {
LinkTokenGetRequest request = new LinkTokenGetRequest()
.linkToken("bad token");
Response<LinkTokenGetResponse> response = client()
.linkTokenGet(request)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_REQUEST,
"INVALID_FIELD"
);
}
@Test
public void testSuccess() throws Exception {
String clientName = "very nice client name";
String clientUserId = Long.toString((new Date()).getTime());
LinkTokenCreateRequestUser user = new LinkTokenCreateRequestUser()
.clientUserId(clientUserId);
DepositoryFilter types = new DepositoryFilter()
.accountSubtypes(Arrays.asList(DepositoryAccountSubtype.SAVINGS));
LinkTokenAccountFilters accountFilters = new LinkTokenAccountFilters()
.depository(types);
LinkTokenCreateRequest request = new LinkTokenCreateRequest()
.user(user)
.clientName(clientName)
.products(Arrays.asList(Products.AUTH))
.countryCodes(Arrays.asList(CountryCode.US))
.language("en")
.accountFilters(accountFilters);
Response<LinkTokenCreateResponse> createResponse = client()
.linkTokenCreate(request)
.execute();
assertSuccessResponse(createResponse);
String linkToken = createResponse.body().getLinkToken();
assertNotNull(linkToken);
LinkTokenGetRequest getRequest = new LinkTokenGetRequest()
.linkToken(linkToken);
Response<LinkTokenGetResponse> getResponse = client()
.linkTokenGet(getRequest)
.execute();
assertSuccessResponse(getResponse);
assertEquals(clientName, getResponse.body().getMetadata().getClientName());
assertEquals(
Arrays.asList(Products.AUTH),
getResponse.body().getMetadata().getInitialProducts()
);
assertEquals(
Arrays.asList(CountryCode.US),
getResponse.body().getMetadata().getCountryCodes()
);
// TODO: Fix when AccountFilters object is condensed.
DepositoryFilter depositoryType = new DepositoryFilter()
.accountSubtypes(Arrays.asList(DepositoryAccountSubtype.SAVINGS));
AccountFiltersResponse filters = new AccountFiltersResponse()
.depository(depositoryType);
assertEquals(filters, getResponse.body().getMetadata().getAccountFilters());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/ItemPublicTokenExchangeTest.java | src/test/java/com/plaid/client/integration/ItemPublicTokenExchangeTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.ItemPublicTokenExchangeRequest;
import com.plaid.client.model.ItemPublicTokenExchangeResponse;
import com.plaid.client.model.Products;
import com.plaid.client.model.SandboxPublicTokenCreateRequest;
import com.plaid.client.model.SandboxPublicTokenCreateResponse;
import java.util.Arrays;
import java.util.HashMap;
import org.junit.Before;
import org.junit.Test;
import retrofit2.Response;
public class ItemPublicTokenExchangeTest extends AbstractIntegrationTest {
private String publicToken;
@Before
public void setUp() throws Exception {
SandboxPublicTokenCreateRequest request = new SandboxPublicTokenCreateRequest()
.institutionId(TARTAN_BANK_INSTITUTION_ID)
.initialProducts(Arrays.asList(Products.AUTH));
Response<SandboxPublicTokenCreateResponse> response = client()
.sandboxPublicTokenCreate(request)
.execute();
assertSuccessResponse(response);
publicToken = response.body().getPublicToken();
}
@Test
public void testSuccess() throws Exception {
ItemPublicTokenExchangeRequest request = new ItemPublicTokenExchangeRequest()
.publicToken(publicToken);
Response<ItemPublicTokenExchangeResponse> response = client()
.itemPublicTokenExchange(request)
.execute();
assertSuccessResponse(response);
assertNotNull(response.body().getAccessToken());
assertNotNull(response.body().getItemId());
}
@Test
public void testInvalidTokenFailure() throws Exception {
ItemPublicTokenExchangeRequest request = new ItemPublicTokenExchangeRequest()
.publicToken("not-real");
Response<ItemPublicTokenExchangeResponse> response = client()
.itemPublicTokenExchange(request)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_PUBLIC_TOKEN"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AssetReportRemoveTest.java | src/test/java/com/plaid/client/integration/AssetReportRemoveTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertTrue;
import com.plaid.client.model.AssetReportCreateResponse;
import com.plaid.client.model.AssetReportRemoveRequest;
import com.plaid.client.model.AssetReportRemoveResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class AssetReportRemoveTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.ASSETS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testAssetReportRemoveSuccess() throws Exception {
// Create asset report to get an asset report token
List<String> accessTokens = Arrays.asList(
getItemPublicTokenExchangeResponse().getAccessToken()
);
Response<AssetReportCreateResponse> createResponse = AssetReportCreateTest.createAssetReport(
client(),
accessTokens
);
String assetReportToken = createResponse.body().getAssetReportToken();
// Poll Plaid till report is ready
AssetReportGetTest.waitTillReady(client(), assetReportToken);
AssetReportRemoveRequest assetReportRemoveRequest = new AssetReportRemoveRequest()
.assetReportToken(assetReportToken);
Response<AssetReportRemoveResponse> response = client()
.assetReportRemove(assetReportRemoveRequest)
.execute();
assertTrue(response.body().getRemoved());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/ItemImportTest.java | src/test/java/com/plaid/client/integration/ItemImportTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.model.ItemImportRequest;
import com.plaid.client.model.ItemImportRequestUserAuth;
import com.plaid.client.model.ItemImportRequestOptions;
import com.plaid.client.model.ItemImportResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.HashMap;
import org.junit.Test;
import retrofit2.Response;
public class ItemImportTest extends AbstractIntegrationTest {
@Test
public void testSuccess() throws Exception {
ItemImportRequestOptions options = new ItemImportRequestOptions()
.webhook("https://some.webhook.example.com");
ItemImportRequestUserAuth itemImportRequestUserAuth = new ItemImportRequestUserAuth()
.userId("user_good")
.authToken("pass_good");
ItemImportRequest request = new ItemImportRequest()
.products(Arrays.asList(Products.IDENTITY, Products.AUTH))
.userAuth(itemImportRequestUserAuth)
.options(options);
Response<ItemImportResponse> response = client()
.itemImport(request)
.execute();
assertSuccessResponse(response);
assertNotNull(response.body().getAccessToken());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/IncomeVerificationSummaryGetTest.java | src/test/java/com/plaid/client/integration/IncomeVerificationSummaryGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.integration.AbstractIntegrationTest;
import com.plaid.client.model.*;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import retrofit2.Response;
public class IncomeVerificationSummaryGetTest extends AbstractIntegrationTest {
private String accessToken;
@Before
public void setUp() throws Exception {
SandboxPublicTokenCreateRequest request = new SandboxPublicTokenCreateRequest()
.institutionId(INCOME_INSTITUTION_ID)
.initialProducts(Arrays.asList(Products.INCOME_VERIFICATION));
Response<SandboxPublicTokenCreateResponse> createResponse = client()
.sandboxPublicTokenCreate(request)
.execute();
assertSuccessResponse(createResponse);
ItemPublicTokenExchangeRequest exchangeRequest = new ItemPublicTokenExchangeRequest()
.publicToken(createResponse.body().getPublicToken());
Response<ItemPublicTokenExchangeResponse> response = client()
.itemPublicTokenExchange(exchangeRequest)
.execute();
assertSuccessResponse(response);
this.accessToken = response.body().getAccessToken();
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/PaymentListTest.java | src/test/java/com/plaid/client/integration/PaymentListTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import com.plaid.client.integration.PaymentCreateTest;
import com.plaid.client.model.PaymentInitiationPaymentCreateResponse;
import com.plaid.client.model.PaymentInitiationPaymentListRequest;
import com.plaid.client.model.PaymentInitiationPaymentListResponse;
import org.junit.Test;
import retrofit2.Response;
import java.time.OffsetDateTime;
public class PaymentListTest extends AbstractIntegrationTest {
@Test
public void testPaymentListSuccess() throws Exception {
Response<PaymentInitiationPaymentCreateResponse> createPaymentResponse = PaymentCreateTest.createPayment(
client()
);
String paymentId = createPaymentResponse.body().getPaymentId();
assertNotNull(paymentId);
PaymentInitiationPaymentListRequest request = new PaymentInitiationPaymentListRequest()
.count(10);
Response<PaymentInitiationPaymentListResponse> listPaymentResponse = client()
.paymentInitiationPaymentList(request)
.execute();
assertSuccessResponse(listPaymentResponse);
assertTrue(listPaymentResponse.body().getPayments().size() > 0);
if (listPaymentResponse.body().getNextCursor() != null) {
OffsetDateTime nextCursor = listPaymentResponse.body().getNextCursor();
PaymentInitiationPaymentListRequest cursorReq = new PaymentInitiationPaymentListRequest()
.cursor(nextCursor);
Response<PaymentInitiationPaymentListResponse> listPaymentResponseWithCursor = client()
.paymentInitiationPaymentList(cursorReq)
.execute();
assertSuccessResponse(listPaymentResponseWithCursor);
}
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/IncomeVerificationTaxformsGetTest.java | src/test/java/com/plaid/client/integration/IncomeVerificationTaxformsGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.integration.AbstractIntegrationTest;
import com.plaid.client.model.*;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import retrofit2.Response;
public class IncomeVerificationTaxformsGetTest extends AbstractIntegrationTest {
private String accessToken;
@Before
public void setUp() throws Exception {
SandboxPublicTokenCreateRequest request = new SandboxPublicTokenCreateRequest()
.institutionId(INCOME_INSTITUTION_ID)
.initialProducts(Arrays.asList(Products.INCOME_VERIFICATION));
Response<SandboxPublicTokenCreateResponse> createResponse = client()
.sandboxPublicTokenCreate(request)
.execute();
assertSuccessResponse(createResponse);
ItemPublicTokenExchangeRequest exchangeRequest = new ItemPublicTokenExchangeRequest()
.publicToken(createResponse.body().getPublicToken());
Response<ItemPublicTokenExchangeResponse> response = client()
.itemPublicTokenExchange(exchangeRequest)
.execute();
assertSuccessResponse(response);
this.accessToken = response.body().getAccessToken();
}
@Test
public void testIncomeVerificationTaxformsGet() throws Exception {
IncomeVerificationTaxformsGetRequest request = new IncomeVerificationTaxformsGetRequest()
.accessToken(this.accessToken);
Response<IncomeVerificationTaxformsGetResponse> apiResponse = client().incomeVerificationTaxformsGet(request).execute();
IncomeVerificationTaxformsGetResponse taxformsResponse = apiResponse.body();
assertNotNull(taxformsResponse);
assertNull(taxformsResponse.getError());
assertTrue(taxformsResponse.getTaxforms().size() > 0);
assertTrue(taxformsResponse.getDocumentMetadata().size() > 0);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/InvestmentsHoldingsGetTest.java | src/test/java/com/plaid/client/integration/InvestmentsHoldingsGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.model.AccountBase;
import com.plaid.client.model.AccountType;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.Holding;
import com.plaid.client.model.InvestmentHoldingsGetRequestOptions;
import com.plaid.client.model.InvestmentsHoldingsGetRequest;
import com.plaid.client.model.InvestmentsHoldingsGetResponse;
import com.plaid.client.model.Products;
import com.plaid.client.model.Security;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Ignore;
import org.junit.Test;
import retrofit2.Response;
public class InvestmentsHoldingsGetTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Collections.singletonList(Products.INVESTMENTS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Ignore
@Test
public void testInvestmentsHoldingsGetSuccess() throws Exception {
InvestmentsHoldingsGetRequest request = new InvestmentsHoldingsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<InvestmentsHoldingsGetResponse> response = client()
.investmentsHoldingsGet(request)
.execute();
assertSuccessResponse(response);
// item should be the same one we created
assertItemEquals(getItem(), response.body().getItem());
// sandbox should return expected holdings
List<Holding> holdings = response.body().getHoldings();
assertTrue(holdings.size() > 0);
for (Holding holding : holdings) {
assertNotNull(holding.getAccountId());
assertNotNull(holding.getSecurityId());
assertNotNull(holding.getQuantity());
assertNotNull(holding.getIsoCurrencyCode());
}
List<Security> securities = response.body().getSecurities();
assertTrue(securities.size() > 0);
for (Security security : securities) {
assertNotNull(security.getSecurityId());
assertNotNull(security.getName());
assertNotNull(security.getType());
assertNotNull(security.getIsoCurrencyCode());
}
}
@Test
public void testInvestmentsHoldingGetWithAccountIds() throws Exception {
// first call to get an account ID
InvestmentsHoldingsGetRequest request = new InvestmentsHoldingsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<InvestmentsHoldingsGetResponse> response = client()
.investmentsHoldingsGet(request)
.execute();
assertSuccessResponse(response);
String accountId = null;
for (AccountBase account : response.body().getAccounts()) {
if (AccountType.INVESTMENT.equals(account.getType())) {
accountId = account.getAccountId();
break;
}
}
InvestmentHoldingsGetRequestOptions options = new InvestmentHoldingsGetRequestOptions()
.accountIds(Arrays.asList(accountId));
InvestmentsHoldingsGetRequest investmentsHoldingsGetRequest = new InvestmentsHoldingsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken())
.options(options);
Response<InvestmentsHoldingsGetResponse> investmentsHoldingsGetResponse = client()
.investmentsHoldingsGet(investmentsHoldingsGetRequest)
.execute();
assertSuccessResponse(investmentsHoldingsGetResponse);
// item should be the same one we created
assertItemEquals(
getItem(),
investmentsHoldingsGetResponse.body().getItem()
);
// sandbox should return expected accounts
List<AccountBase> accounts = investmentsHoldingsGetResponse
.body()
.getAccounts();
assertEquals(1, accounts.size());
}
@Test
public void testInvestmentsHoldingGetInvalidAccessToken() throws Exception {
InvestmentsHoldingsGetRequest investmentsHoldingsGetRequest = new InvestmentsHoldingsGetRequest()
.accessToken("notreal");
Response<InvestmentsHoldingsGetResponse> response = client()
.investmentsHoldingsGet(investmentsHoldingsGetRequest)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_ACCESS_TOKEN"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AssetReportAuditCopyGetTest.java | src/test/java/com/plaid/client/integration/AssetReportAuditCopyGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.AssetReportAuditCopyCreateRequest;
import com.plaid.client.model.AssetReportAuditCopyCreateResponse;
import com.plaid.client.model.AssetReportAuditCopyGetRequest;
import com.plaid.client.model.AssetReportCreateResponse;
import com.plaid.client.model.AssetReportGetResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class AssetReportAuditCopyGetTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.ASSETS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testAssetReportAuditCopyGetSuccess() throws Exception {
// Create asset report to get an asset report token
List<String> accessTokens = Arrays.asList(
getItemPublicTokenExchangeResponse().getAccessToken()
);
Response<AssetReportCreateResponse> createResponse = AssetReportCreateTest.createAssetReport(
client(),
accessTokens
);
String assetReportToken = createResponse.body().getAssetReportToken();
AssetReportGetTest.waitTillReady(client(), assetReportToken);
AssetReportAuditCopyCreateRequest request = new AssetReportAuditCopyCreateRequest()
.assetReportToken(assetReportToken)
.auditorId(System.getenv("PLAID_CLIENT_ID"));
Response<AssetReportAuditCopyCreateResponse> response = client()
.assetReportAuditCopyCreate(request)
.execute();
String auditCopyToken = response.body().getAuditCopyToken();
assertNotNull(auditCopyToken);
AssetReportAuditCopyGetRequest assetReportAuditCopyGetRequest = new AssetReportAuditCopyGetRequest()
.auditCopyToken(auditCopyToken);
Response<AssetReportGetResponse> auditCopyGetResponse = client()
.assetReportAuditCopyGet(assetReportAuditCopyGetRequest)
.execute();
// Validate the responses
AssetReportGetResponse respBody = auditCopyGetResponse.body();
assertSuccessResponse(auditCopyGetResponse);
assertNotNull(respBody.getReport());
assertNotNull(respBody.getReport().getUser());
assertFalse(respBody.getReport().getItems().isEmpty());
assertNotNull(respBody.getReport().getAssetReportId());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/PaymentCreateTest.java | src/test/java/com/plaid/client/integration/PaymentCreateTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.integration.RecipientCreateTest;
import com.plaid.client.model.PaymentAmount;
import com.plaid.client.model.PaymentAmountCurrency;
import com.plaid.client.model.PaymentInitiationPaymentCreateRequest;
import com.plaid.client.model.PaymentInitiationPaymentCreateResponse;
import com.plaid.client.model.PaymentInitiationPaymentCreateResponse;
import com.plaid.client.model.PaymentInitiationRecipientCreateResponse;
import com.plaid.client.request.PlaidApi;
import org.junit.Test;
import retrofit2.Response;
public class PaymentCreateTest extends AbstractIntegrationTest {
/**
* Utility method that creates a paymentinitiation.
* Used by other integration tests to set up.
*/
public static Response<PaymentInitiationPaymentCreateResponse> createPayment(
PlaidApi client
)
throws Exception {
Response<PaymentInitiationRecipientCreateResponse> createRecipientResponse = RecipientCreateTest.createRecipientWithIban(
client
);
String recipientId = createRecipientResponse.body().getRecipientId();
assertNotNull(recipientId);
PaymentAmount amount = new PaymentAmount()
.currency(PaymentAmountCurrency.GBP)
.value(999.99);
PaymentInitiationPaymentCreateRequest paymentCreateRequest = new PaymentInitiationPaymentCreateRequest()
.recipientId(recipientId)
.reference("reference")
.amount(amount);
Response<PaymentInitiationPaymentCreateResponse> response = client
.paymentInitiationPaymentCreate(paymentCreateRequest)
.execute();
return response;
}
@Test
public void testPaymentCreateSuccess() throws Exception {
Response<PaymentInitiationPaymentCreateResponse> response = createPayment(
client()
);
assertSuccessResponse(response);
assertNotNull(response.body().getPaymentId());
assertNotNull(response.body().getStatus());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/TransactionsRefreshTest.java | src/test/java/com/plaid/client/integration/TransactionsRefreshTest.java | package com.plaid.client.integration;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.Products;
import com.plaid.client.model.TransactionsRefreshRequest;
import com.plaid.client.model.TransactionsRefreshResponse;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class TransactionsRefreshTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Collections.singletonList(Products.TRANSACTIONS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testSuccess() throws Exception {
TransactionsRefreshRequest request = new TransactionsRefreshRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<TransactionsRefreshResponse> response = client()
.transactionsRefresh(request)
.execute();
assertSuccessResponse(response);
}
@Test
public void testInvalidAccessKey() throws Exception {
TransactionsRefreshRequest request = new TransactionsRefreshRequest()
.accessToken("Bad Token");
Response<TransactionsRefreshResponse> response = client()
.transactionsRefresh(request)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_ACCESS_TOKEN"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/LiabilitiesGetTest.java | src/test/java/com/plaid/client/integration/LiabilitiesGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.model.APR;
import com.plaid.client.model.AccountBase;
import com.plaid.client.model.AccountSubtype;
import com.plaid.client.model.CreditCardLiability;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.LiabilitiesGetRequest;
import com.plaid.client.model.LiabilitiesGetRequestOptions;
import com.plaid.client.model.LiabilitiesGetResponse;
import com.plaid.client.model.LiabilitiesObject;
import com.plaid.client.model.Products;
import com.plaid.client.model.Security;
import com.plaid.client.model.StudentLoan;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Ignore;
import org.junit.Test;
import retrofit2.Response;
public class LiabilitiesGetTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Collections.singletonList(Products.LIABILITIES);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testLiabilitiesStudentLoanGetSuccess() throws Exception {
LiabilitiesGetRequest request = new LiabilitiesGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<LiabilitiesGetResponse> response = client()
.liabilitiesGet(request)
.execute();
assertSuccessResponse(response);
// item should be the same one we created
assertItemEquals(getItem(), response.body().getItem());
// sandbox should return expected student loan liabilities
LiabilitiesObject liabilities = response.body().getLiabilities();
List<StudentLoan> studentLoans = liabilities.getStudent();
assertTrue(studentLoans.size() > 0);
for (StudentLoan studentLoan : studentLoans) {
assertNotNull(studentLoan.getAccountId());
assertNotNull(studentLoan.getAccountNumber());
assertNotNull(studentLoan.getDisbursementDates());
assertNotNull(studentLoan.getExpectedPayoffDate());
assertNotNull(studentLoan.getGuarantor());
assertNotNull(studentLoan.getInterestRatePercentage());
assertNotNull(studentLoan.getIsOverdue());
assertNotNull(studentLoan.getLastPaymentAmount());
assertNotNull(studentLoan.getLastPaymentDate());
assertNotNull(studentLoan.getLastStatementIssueDate());
assertNotNull(studentLoan.getLoanName());
assertNotNull(studentLoan.getLoanStatus());
assertNotNull(studentLoan.getLoanStatus().getEndDate());
assertNotNull(studentLoan.getLoanStatus().getType());
assertNotNull(studentLoan.getMinimumPaymentAmount());
assertNotNull(studentLoan.getNextPaymentDueDate());
assertNotNull(studentLoan.getOriginationDate());
assertNotNull(studentLoan.getOriginationPrincipalAmount());
assertNotNull(studentLoan.getOutstandingInterestAmount());
assertNotNull(studentLoan.getPaymentReferenceNumber());
assertNotNull(studentLoan.getPslfStatus());
assertNotNull(studentLoan.getPslfStatus().getEstimatedEligibilityDate());
assertNotNull(studentLoan.getPslfStatus().getPaymentsMade());
assertNotNull(studentLoan.getPslfStatus().getPaymentsRemaining());
assertNotNull(studentLoan.getRepaymentPlan());
assertNotNull(studentLoan.getRepaymentPlan().getDescription());
assertNotNull(studentLoan.getRepaymentPlan().getType());
assertNotNull(studentLoan.getSequenceNumber());
assertNotNull(studentLoan.getServicerAddress());
assertNotNull(studentLoan.getServicerAddress().getCity());
assertNotNull(studentLoan.getServicerAddress().getCountry());
assertNotNull(studentLoan.getServicerAddress().getRegion());
assertNotNull(studentLoan.getServicerAddress().getStreet());
assertNotNull(studentLoan.getServicerAddress().getPostalCode());
assertNotNull(studentLoan.getYtdInterestPaid());
assertNotNull(studentLoan.getYtdPrincipalPaid());
}
}
@Test
public void testLiabilitiesCreditCardGetSuccess() throws Exception {
LiabilitiesGetRequest request = new LiabilitiesGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<LiabilitiesGetResponse> response = client()
.liabilitiesGet(request)
.execute();
assertSuccessResponse(response);
// item should be the same one we created
assertItemEquals(getItem(), response.body().getItem());
// sandbox should return expected credit card liabilities
LiabilitiesObject liabilities = response.body().getLiabilities();
List<CreditCardLiability> creditCards = liabilities.getCredit();
assertTrue(creditCards.size() > 0);
for (CreditCardLiability creditCard : creditCards) {
List<APR> aprs = creditCard.getAprs();
assertNotNull(aprs);
for (APR apr : aprs) {
assertNotNull(apr.getAprPercentage());
assertNotNull(apr.getAprType());
assertNotNull(apr.getBalanceSubjectToApr());
assertNotNull(apr.getInterestChargeAmount());
}
assertNotNull(creditCard.getAccountId());
assertNotNull(creditCard.getIsOverdue());
assertNotNull(creditCard.getLastPaymentAmount());
assertNotNull(creditCard.getLastPaymentDate());
assertNotNull(creditCard.getLastStatementIssueDate());
assertNotNull(creditCard.getMinimumPaymentAmount());
assertNotNull(creditCard.getNextPaymentDueDate());
}
}
@Test
public void testLiabilitiesGetWithAccountIds() throws Exception {
// first call to get an account ID
LiabilitiesGetRequest request = new LiabilitiesGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<LiabilitiesGetResponse> response = client()
.liabilitiesGet(request)
.execute();
assertSuccessResponse(response);
String accountId = null;
for (AccountBase account : response.body().getAccounts()) {
if (AccountSubtype.STUDENT.equals(account.getSubtype())) {
accountId = account.getAccountId();
break;
}
}
// call under test
LiabilitiesGetRequestOptions options = new LiabilitiesGetRequestOptions()
.accountIds(Arrays.asList(accountId));
LiabilitiesGetRequest liabilitiesGetRequest = new LiabilitiesGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken())
.options(options);
Response<LiabilitiesGetResponse> liabilitiesGetResponse = client()
.liabilitiesGet(liabilitiesGetRequest)
.execute();
response = client().liabilitiesGet(liabilitiesGetRequest).execute();
assertSuccessResponse(response);
// item should be the same one we created
assertItemEquals(getItem(), response.body().getItem());
// sandbox should return expected accounts
List<AccountBase> accounts = response.body().getAccounts();
assertEquals(1, accounts.size());
}
@Test
public void testLiabilitiesGetInvalidAccessToken() throws Exception {
LiabilitiesGetRequest request = new LiabilitiesGetRequest()
.accessToken("not-real");
Response<LiabilitiesGetResponse> response = client()
.liabilitiesGet(request)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_ACCESS_TOKEN"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/CategoriesGetTest.java | src/test/java/com/plaid/client/integration/CategoriesGetTest.java | package com.plaid.client.integration;
// Empty class for constructing request
import com.plaid.client.model.Category;
import com.plaid.client.model.CategoriesGetResponse;
import org.junit.Test;
import retrofit2.Response;
import java.util.Arrays;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
public class CategoriesGetTest extends AbstractIntegrationTest {
@Test
public void testSuccess() throws Exception {
Response<CategoriesGetResponse> response = client().categoriesGet(new Object()).execute();
assertSuccessResponse(response);
assertFalse(response.body().getCategories().isEmpty());
Category category = response.body().getCategories().get(0);
assertEquals("10000000", category.getCategoryId());
assertEquals("special", category.getGroup());
assertEquals(Arrays.asList("Bank Fees"), category.getHierarchy());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AssetReportAuditCopyRemoveTest.java | src/test/java/com/plaid/client/integration/AssetReportAuditCopyRemoveTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertTrue;
// import com.plaid.client.PlaidClient;
import com.plaid.client.model.AssetReportAuditCopyCreateRequest;
import com.plaid.client.model.AssetReportAuditCopyCreateResponse;
import com.plaid.client.model.AssetReportAuditCopyRemoveRequest;
import com.plaid.client.model.AssetReportAuditCopyRemoveResponse;
import com.plaid.client.model.AssetReportCreateResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class AssetReportAuditCopyRemoveTest
extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.ASSETS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testAssetReportAuditCopyRemoveSuccess() throws Exception {
// Create asset report to get an asset report token
List<String> accessTokens = Arrays.asList(
getItemPublicTokenExchangeResponse().getAccessToken()
);
Response<AssetReportCreateResponse> createResponse = AssetReportCreateTest.createAssetReport(
client(),
accessTokens
);
String assetReportToken = createResponse.body().getAssetReportToken();
AssetReportGetTest.waitTillReady(client(), assetReportToken);
AssetReportAuditCopyCreateRequest auditCopyCreateRequest = new AssetReportAuditCopyCreateRequest()
.assetReportToken(assetReportToken)
.auditorId("fannie_mae");
Response<AssetReportAuditCopyCreateResponse> auditCopyCreateResponse = client()
.assetReportAuditCopyCreate(auditCopyCreateRequest)
.execute();
String auditCopyToken = auditCopyCreateResponse.body().getAuditCopyToken();
AssetReportAuditCopyRemoveRequest request = new AssetReportAuditCopyRemoveRequest()
.auditCopyToken(auditCopyToken);
Response<AssetReportAuditCopyRemoveResponse> response = client()
.assetReportAuditCopyRemove(request)
.execute();
assertTrue(response.body().getRemoved());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AssetReportRefreshTest.java | src/test/java/com/plaid/client/integration/AssetReportRefreshTest.java | package com.plaid.client.integration;
import static com.plaid.client.integration.AssetReportGetTest.waitTillReady;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.AssetReportCreateRequest;
import com.plaid.client.model.AssetReportCreateResponse;
import com.plaid.client.model.AssetReportFilterRequest;
import com.plaid.client.model.AssetReportGetResponse;
import com.plaid.client.model.AssetReportItem;
import com.plaid.client.model.AssetReportItem;
import com.plaid.client.model.AssetReportRefreshRequest;
import com.plaid.client.model.AssetReportRefreshRequestOptions;
import com.plaid.client.model.AssetReportRefreshResponse;
import com.plaid.client.model.AssetReportUser;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.junit.Test;
import retrofit2.Response;
public class AssetReportRefreshTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.ASSETS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
private Response<AssetReportRefreshResponse> assetReportRefresh(
AssetReportRefreshRequest assetReportRefreshRequest
)
throws Exception {
Response<AssetReportRefreshResponse> response = client()
.assetReportRefresh(assetReportRefreshRequest)
.execute();
return response;
}
@Test
public void testAssetReportRefreshSuccessNoOverrideOptions()
throws Exception {
// Create asset report to get an asset report token
List<String> accessTokens = Arrays.asList(
getItemPublicTokenExchangeResponse().getAccessToken()
);
Response<AssetReportCreateResponse> createResponse = AssetReportCreateTest.createAssetReport(
client(),
accessTokens
);
String assetReportToken = createResponse.body().getAssetReportToken();
// Wait till asset report is ready
Response<AssetReportGetResponse> response = waitTillReady(
client(),
assetReportToken
);
// Validate the responses
AssetReportGetResponse respBody = response.body();
assertSuccessResponse(response);
assertNotNull(respBody.getReport());
assertNotNull(respBody.getReport().getUser());
assertFalse(respBody.getReport().getItems().isEmpty());
assertNotNull(respBody.getReport().getAssetReportId());
AssetReportRefreshRequest assetReportRefreshRequest = new AssetReportRefreshRequest()
.assetReportToken(assetReportToken);
Response<AssetReportRefreshResponse> assetReportRefreshResponse = assetReportRefresh(
assetReportRefreshRequest
);
Response<AssetReportGetResponse> assetReportGetResponse = waitTillReady(
client(),
assetReportRefreshResponse.body().getAssetReportToken()
);
assertEquals(
response.body().getReport().getUser(),
assetReportGetResponse.body().getReport().getUser()
);
Set<AssetReportItem> originalItems = new HashSet<>(
response.body().getReport().getItems()
);
Set<AssetReportItem> refreshItems = new HashSet<>(
assetReportGetResponse.body().getReport().getItems()
);
assertEquals(originalItems.size(), refreshItems.size());
}
@Test
public void testAssetReportRefreshSuccessWithOverride() throws Exception {
// Create asset report to get an asset report token
List<String> accessTokens = Arrays.asList(
getItemPublicTokenExchangeResponse().getAccessToken()
);
Response<AssetReportCreateResponse> createResponse = AssetReportCreateTest.createAssetReport(
client(),
accessTokens
);
String assetReportToken = createResponse.body().getAssetReportToken();
// Wait till asset report is ready
Response<AssetReportGetResponse> response = waitTillReady(
client(),
assetReportToken
);
// Validate the responses
AssetReportGetResponse respBody = response.body();
assertSuccessResponse(response);
assertNotNull(respBody.getReport());
assertNotNull(respBody.getReport().getUser());
assertFalse(respBody.getReport().getItems().isEmpty());
assertNotNull(respBody.getReport().getAssetReportId());
AssetReportUser assetReportUser = new AssetReportUser()
.lastName("newLastName");
AssetReportRefreshRequestOptions options = new AssetReportRefreshRequestOptions()
.user(assetReportUser);
AssetReportRefreshRequest assetReportRefreshRequest = new AssetReportRefreshRequest()
.options(options)
.assetReportToken(assetReportToken);
Response<AssetReportRefreshResponse> assetReportCreateRefreshResponse = assetReportRefresh(
assetReportRefreshRequest
);
Response<AssetReportGetResponse> assetReportRefreshGetResponse = waitTillReady(
client(),
assetReportCreateRefreshResponse.body().getAssetReportToken()
);
Set<AssetReportItem> originalItems = new HashSet<>(
response.body().getReport().getItems()
);
Set<AssetReportItem> refreshItems = new HashSet<>(
assetReportRefreshGetResponse.body().getReport().getItems()
);
assertEquals(originalItems.size(), refreshItems.size());
AssetReportUser originalUser = response.body().getReport().getUser();
AssetReportUser refreshedUser = assetReportRefreshGetResponse
.body()
.getReport()
.getUser();
assertEquals(
originalUser.getClientUserId(),
refreshedUser.getClientUserId()
);
assertEquals(originalUser.getEmail(), refreshedUser.getEmail());
assertEquals(originalUser.getFirstName(), refreshedUser.getFirstName());
assertEquals(originalUser.getMiddleName(), refreshedUser.getMiddleName());
assertEquals(originalUser.getPhoneNumber(), refreshedUser.getPhoneNumber());
assertEquals(originalUser.getSsn(), refreshedUser.getSsn());
assertEquals("newLastName", refreshedUser.getLastName());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AuthGetTest.java | src/test/java/com/plaid/client/integration/AuthGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import com.plaid.client.model.AccountsGetRequest;
import com.plaid.client.model.AccountsGetResponse;
import com.plaid.client.model.AuthGetNumbers;
import com.plaid.client.model.AuthGetRequest;
import com.plaid.client.model.AuthGetRequestOptions;
import com.plaid.client.model.AuthGetResponse;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.NumbersACH;
import com.plaid.client.model.NumbersBACS;
import com.plaid.client.model.NumbersEFT;
import com.plaid.client.model.NumbersInternational;
import com.plaid.client.model.Products;
import java.util.Collections;
import java.util.List;
import org.junit.Ignore;
import org.junit.Test;
import retrofit2.Response;
public class AuthGetTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Collections.singletonList(Products.AUTH);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testAllAccountsSuccess() throws Exception {
AuthGetRequest authGetRequest = new AuthGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<AuthGetResponse> response = client()
.authGet(authGetRequest)
.execute();
assertSuccessResponse(response);
assertTrue(response.body().getAccounts().size() > 1);
assertNotNull(response.body().getItem());
for (NumbersACH numberACH : response.body().getNumbers().getAch()) {
assertNotNull(numberACH.getAccount());
assertNotNull(numberACH.getRouting());
assertNotNull(numberACH.getAccountId());
assertNotNull(numberACH.getWireRouting());
}
// The sandbox data that is returned only has ACH numbers so this doesn't actually do anything
for (NumbersEFT numberEFT : response.body().getNumbers().getEft()) {
assertNotNull(numberEFT.getAccount());
assertNotNull(numberEFT.getBranch());
assertNotNull(numberEFT.getInstitution());
assertNotNull(numberEFT.getAccountId());
}
// The sandbox data that is returned only has ACH numbers so this doesn't actually do anything
for (NumbersInternational numberInternational : response
.body()
.getNumbers()
.getInternational()) {
assertNotNull(numberInternational.getIban());
assertNotNull(numberInternational.getBic());
assertNotNull(numberInternational.getAccountId());
}
// The sandbox data that is returned only has ACH numbers so this doesn't actually do anything
for (NumbersBACS numberBACS : response.body().getNumbers().getBacs()) {
assertNotNull(numberBACS.getAccountId());
assertNotNull(numberBACS.getAccount());
assertNotNull(numberBACS.getSortCode());
}
}
@Test
public void testSelectiveAccountSuccess() throws Exception {
// first call to get an account ID
AccountsGetRequest accountsGetRequest = new AccountsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<AccountsGetResponse> accountsGetResponse = client().accountsGet(accountsGetRequest).execute();
assertSuccessResponse(accountsGetResponse);
String accountId = accountsGetResponse.body().getAccounts().get(1).getAccountId();
// call under test
AuthGetRequest authGetRequest = new AuthGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
AuthGetRequestOptions authGetRequestOptions = new AuthGetRequestOptions()
.accountIds(Collections.singletonList(accountId));
authGetRequest.options(authGetRequestOptions);
Response<AuthGetResponse> response = client().authGet(authGetRequest).execute();
assertSuccessResponse(response);
List<NumbersACH> achList = response.body().getNumbers().getAch();
assertNotNull(achList);
assertEquals(1, achList.size());
assertEquals(accountId, achList.get(0).getAccountId());
assertEquals("1111222233331111", achList.get(0).getAccount());
assertEquals("011401533", achList.get(0).getRouting());
assertEquals("021000021", achList.get(0).getWireRouting());
}
@Test
public void testNoSuchTokenError() throws Exception {
AuthGetRequest authGetRequest = new AuthGetRequest()
.accessToken("bad-access-token");
Response<AuthGetResponse> response = client()
.authGet(authGetRequest)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_ACCESS_TOKEN"
);
}
@Test
public void testNoSuchAccountError() throws Exception {
AuthGetRequest authGetRequestErr = new AuthGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
AuthGetRequestOptions authGetRequestOptions = new AuthGetRequestOptions()
.accountIds(Collections.singletonList("fake-not-real"));
authGetRequestErr.options(authGetRequestOptions);
Response<AuthGetResponse> authResponse = client()
.authGet(authGetRequestErr)
.execute();
assertErrorResponse(
authResponse,
PlaidErrorType.INVALID_REQUEST,
"INVALID_FIELD"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AccountsGetTest.java | src/test/java/com/plaid/client/integration/AccountsGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.model.AccountBase;
import com.plaid.client.model.AccountSubtype;
import com.plaid.client.model.AccountType;
import com.plaid.client.model.AccountsGetRequest;
import com.plaid.client.model.AccountsGetRequestOptions;
import com.plaid.client.model.AccountsGetResponse;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Ignore;
import org.junit.Test;
import retrofit2.Response;
public class AccountsGetTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Collections.singletonList(Products.TRANSACTIONS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testAccountsGetSuccess() throws Exception {
AccountsGetRequest request = new AccountsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<AccountsGetResponse> response = client()
.accountsGet(request)
.execute();
assertSuccessResponse(response);
// item should be the same one we created
assertItemEquals(getItem(), response.body().getItem());
// sandbox should return expected accounts
List<AccountBase> accounts = response.body().getAccounts();
assertTrue(accounts.size() > 1);
assertAccount(
accounts.get(0),
AccountType.DEPOSITORY,
AccountSubtype.CHECKING,
100d,
110d,
null,
"Plaid Checking",
"0000",
"Plaid Gold Standard 0% Interest Checking"
);
assertAccount(
accounts.get(1),
AccountType.DEPOSITORY,
AccountSubtype.SAVINGS,
200d,
210d,
null,
"Plaid Saving",
"1111",
"Plaid Silver Standard 0.1% Interest Saving"
);
assertAccount(
accounts.get(2),
AccountType.DEPOSITORY,
AccountSubtype.CD,
null,
1000d,
null,
"Plaid CD",
"2222",
"Plaid Bronze Standard 0.2% Interest CD"
);
assertAccount(
accounts.get(3),
AccountType.CREDIT,
AccountSubtype.CREDIT_CARD,
null,
410d,
2000d,
"Plaid Credit Card",
"3333",
"Plaid Diamond 12.5% APR Interest Credit Card"
);
}
@Test
public void testAccountGetWithAccountId() throws Exception {
// first call to get an account ID
AccountsGetRequest request = new AccountsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<AccountsGetResponse> response = client()
.accountsGet(request)
.execute();
assertSuccessResponse(response);
String accountId = response.body().getAccounts().get(1).getAccountId();
// call under test
AccountsGetRequest accountsGetRequest = new AccountsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
AccountsGetRequestOptions options = new AccountsGetRequestOptions()
.accountIds(Arrays.asList(accountId));
accountsGetRequest.setOptions(options);
response = client().accountsGet(accountsGetRequest).execute();
assertSuccessResponse(response);
// item should be the same one we created
assertItemEquals(getItem(), response.body().getItem());
// sandbox should return expected accounts
List<AccountBase> accounts = response.body().getAccounts();
assertEquals(1, accounts.size());
assertAccount(
accounts.get(0),
AccountType.DEPOSITORY,
AccountSubtype.SAVINGS,
200d,
210d,
null,
"Plaid Saving",
"1111",
"Plaid Silver Standard 0.1% Interest Saving"
);
}
@Test
public void testAccountGetInvalidAccountId() throws Exception {
AccountsGetRequest accountsGetRequest = new AccountsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
AccountsGetRequestOptions options = new AccountsGetRequestOptions()
.accountIds(Arrays.asList("not-real"));
accountsGetRequest.setOptions(options);
Response<AccountsGetResponse> response = client()
.accountsGet(accountsGetRequest)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_REQUEST,
"INVALID_FIELD"
);
}
@Test
public void testAccountGetInvalidAccessToken() throws Exception {
AccountsGetRequest accountsGetRequest = new AccountsGetRequest()
.accessToken("notreal");
Response<AccountsGetResponse> response = client()
.accountsGet(accountsGetRequest)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_ACCESS_TOKEN"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/RecipientGetTest.java | src/test/java/com/plaid/client/integration/RecipientGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.integration.RecipientCreateTest;
import com.plaid.client.model.PaymentInitiationRecipientCreateResponse;
import com.plaid.client.model.PaymentInitiationRecipientGetRequest;
import com.plaid.client.model.PaymentInitiationRecipientGetResponse;
import java.util.Arrays;
import org.junit.Test;
import retrofit2.Response;
public class RecipientGetTest extends AbstractIntegrationTest {
@Test
public void testRecipientGetSuccessWithIban() throws Exception {
Response<PaymentInitiationRecipientCreateResponse> createRecipientResponse = RecipientCreateTest.createRecipientWithIban(
client()
);
String recipientId = createRecipientResponse.body().getRecipientId();
assertNotNull(recipientId);
PaymentInitiationRecipientGetRequest request = new PaymentInitiationRecipientGetRequest()
.recipientId(recipientId);
Response<PaymentInitiationRecipientGetResponse> getRecipientResponse = client()
.paymentInitiationRecipientGet(request)
.execute();
assertSuccessResponse(getRecipientResponse);
assertNotNull(getRecipientResponse.body().getRecipientId());
assertNotNull(getRecipientResponse.body().getName());
assertNotNull(getRecipientResponse.body().getIban());
assertNotNull(getRecipientResponse.body().getAddress());
}
@Test
public void testRecipientGetSuccessWithBacs() throws Exception {
Response<PaymentInitiationRecipientCreateResponse> createRecipientResponse = RecipientCreateTest.createRecipientWithBacs(
client()
);
String recipientId = createRecipientResponse.body().getRecipientId();
assertNotNull(recipientId);
PaymentInitiationRecipientGetRequest request = new PaymentInitiationRecipientGetRequest()
.recipientId(recipientId);
Response<PaymentInitiationRecipientGetResponse> getRecipientResponse = client()
.paymentInitiationRecipientGet(request)
.execute();
assertSuccessResponse(getRecipientResponse);
assertNotNull(getRecipientResponse.body().getRecipientId());
assertNotNull(getRecipientResponse.body().getName());
assertNotNull(getRecipientResponse.body().getBacs());
assertNotNull(getRecipientResponse.body().getAddress());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/InstitutionsGetByIdTest.java | src/test/java/com/plaid/client/integration/InstitutionsGetByIdTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.model.CountryCode;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.Institution;
import com.plaid.client.model.InstitutionsGetByIdRequest;
import com.plaid.client.model.InstitutionsGetByIdRequestOptions;
import com.plaid.client.model.InstitutionsGetByIdResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.HashSet;
import org.junit.Test;
import retrofit2.Response;
public class InstitutionsGetByIdTest extends AbstractIntegrationTest {
@Test
public void testSuccess() throws Exception {
InstitutionsGetByIdRequest request = new InstitutionsGetByIdRequest()
.institutionId(TARTAN_BANK_INSTITUTION_ID)
.addCountryCodesItem(CountryCode.US);
Response<InstitutionsGetByIdResponse> response = client()
.institutionsGetById(request)
.execute();
assertSuccessResponse(response);
Institution institution = response.body().getInstitution();
assertIsTartanBank(institution);
}
@Test
public void testSuccessWithIncludeOptionalMetadataTrue() throws Exception {
InstitutionsGetByIdRequestOptions options = new InstitutionsGetByIdRequestOptions();
options.includeOptionalMetadata(true);
InstitutionsGetByIdRequest request = new InstitutionsGetByIdRequest()
.institutionId(TARTAN_BANK_INSTITUTION_ID)
.addCountryCodesItem(CountryCode.US)
.options(options);
Response<InstitutionsGetByIdResponse> response = client()
.institutionsGetById(request)
.execute();
assertSuccessResponse(response);
Institution institution = response.body().getInstitution();
assertIsTartanBank(institution);
assertEquals("https://www.plaid.com/", institution.getUrl());
assertNotNull(institution.getLogo());
assertEquals("#174e7c", institution.getPrimaryColor());
}
@Test
public void testSuccessWithIncludeOptionalMetadataFalse() throws Exception {
InstitutionsGetByIdRequestOptions options = new InstitutionsGetByIdRequestOptions();
options.includeOptionalMetadata(false);
InstitutionsGetByIdRequest request = new InstitutionsGetByIdRequest()
.institutionId(TARTAN_BANK_INSTITUTION_ID)
.addCountryCodesItem(CountryCode.US)
.options(options);
Response<InstitutionsGetByIdResponse> response = client()
.institutionsGetById(request)
.execute();
assertSuccessResponse(response);
Institution institution = response.body().getInstitution();
assertIsTartanBank(institution);
assertEquals(null, institution.getUrl());
assertEquals(null, institution.getLogo());
assertEquals(null, institution.getPrimaryColor());
}
@Test
public void testSuccessWithIncludeStatusTrue() throws Exception {
InstitutionsGetByIdRequestOptions options = new InstitutionsGetByIdRequestOptions();
options.includeStatus(true);
InstitutionsGetByIdRequest request = new InstitutionsGetByIdRequest()
.institutionId(FIRST_PLATYPUS_BANK_INSTITUTION_ID)
.addCountryCodesItem(CountryCode.US)
.options(options);
Response<InstitutionsGetByIdResponse> response = client()
.institutionsGetById(request)
.execute();
assertSuccessResponse(response);
Institution institution = response.body().getInstitution();
assertNotNull(institution.getStatus());
assertNotNull(institution.getStatus().getTransactionsUpdates());
assertNotNull(institution.getStatus().getAuth());
assertNotNull(institution.getStatus().getIdentity());
assertIsFirstPlatypusBank(institution);
}
@Test
public void testSuccessWithIncludeStatusFalse() throws Exception {
InstitutionsGetByIdRequestOptions options = new InstitutionsGetByIdRequestOptions();
options.includeStatus(false);
InstitutionsGetByIdRequest request = new InstitutionsGetByIdRequest()
.institutionId(TARTAN_BANK_INSTITUTION_ID)
.addCountryCodesItem(CountryCode.US)
.options(options);
Response<InstitutionsGetByIdResponse> response = client()
.institutionsGetById(request)
.execute();
assertSuccessResponse(response);
Institution institution = response.body().getInstitution();
assertNull(institution.getStatus());
assertIsTartanBank(institution);
}
private void assertIsTartanBank(Institution institution) {
assertEquals(TARTAN_BANK_INSTITUTION_ID, institution.getInstitutionId());
assertEquals("Tartan Bank", institution.getName());
assertFalse(
institution.getProducts().contains(Products.ENUM_UNKNOWN)
);
assertTrue(institution.getCountryCodes().contains(CountryCode.US));
}
private void assertIsFirstPlatypusBank(Institution institution) {
assertEquals(
FIRST_PLATYPUS_BANK_INSTITUTION_ID,
institution.getInstitutionId()
);
assertTrue(institution.getName().contains("First Platypus Bank"));
assertFalse(
institution.getProducts().contains(Products.ENUM_UNKNOWN)
);
assertTrue(institution.getCountryCodes().contains(CountryCode.US));
}
@Test
public void testInvalidInstitution() throws Exception {
InstitutionsGetByIdRequest request = new InstitutionsGetByIdRequest()
.institutionId("notreal")
.addCountryCodesItem(CountryCode.US);
Response<InstitutionsGetByIdResponse> response = client()
.institutionsGetById(request)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_INSTITUTION"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/IdentityGetTest.java | src/test/java/com/plaid/client/integration/IdentityGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.AccountIdentity;
import com.plaid.client.model.Address;
import com.plaid.client.model.Email;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.IdentityGetRequest;
import com.plaid.client.model.IdentityGetResponse;
import com.plaid.client.model.Owner;
import com.plaid.client.model.PhoneNumber;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class IdentityGetTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.IDENTITY);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testSuccess() throws Exception {
IdentityGetRequest identityGetRequest = new IdentityGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<IdentityGetResponse> response = client()
.identityGet(identityGetRequest)
.execute();
assertSuccessResponse(response);
assertFalse(response.body().getAccounts().isEmpty());
assertNotNull(response.body().getItem());
List<AccountIdentity> accounts = response.body().getAccounts();
assertNotNull(accounts);
for (AccountIdentity account : accounts) {
List<Owner> owners = account.getOwners();
assertFalse(owners.isEmpty());
for (Owner owner : owners) {
assertNotNull(owner);
assertFalse(owner.getNames().isEmpty());
assertFalse(owner.getEmails().isEmpty());
assertFalse(owner.getAddresses().isEmpty());
assertFalse(owner.getPhoneNumbers().isEmpty());
for (Email email : owner.getEmails()) {
assertNotNull(email.getData());
assertNotNull(email.getType());
assertNotNull(email.getPrimary());
}
for (Address address : owner.getAddresses()) {
assertNotNull(address.getPrimary());
assertNotNull(address.getData());
assertNotNull(address.getData().getStreet());
assertNotNull(address.getData().getCity());
assertNotNull(address.getData().getRegion());
assertNotNull(address.getData().getPostalCode());
// assertNotNull(address.getData().getCountry());
}
for (PhoneNumber phoneNumber : owner.getPhoneNumbers()) {
assertNotNull(phoneNumber.getData());
assertNotNull(phoneNumber.getType());
assertNotNull(phoneNumber.getPrimary());
}
}
}
}
@Test
public void testFailure() throws Exception {
IdentityGetRequest identityGetRequest = new IdentityGetRequest()
.accessToken("made-up-token");
Response<IdentityGetResponse> response = client()
.identityGet(identityGetRequest)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_ACCESS_TOKEN"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/RecipientCreateTest.java | src/test/java/com/plaid/client/integration/RecipientCreateTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.request.PlaidApi;
import com.plaid.client.model.RecipientBACSNullable;
import com.plaid.client.model.PaymentInitiationAddress;
import com.plaid.client.model.PaymentInitiationRecipientCreateRequest;
import com.plaid.client.model.PaymentInitiationRecipientCreateResponse;
import java.util.Arrays;
import org.junit.Test;
import retrofit2.Response;
public class RecipientCreateTest extends AbstractIntegrationTest {
/**
* Utility method that creates a payment recipient with an iban. Used by other integration tests
* to set up.
*/
public static Response<PaymentInitiationRecipientCreateResponse> createRecipientWithIban(
PlaidApi client
)
throws Exception {
PaymentInitiationAddress address = new PaymentInitiationAddress()
.street(Arrays.asList("Street Name 999"))
.city("City")
.postalCode("99999")
.country("GB");
PaymentInitiationRecipientCreateRequest recipientCreateRequest = new PaymentInitiationRecipientCreateRequest()
.name("John Doe")
.iban("GB33BUKB20201555555555")
.address(address);
Response<PaymentInitiationRecipientCreateResponse> response = client
.paymentInitiationRecipientCreate(recipientCreateRequest)
.execute();
return response;
}
/**
* Utility method that creates a payment recipient with bacs. Used by other integration tests to
* set up.
*/
public static Response<PaymentInitiationRecipientCreateResponse> createRecipientWithBacs(
PlaidApi client
)
throws Exception {
PaymentInitiationAddress address = new PaymentInitiationAddress()
.street(Arrays.asList("Street Name 999"))
.city("City")
.postalCode("99999")
.country("GB");
RecipientBACSNullable bacs = new RecipientBACSNullable()
.account("26207729")
.sortCode("560029");
PaymentInitiationRecipientCreateRequest recipientCreateRequest = new PaymentInitiationRecipientCreateRequest()
.name("John Doe")
.bacs(bacs)
.address(address);
Response<PaymentInitiationRecipientCreateResponse> response = client
.paymentInitiationRecipientCreate(recipientCreateRequest)
.execute();
return response;
}
public static Response<PaymentInitiationRecipientCreateResponse> createRecipientWithBacsAndIban(
PlaidApi client
)
throws Exception {
PaymentInitiationAddress address = new PaymentInitiationAddress()
.street(Arrays.asList("Street Name 999"))
.city("City")
.postalCode("99999")
.country("GB");
RecipientBACSNullable bacs = new RecipientBACSNullable()
.account("26207729")
.sortCode("560029");
PaymentInitiationRecipientCreateRequest recipientCreateRequest = new PaymentInitiationRecipientCreateRequest()
.name("John Doe")
.bacs(bacs)
.iban("GB33BUKB20201555555555")
.address(address);
Response<PaymentInitiationRecipientCreateResponse> response = client
.paymentInitiationRecipientCreate(recipientCreateRequest)
.execute();
return response;
}
@Test
public void testRecipientCreateSuccessWithIban() throws Exception {
Response<PaymentInitiationRecipientCreateResponse> response = createRecipientWithIban(
client()
);
assertSuccessResponse(response);
assertNotNull(response.body().getRecipientId());
}
@Test
public void testRecipientCreateSuccessWithBacs() throws Exception {
Response<PaymentInitiationRecipientCreateResponse> response = createRecipientWithBacs(
client()
);
assertSuccessResponse(response);
assertNotNull(response.body().getRecipientId());
}
@Test
public void testRecipientCreateSuccessWithBacsAndIban() throws Exception {
Response<PaymentInitiationRecipientCreateResponse> response = createRecipientWithBacsAndIban(
client()
);
assertSuccessResponse(response);
assertNotNull(response.body().getRecipientId());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/IdentityVerificationTest.java | src/test/java/com/plaid/client/integration/IdentityVerificationTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.AccountIdentity;
import com.plaid.client.model.Address;
import com.plaid.client.model.Email;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.IdentityVerificationGetRequest;
import com.plaid.client.model.IdentityVerificationCreateRequest;
import com.plaid.client.model.IdentityVerificationGetResponse;
import com.plaid.client.model.IdentityVerificationCreateResponse;
import com.plaid.client.model.IdentityVerificationCreateRequestUser;
import com.plaid.client.model.IdentityVerificationRequestUser;
import com.plaid.client.model.IdentityVerificationRetryRequest;
import com.plaid.client.model.IdentityVerificationRetryResponse;
import com.plaid.client.model.IdentityVerificationListRequest;
import com.plaid.client.model.IdentityVerificationListResponse;
import com.plaid.client.model.IdentityVerification;
import com.plaid.client.model.Strategy;
import java.time.Instant;
import java.util.Arrays;
import java.util.List;
import org.junit.Ignore;
import org.junit.Test;
import retrofit2.Response;
import java.time.OffsetDateTime;
public class IdentityVerificationTest extends AbstractIntegrationTest {
private static final String TEMPLATE_ID = "flwtmp_aWogUuKsL6NEHU";
@Ignore
@Test
public void testSuccess() throws Exception {
// customerReference is used to build `email` but the ISO8601 timestamp that is created from
// Instant.now() contains a ':' which is not allowed in email addresses so we remove it.
String customerReference = "idv-user-" + Instant.now().toString().replace(":", "");
String email = customerReference + "@example.com";
// POST /identity_verification/create
IdentityVerificationCreateRequestUser user = new IdentityVerificationCreateRequestUser();
user.setEmailAddress(email);
IdentityVerificationCreateRequest identityVerificationCreateRequest = new IdentityVerificationCreateRequest();
identityVerificationCreateRequest.setClientUserId(customerReference);
identityVerificationCreateRequest.setIsShareable(true);
identityVerificationCreateRequest.setTemplateId(TEMPLATE_ID);
identityVerificationCreateRequest.setGaveConsent(true);
identityVerificationCreateRequest.setClientId(customerReference);
identityVerificationCreateRequest.setUser(user);
Response<IdentityVerificationCreateResponse> identityVerificationCreateResponse = client()
.identityVerificationCreate(identityVerificationCreateRequest)
.execute();
assertSuccessResponse(identityVerificationCreateResponse);
// TODO: this string replace can be removed once COG-3394 is addressed.
String clientId = identityVerificationCreateResponse.body().getId().replaceAll("flwses", "idv");
// POST /identity_verification/retry
IdentityVerificationRequestUser retryUser = new IdentityVerificationRequestUser();
retryUser.setEmailAddress(email);
IdentityVerificationRetryRequest identityVerificationRetryRequest = new IdentityVerificationRetryRequest();
identityVerificationRetryRequest.setTemplateId(TEMPLATE_ID);
identityVerificationRetryRequest.setClientUserId(customerReference);
identityVerificationRetryRequest.setStrategy(Strategy.RESET);
identityVerificationRetryRequest.setUser(retryUser);
Response<IdentityVerificationRetryResponse> identityVerificationRetryResponse = client()
.identityVerificationRetry(identityVerificationRetryRequest)
.execute();
assertSuccessResponse(identityVerificationRetryResponse);
// TODO: this string replace can be removed once COG-3394 is addressed.
String previousAttemptId =
identityVerificationRetryResponse.body().getPreviousAttemptId().replaceAll("flwses", "idv");
assertEquals(clientId, previousAttemptId);
// POST /identity_verification/get
IdentityVerificationGetRequest identityVerificationGetRequest = new IdentityVerificationGetRequest();
identityVerificationGetRequest.setIdentityVerificationId(clientId);
Response<IdentityVerificationGetResponse> identityVerificationGetResponse = client()
.identityVerificationGet(identityVerificationGetRequest)
.execute();
assertSuccessResponse(identityVerificationGetResponse);
assertEquals(customerReference, identityVerificationGetResponse.body().getClientUserId());
// POST /identity_verification/list
IdentityVerificationListRequest identityVerificationListRequest = new IdentityVerificationListRequest();
identityVerificationListRequest.setTemplateId(TEMPLATE_ID);
identityVerificationListRequest.setClientUserId(customerReference);
Response<IdentityVerificationListResponse> identityVerificationListResponse = client()
.identityVerificationList(identityVerificationListRequest)
.execute();
assertSuccessResponse(identityVerificationListResponse);
assertEquals(2, identityVerificationListResponse.body().getIdentityVerifications().size());
assertEquals(customerReference, identityVerificationListResponse.body().getIdentityVerifications().get(0).getClientUserId());
}
// This tests for a bug fixed in https://github.plaid.com/plaid/go/pull/52937
@Test
public void testStructIssue() throws Exception {
// Instant.now() contains a ':' which is not allowed in email addresses so we remove it.
String customerReference = "idv-user-" + Instant.now().toString().replace(":", "");;
// POST /identity_verification/create
IdentityVerificationCreateRequestUser user = new IdentityVerificationCreateRequestUser();
user.setEmailAddress(customerReference + "2@example.com");
IdentityVerificationCreateRequest identityVerificationCreateRequest = new IdentityVerificationCreateRequest();
identityVerificationCreateRequest.setClientUserId(customerReference);
identityVerificationCreateRequest.setIsShareable(true);
identityVerificationCreateRequest.setTemplateId(TEMPLATE_ID);
identityVerificationCreateRequest.setGaveConsent(true);
identityVerificationCreateRequest.setClientId(customerReference);
identityVerificationCreateRequest.setUser(user);
Response<IdentityVerificationCreateResponse> identityVerificationCreateResponse = client()
.identityVerificationCreate(identityVerificationCreateRequest)
.execute();
assertSuccessResponse(identityVerificationCreateResponse);
// TODO: this string replace can be removed once COG-3394 is addressed.
String clientId = identityVerificationCreateResponse.body().getId().replaceAll("flwses", "idv");
IdentityVerificationGetRequest identityVerificationGetRequest;
for (int i = 0; i < 20; i++) {
identityVerificationGetRequest = new IdentityVerificationGetRequest();
identityVerificationGetRequest.setIdentityVerificationId(clientId);
Response<IdentityVerificationGetResponse> identityVerificationGetResponse = client()
.identityVerificationGet(identityVerificationGetRequest)
.execute();
assertSuccessResponse(identityVerificationGetResponse);
}
identityVerificationGetRequest = new IdentityVerificationGetRequest();
Response<IdentityVerificationGetResponse> identityVerificationGetResponse = client()
.identityVerificationGet(identityVerificationGetRequest)
.execute();
assertErrorResponse(identityVerificationGetResponse, PlaidErrorType.INVALID_REQUEST, "INVALID_FIELD");
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/SandboxItemFireWebhookTest.java | src/test/java/com/plaid/client/integration/SandboxItemFireWebhookTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertTrue;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.ItemWebhookUpdateRequest;
import com.plaid.client.model.ItemWebhookUpdateResponse;
import com.plaid.client.model.Products;
import com.plaid.client.model.SandboxItemFireWebhookRequest;
import com.plaid.client.model.SandboxItemFireWebhookResponse;
import com.plaid.client.model.WebhookType;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class SandboxItemFireWebhookTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.TRANSACTIONS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testSuccess() throws Exception {
// Set a webhook
ItemWebhookUpdateRequest request = new ItemWebhookUpdateRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken())
.webhook("https://baz.xyz/foo-test-hook");
Response<ItemWebhookUpdateResponse> webhookResponse = client()
.itemWebhookUpdate(request)
.execute();
// Fire a webhook
SandboxItemFireWebhookRequest fireRequest = new SandboxItemFireWebhookRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken())
.webhookCode(
SandboxItemFireWebhookRequest.WebhookCodeEnum.DEFAULT_UPDATE
)
.webhookType(WebhookType.TRANSACTIONS);
Response<SandboxItemFireWebhookResponse> response = client()
.sandboxItemFireWebhook(fireRequest)
.execute();
assertSuccessResponse(response);
assertTrue(response.body().getWebhookFired());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/SandboxItemResetLoginTest.java | src/test/java/com/plaid/client/integration/SandboxItemResetLoginTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertTrue;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.Products;
import com.plaid.client.model.SandboxItemResetLoginRequest;
import com.plaid.client.model.SandboxItemResetLoginResponse;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class SandboxItemResetLoginTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.AUTH);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testSuccess() throws Exception {
SandboxItemResetLoginRequest request = new SandboxItemResetLoginRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<SandboxItemResetLoginResponse> response = client()
.sandboxItemResetLogin(request)
.execute();
assertSuccessResponse(response);
assertTrue(response.body().getResetLogin());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/TransactionsEnrichTest.java | src/test/java/com/plaid/client/integration/TransactionsEnrichTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import com.plaid.client.model.ClientProvidedEnrichedTransaction;
import com.plaid.client.model.ClientProvidedTransaction;
import com.plaid.client.model.ClientProvidedTransactionLocation;
import com.plaid.client.model.EnrichTransactionDirection;
import com.plaid.client.model.TransactionsEnrichRequest;
import com.plaid.client.model.TransactionsEnrichResponse;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class TransactionsEnrichTest extends AbstractIntegrationTest {
@Test
public void testTransactionsEnrichSuccess() throws Exception {
List<ClientProvidedTransaction> transactionsToEnrich = Arrays.asList(
new ClientProvidedTransaction()
.id("1")
.direction(EnrichTransactionDirection.OUTFLOW)
.isoCurrencyCode("USD")
.amount(123.00)
.location(
new ClientProvidedTransactionLocation().city("Ipswich").region("MA")
)
.description("TST *JETTIES BAGELS"),
new ClientProvidedTransaction()
.id("2")
.direction(EnrichTransactionDirection.OUTFLOW)
.isoCurrencyCode("USD")
.amount(123.00)
.description("AMAZON.COM*MJ3LO9AN2"),
new ClientProvidedTransaction()
.id("3")
.direction(EnrichTransactionDirection.OUTFLOW)
.isoCurrencyCode("USD")
.amount(123.00)
.description("GOOGLE *FRESHBOOKS"),
new ClientProvidedTransaction()
.id("4")
.direction(EnrichTransactionDirection.INFLOW)
.isoCurrencyCode("USD")
.amount(123.00)
.description("EARNIN TRANSFER")
);
TransactionsEnrichRequest transactionsEnrichRequest = new TransactionsEnrichRequest()
.accountType("depository").transactions(transactionsToEnrich);
Response<TransactionsEnrichResponse> response = client()
.transactionsEnrich(transactionsEnrichRequest)
.execute();
assertSuccessResponse(response);
List<ClientProvidedEnrichedTransaction> enrichedTransactions = response.body().getEnrichedTransactions();
assertTrue(enrichedTransactions.size() == transactionsToEnrich.size());
for (ClientProvidedEnrichedTransaction item : enrichedTransactions) {
assertNotNull(item.getAmount());
assertNotNull(item.getDescription());
assertNotNull(item.getDirection());
assertNotNull(item.getEnrichments());
assertNotNull(item.getId());
}
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/SandboxPublicTokenCreateTest.java | src/test/java/com/plaid/client/integration/SandboxPublicTokenCreateTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.ItemPublicTokenExchangeRequest;
import com.plaid.client.model.ItemPublicTokenExchangeResponse;
import com.plaid.client.model.Products;
import com.plaid.client.model.SandboxPublicTokenCreateRequest;
import com.plaid.client.model.SandboxPublicTokenCreateResponse;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class SandboxPublicTokenCreateTest extends AbstractIntegrationTest {
@Test
public void testSuccess() throws Exception {
SandboxPublicTokenCreateRequest request = new SandboxPublicTokenCreateRequest()
.institutionId(TARTAN_BANK_INSTITUTION_ID)
.initialProducts(Arrays.asList(Products.AUTH));
Response<SandboxPublicTokenCreateResponse> createResponse = client()
.sandboxPublicTokenCreate(request)
.execute();
assertSuccessResponse(createResponse);
assertNotNull(createResponse.body().getPublicToken());
ItemPublicTokenExchangeRequest exchangeRequest = new ItemPublicTokenExchangeRequest()
.publicToken(createResponse.body().getPublicToken());
Response<ItemPublicTokenExchangeResponse> response = client()
.itemPublicTokenExchange(exchangeRequest)
.execute();
assertSuccessResponse(response);
assertNotNull(response.body().getAccessToken());
assertNotNull(response.body().getItemId());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/WebhookVerificationKeyGetTest.java | src/test/java/com/plaid/client/integration/WebhookVerificationKeyGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.WebhookVerificationKeyGetRequest;
import com.plaid.client.model.WebhookVerificationKeyGetResponse;
import org.junit.Test;
import retrofit2.Response;
public class WebhookVerificationKeyGetTest extends AbstractIntegrationTest {
@Test
public void testWebhookVerificationKeyGetSuccess() throws Exception {
WebhookVerificationKeyGetRequest request = new WebhookVerificationKeyGetRequest()
.keyId("6c5516e1-92dc-479e-a8ff-5a51992e0001");
Response<WebhookVerificationKeyGetResponse> getWebhookVerificationKeyResponse = client()
.webhookVerificationKeyGet(request)
.execute();
assertSuccessResponse(getWebhookVerificationKeyResponse);
assertNotNull(getWebhookVerificationKeyResponse.body().getKey());
assertNotNull(getWebhookVerificationKeyResponse.body().getKey().getAlg());
assertNotNull(
getWebhookVerificationKeyResponse.body().getKey().getCreatedAt()
);
assertNotNull(getWebhookVerificationKeyResponse.body().getKey().getCrv());
assertNotNull(getWebhookVerificationKeyResponse.body().getKey().getKid());
assertNotNull(getWebhookVerificationKeyResponse.body().getKey().getKty());
assertNotNull(getWebhookVerificationKeyResponse.body().getKey().getUse());
assertNotNull(getWebhookVerificationKeyResponse.body().getKey().getX());
assertNotNull(getWebhookVerificationKeyResponse.body().getKey().getY());
}
@Test
public void testWebhookVerificationKeyGetFailure() throws Exception {
WebhookVerificationKeyGetRequest request = new WebhookVerificationKeyGetRequest()
.keyId("not-a-key-id");
Response<WebhookVerificationKeyGetResponse> response = client()
.webhookVerificationKeyGet(request)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_WEBHOOK_VERIFICATION_KEY_ID"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/InvestmentsTransactionsGetTest.java | src/test/java/com/plaid/client/integration/InvestmentsTransactionsGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import com.google.gson.Gson;
import com.plaid.client.model.AccountBase;
import com.plaid.client.model.AccountType;
import com.plaid.client.model.AccountsGetRequest;
import com.plaid.client.model.AccountsGetResponse;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.InvestmentTransaction;
import com.plaid.client.model.InvestmentsTransactionsGetRequest;
import com.plaid.client.model.InvestmentsTransactionsGetRequestOptions;
import com.plaid.client.model.InvestmentsTransactionsGetResponse;
import com.plaid.client.model.ItemPublicTokenExchangeRequest;
import com.plaid.client.model.ItemPublicTokenExchangeResponse;
import com.plaid.client.model.Products;
import com.plaid.client.model.SandboxPublicTokenCreateRequest;
import com.plaid.client.model.SandboxPublicTokenCreateResponse;
import com.plaid.client.model.Security;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.List;
import org.ietf.jgss.GSSContext;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import retrofit2.Response;
public class InvestmentsTransactionsGetTest
extends AbstractItemIntegrationTest {
private LocalDate startDate;
private LocalDate endDate;
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.INVESTMENTS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Before
public void setUp() throws Exception {
startDate = LocalDate.now().minusDays(365 * 2);
endDate = LocalDate.now();
}
@Ignore
@Test
public void testSuccess() throws Exception {
InvestmentsTransactionsGetRequestOptions options = new InvestmentsTransactionsGetRequestOptions()
.count(100);
InvestmentsTransactionsGetRequest request = new InvestmentsTransactionsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken())
.startDate(startDate)
.endDate(endDate)
.options(options);
Response<InvestmentsTransactionsGetResponse> response = null;
for (int i = 0; i < 5; i++) {
response = client().investmentsTransactionsGet(request).execute();
if (response.isSuccessful()) {
break;
} else {
Gson gson = new Gson();
PlaidError error = gson.fromJson(response.errorBody().string(), PlaidError.class);
assertEquals(error.getErrorCode(), "PRODUCT_NOT_READY");
Thread.sleep(3000);
}
}
assertSuccessResponse(response);
assertNotNull(response.body().getTotalInvestmentTransactions());
assertNotNull(response.body().getItem());
assertNotNull(response.body().getAccounts());
assertFalse(response.body().getAccounts().isEmpty());
assertTrue(response.body().getInvestmentTransactions().size() > 0);
List<InvestmentTransaction> investmentTransactions = response
.body()
.getInvestmentTransactions();
assertTrue(investmentTransactions.size() > 0);
for (InvestmentTransaction txn : investmentTransactions) {
assertNotNull(txn.getInvestmentTransactionId());
assertNotNull(txn.getAccountId());
assertNotNull(txn.getDate());
assertNotNull(txn.getName());
assertNotNull(txn.getAmount());
assertNotNull(txn.getType());
assertNotNull(txn.getIsoCurrencyCode());
assertNotNull(txn.getSubtype());
}
List<Security> securities = response.body().getSecurities();
assertTrue(securities.size() > 0);
for (Security security : securities) {
assertNotNull(security.getSecurityId());
assertNotNull(security.getName());
assertNotNull(security.getType());
assertNotNull(security.getIsoCurrencyCode());
}
}
@Ignore
@Test
public void testFullyLoadedRequest() throws Exception {
// get some account info
AccountsGetRequest request = new AccountsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<AccountsGetResponse> accountsGetResponse = client()
.accountsGet(request)
.execute();
assertSuccessResponse(accountsGetResponse);
String accountId = null;
for (AccountBase account : accountsGetResponse.body().getAccounts()) {
if (AccountType.INVESTMENT.equals(account.getType())) {
accountId = account.getAccountId();
break;
}
}
// actual test
InvestmentsTransactionsGetRequestOptions options = new InvestmentsTransactionsGetRequestOptions()
.accountIds(Arrays.asList(accountId))
.count(2)
.offset(1);
InvestmentsTransactionsGetRequest investmentGetRequest = new InvestmentsTransactionsGetRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken())
.startDate(startDate)
.endDate(endDate)
.options(options);
Response<InvestmentsTransactionsGetResponse> response = client()
.investmentsTransactionsGet(investmentGetRequest)
.execute();
assertSuccessResponse(response);
assertTrue(response.body().getTotalInvestmentTransactions() > 2);
assertEquals(2, response.body().getInvestmentTransactions().size());
}
@Test
public void testBadAccessToken() throws Exception {
InvestmentsTransactionsGetRequest request = new InvestmentsTransactionsGetRequest()
.accessToken("totally-invalid-stuff")
.startDate(startDate)
.endDate(endDate);
Response<InvestmentsTransactionsGetResponse> response = client()
.investmentsTransactionsGet(request)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_ACCESS_TOKEN"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AbstractItemIntegrationTest.java | src/test/java/com/plaid/client/integration/AbstractItemIntegrationTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.AccountBase;
import com.plaid.client.model.AccountSubtype;
import com.plaid.client.model.AccountType;
import com.plaid.client.model.Item;
import com.plaid.client.model.ItemGetRequest;
import com.plaid.client.model.ItemGetResponse;
import com.plaid.client.model.ItemPublicTokenExchangeRequest;
import com.plaid.client.model.ItemPublicTokenExchangeResponse;
import com.plaid.client.model.ItemStatus;
import com.plaid.client.model.Products;
import com.plaid.client.model.SandboxPublicTokenCreateRequest;
import com.plaid.client.model.SandboxPublicTokenCreateRequestOptions;
import com.plaid.client.model.SandboxPublicTokenCreateResponse;
import java.util.List;
import org.junit.Before;
import retrofit2.Response;
/**
* For tests where an item is required.
* <p>
* Subclasses must provide the institution and products desired by implementing.
* {@link #setupItemProducts()} and {@link #setupItemInstitutionId()}
*/
public abstract class AbstractItemIntegrationTest
extends AbstractIntegrationTest {
private ItemPublicTokenExchangeResponse exchangeTokenResponse;
private Item item;
protected static void assertAccount(
AccountBase actualAccount,
AccountType expectedType,
AccountSubtype expectedSubType,
Double expectedBalanceAvailable,
Double expectedBalanceCurrent,
Double expectedBalanceLimit,
String expectedName,
String expectedMask,
String expectedOfficialName
) {
assertNotNull(actualAccount.getAccountId());
assertEquals(expectedType, actualAccount.getType());
assertEquals(expectedSubType, actualAccount.getSubtype());
assertEquals(
expectedBalanceAvailable,
actualAccount.getBalances().getAvailable()
);
assertEquals(
expectedBalanceCurrent,
actualAccount.getBalances().getCurrent()
);
assertEquals(expectedBalanceLimit, actualAccount.getBalances().getLimit());
assertEquals(expectedName, actualAccount.getName());
assertEquals(expectedMask, actualAccount.getMask());
assertEquals(expectedOfficialName, actualAccount.getOfficialName());
}
@Before
public void setUpItem() throws Exception {
SandboxPublicTokenCreateRequest request = new SandboxPublicTokenCreateRequest()
.institutionId(setupItemInstitutionId());
request.setInitialProducts(setupItemProducts());
request.setOptions(setupOptions());
Response<SandboxPublicTokenCreateResponse> createResponse = client()
.sandboxPublicTokenCreate(request)
.execute();
assertSuccessResponse(createResponse);
ItemPublicTokenExchangeRequest itemPublicTokenExchangeRequest = new ItemPublicTokenExchangeRequest()
.publicToken(createResponse.body().getPublicToken());
Response<ItemPublicTokenExchangeResponse> response = client()
.itemPublicTokenExchange(itemPublicTokenExchangeRequest)
.execute();
assertSuccessResponse(response);
this.exchangeTokenResponse = response.body();
ItemGetRequest itemGetRequest = new ItemGetRequest()
.accessToken(exchangeTokenResponse.getAccessToken());
Response<ItemGetResponse> itemGetResponse = client()
.itemGet(itemGetRequest)
.execute();
assertSuccessResponse(itemGetResponse);
item = getItemFromItemWithConsentFields(itemGetResponse.body().getItem());
}
protected abstract List<Products> setupItemProducts();
protected abstract String setupItemInstitutionId();
protected SandboxPublicTokenCreateRequestOptions setupOptions() {
return null;
}
public ItemPublicTokenExchangeResponse getItemPublicTokenExchangeResponse() {
return exchangeTokenResponse;
}
public Item getItem() {
return item;
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/LinkTokenCreateTest.java | src/test/java/com/plaid/client/integration/LinkTokenCreateTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import com.plaid.client.model.DepositoryAccountSubtype;
import com.plaid.client.model.CountryCode;
import com.plaid.client.model.DepositoryFilter;
import com.plaid.client.model.LinkTokenAccountFilters;
import com.plaid.client.model.LinkTokenCreateRequest;
import com.plaid.client.model.LinkTokenCreateDepositoryFilter;
import com.plaid.client.model.LinkTokenCreateRequestAuth;
import com.plaid.client.model.LinkTokenCreateRequestUser;
import com.plaid.client.model.LinkTokenCreateResponse;
import com.plaid.client.model.Products;
import java.time.OffsetDateTime;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import retrofit2.Response;
public class LinkTokenCreateTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Collections.singletonList(Products.AUTH);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testSuccess() throws Exception {
String clientUserId = Long.toString((new Date()).getTime());
LinkTokenCreateRequestUser user = new LinkTokenCreateRequestUser()
.clientUserId(clientUserId);
LinkTokenCreateRequest request = new LinkTokenCreateRequest()
.user(user)
.clientName("very nice client name")
.products(Arrays.asList(Products.AUTH))
.countryCodes(Arrays.asList(CountryCode.US))
.language("en");
Response<LinkTokenCreateResponse> response = client()
.linkTokenCreate(request)
.execute();
assertSuccessResponse(response);
assertNotNull(response.body().getLinkToken());
assertTrue(response.body().getExpiration().isAfter(OffsetDateTime.now()));
}
@Test
public void testSuccess_full() throws Exception {
String clientUserId = Long.toString((new Date()).getTime());
LinkTokenCreateRequestUser user = new LinkTokenCreateRequestUser()
.clientUserId(clientUserId)
.legalName("legal name")
.phoneNumber("4155558888")
.emailAddress("email@address.com");
DepositoryFilter types = new DepositoryFilter()
.accountSubtypes(Arrays.asList(DepositoryAccountSubtype.CHECKING));
LinkTokenAccountFilters accountFilters = new LinkTokenAccountFilters()
.depository(types);
LinkTokenCreateRequest request = new LinkTokenCreateRequest()
.user(user)
.clientName("very nice client name")
.products(Arrays.asList(Products.AUTH))
.countryCodes(Arrays.asList(CountryCode.US))
.language("en")
.webhook("https://example.com/webhook")
.linkCustomizationName("default")
.accountFilters(accountFilters);
Response<LinkTokenCreateResponse> response = client()
.linkTokenCreate(request)
.execute();
assertSuccessResponse(response);
assertNotNull(response.body().getLinkToken());
assertTrue(response.body().getExpiration().isAfter(OffsetDateTime.now()));
}
@Test
public void testSuccess_auth() throws Exception {
String clientUserId = Long.toString((new Date()).getTime());
LinkTokenCreateRequestUser user = new LinkTokenCreateRequestUser()
.clientUserId(clientUserId)
.legalName("legal name")
.phoneNumber("4155558888")
.emailAddress("email@address.com");
DepositoryFilter types = new DepositoryFilter()
.accountSubtypes(Arrays.asList(DepositoryAccountSubtype.CHECKING));
LinkTokenAccountFilters accountFilters = new LinkTokenAccountFilters()
.depository(types);
LinkTokenCreateRequestAuth auth = new LinkTokenCreateRequestAuth()
.automatedMicrodepositsEnabled(true)
.instantMatchEnabled(true)
.sameDayMicrodepositsEnabled(true)
.authTypeSelectEnabled(true);
LinkTokenCreateRequest request = new LinkTokenCreateRequest()
.user(user)
.clientName("very nice client name")
.products(Arrays.asList(Products.AUTH))
.countryCodes(Arrays.asList(CountryCode.US))
.language("en")
.webhook("https://example.com/webhook")
.linkCustomizationName("default")
.accountFilters(accountFilters)
.auth(auth);
Response<LinkTokenCreateResponse> response = client()
.linkTokenCreate(request)
.execute();
assertSuccessResponse(response);
assertNotNull(response.body().getLinkToken());
assertTrue(response.body().getExpiration().isAfter(OffsetDateTime.now()));
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/ItemAccessTokenInvalidateTest.java | src/test/java/com/plaid/client/integration/ItemAccessTokenInvalidateTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.ItemAccessTokenInvalidateRequest;
import com.plaid.client.model.ItemAccessTokenInvalidateResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class ItemAccessTokenInvalidateTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.AUTH);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testSuccess() throws Exception {
ItemAccessTokenInvalidateRequest request = new ItemAccessTokenInvalidateRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken());
Response<ItemAccessTokenInvalidateResponse> response = client()
.itemAccessTokenInvalidate(request)
.execute();
assertSuccessResponse(response);
assertNotNull(response.body().getNewAccessToken());
assertNotEquals(
getItemPublicTokenExchangeResponse().getAccessToken(),
response.body().getNewAccessToken()
);
}
@Test
public void testInvalidAccessToken() throws Exception {
ItemAccessTokenInvalidateRequest request = new ItemAccessTokenInvalidateRequest()
.accessToken("not-real");
Response<ItemAccessTokenInvalidateResponse> response = client()
.itemAccessTokenInvalidate(request)
.execute();
assertErrorResponse(
response,
PlaidErrorType.INVALID_INPUT,
"INVALID_ACCESS_TOKEN"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/InstitutionsGetTest.java | src/test/java/com/plaid/client/integration/InstitutionsGetTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import com.plaid.client.model.CountryCode;
import com.plaid.client.model.Institution;
import com.plaid.client.model.InstitutionsGetRequest;
import com.plaid.client.model.InstitutionsGetRequestOptions;
import com.plaid.client.model.InstitutionsGetResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class InstitutionsGetTest extends AbstractIntegrationTest {
@Test
public void testSuccess() throws Exception {
InstitutionsGetRequest request = new InstitutionsGetRequest()
.count(3)
.offset(4)
.countryCodes(Arrays.asList(CountryCode.US));
Response<InstitutionsGetResponse> response = client()
.institutionsGet(request)
.execute();
assertSuccessResponse(response);
// check number returned
assertEquals(3, response.body().getInstitutions().size());
}
@Test
public void testSuccessWithProducts() throws Exception {
InstitutionsGetRequestOptions options = new InstitutionsGetRequestOptions();
options.products(Arrays.asList(Products.IDENTITY));
InstitutionsGetRequest request = new InstitutionsGetRequest()
.count(3)
.offset(4)
.countryCodes(Arrays.asList(CountryCode.US))
.options(options);
Response<InstitutionsGetResponse> response = client()
.institutionsGet(request)
.execute();
assertSuccessResponse(response);
// check number returned
assertEquals(3, response.body().getInstitutions().size());
}
@Test
public void testSuccessWithIncludeOptionalMetadataTrue() throws Exception {
InstitutionsGetRequestOptions options = new InstitutionsGetRequestOptions();
options.includeOptionalMetadata(true);
InstitutionsGetRequest request = new InstitutionsGetRequest()
.count(3)
.offset(4)
.countryCodes(Arrays.asList(CountryCode.US))
.options(options);
Response<InstitutionsGetResponse> response = client()
.institutionsGet(request)
.execute();
assertSuccessResponse(response);
// check number returned
assertEquals(3, response.body().getInstitutions().size());
}
@Test
public void testSuccessWithIncludeOptionalMetadataFalse() throws Exception {
InstitutionsGetRequestOptions options = new InstitutionsGetRequestOptions();
options.includeOptionalMetadata(false);
InstitutionsGetRequest request = new InstitutionsGetRequest()
.count(3)
.offset(4)
.countryCodes(Arrays.asList(CountryCode.US))
.options(options);
Response<InstitutionsGetResponse> response = client()
.institutionsGet(request)
.execute();
assertSuccessResponse(response);
// check number returned
assertEquals(3, response.body().getInstitutions().size());
}
@Test
public void testSuccessWithCountryCodes() throws Exception {
InstitutionsGetRequest request = new InstitutionsGetRequest()
.count(3)
.offset(4)
.countryCodes(Arrays.asList(CountryCode.US));
Response<InstitutionsGetResponse> response = client()
.institutionsGet(request)
.execute();
assertSuccessResponse(response);
// check number returned
assertEquals(3, response.body().getInstitutions().size());
}
@Test
public void testSuccessWithOAuth() throws Exception {
InstitutionsGetRequestOptions options = new InstitutionsGetRequestOptions();
options.oauth(true);
InstitutionsGetRequest request = new InstitutionsGetRequest()
.count(3)
.offset(1)
.countryCodes(Arrays.asList(CountryCode.GB))
.options(options);
Response<InstitutionsGetResponse> response = client()
.institutionsGet(request)
.execute();
assertSuccessResponse(response);
List<Institution> institutions = response.body().getInstitutions();
assertEquals(3, institutions.size());
// TODO: reenable this after institution fix for oauth filtering
// for (int i = 0; i < institutions.size(); i++) {
// assertTrue(institutions.get(i).getOauth());
// }
}
@Test
public void testSuccessWithoutOAuth() throws Exception {
InstitutionsGetRequestOptions options = new InstitutionsGetRequestOptions();
options.oauth(false);
InstitutionsGetRequest request = new InstitutionsGetRequest()
.count(3)
.offset(1)
.countryCodes(Arrays.asList(CountryCode.GB))
.options(options);
Response<InstitutionsGetResponse> response = client()
.institutionsGet(request)
.execute();
assertSuccessResponse(response);
// TODO: reenable this after institution fix for oauth filtering
List<Institution> institutions = response.body().getInstitutions();
// for (int i = 0; i < institutions.size(); i++) {
// assertFalse(institutions.get(i).getOauth());
// }
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/PlaidClientTest.java | src/test/java/com/plaid/client/integration/PlaidClientTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.model.CountryCode;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.InstitutionsSearchRequest;
import com.plaid.client.model.InstitutionsSearchResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import org.junit.Test;
import retrofit2.Response;
public class PlaidClientTest extends AbstractIntegrationTest {
@Test
public void testFailedRequest() throws Exception {
InstitutionsSearchRequest request = new InstitutionsSearchRequest()
.products(Arrays.asList(Products.ASSETS))
.countryCodes(Arrays.asList(CountryCode.US))
.query("");
Response<InstitutionsSearchResponse> response = client()
.institutionsSearch(request)
.execute();
assertErrorResponse(response, PlaidErrorType.INVALID_REQUEST, "INVALID_FIELD");
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/ItemWebhookUpdateTest.java | src/test/java/com/plaid/client/integration/ItemWebhookUpdateTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertEquals;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.Item;
import com.plaid.client.model.ItemWebhookUpdateRequest;
import com.plaid.client.model.ItemWebhookUpdateResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class ItemWebhookUpdateTest extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.TRANSACTIONS);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testSuccess() throws Exception {
// Update the webhook
String webhook = "https://baz.xyz/foo-test-hook";
ItemWebhookUpdateRequest request = new ItemWebhookUpdateRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken())
.webhook(webhook);
Response<ItemWebhookUpdateResponse> webhookResponse = client()
.itemWebhookUpdate(request)
.execute();
assertSuccessResponse(webhookResponse);
Item item = webhookResponse.body().getItem();
assertEquals(item.getWebhook(), webhook);
}
@Test
public void testFailure() throws Exception {
// Invalid webhook URL provided
ItemWebhookUpdateRequest request = new ItemWebhookUpdateRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken())
.webhook("invalid-hook");
Response<ItemWebhookUpdateResponse> webhookResponse = client()
.itemWebhookUpdate(request)
.execute();
assertErrorResponse(
webhookResponse,
PlaidErrorType.INVALID_REQUEST,
"INVALID_FIELD"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/RecipientListTest.java | src/test/java/com/plaid/client/integration/RecipientListTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import com.plaid.client.integration.RecipientCreateTest;
import com.plaid.client.model.PaymentInitiationRecipientCreateResponse;
import com.plaid.client.model.PaymentInitiationRecipientListRequest;
import com.plaid.client.model.PaymentInitiationRecipientListResponse;
import java.util.Arrays;
import org.junit.Test;
import retrofit2.Response;
public class RecipientListTest extends AbstractIntegrationTest {
@Test
public void testRecipientListSuccess() throws Exception {
Response<PaymentInitiationRecipientCreateResponse> createRecipientResponse = RecipientCreateTest.createRecipientWithIban(
client()
);
assertNotNull(createRecipientResponse.body().getRecipientId());
PaymentInitiationRecipientListRequest request = new PaymentInitiationRecipientListRequest();
Response<PaymentInitiationRecipientListResponse> listRecipientResponse = client()
.paymentInitiationRecipientList(request)
.execute();
assertSuccessResponse(listRecipientResponse);
assertTrue(listRecipientResponse.body().getRecipients().size() > 0);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/MonitorTest.java | src/test/java/com/plaid/client/integration/MonitorTest.java | package com.plaid.client.integration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import com.plaid.client.model.AccountIdentity;
import com.plaid.client.model.Address;
import com.plaid.client.model.Email;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.WatchlistScreeningRequestSearchTerms;
import com.plaid.client.model.WatchlistScreeningIndividualCreateRequest;
import com.plaid.client.model.WatchlistScreeningIndividualCreateResponse;
import com.plaid.client.model.WatchlistScreeningIndividualUpdateRequest;
import com.plaid.client.model.WatchlistScreeningIndividualUpdateResponse;
import com.plaid.client.model.WatchlistScreeningIndividualGetRequest;
import com.plaid.client.model.WatchlistScreeningIndividualGetResponse;
import com.plaid.client.model.WatchlistScreeningIndividualListRequest;
import com.plaid.client.model.WatchlistScreeningIndividualListResponse;
import com.plaid.client.model.WatchlistScreeningIndividualHistoryListRequest;
import com.plaid.client.model.WatchlistScreeningIndividualHistoryListResponse;
import com.plaid.client.model.WatchlistScreeningStatus;
import java.time.Instant;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
import java.time.LocalDate;
public class MonitorTest extends AbstractIntegrationTest {
private static final String WATCHLIST_PROGRAM_ID = "prg_egdF5fGjY8fWqk";
@Test
public void testSuccess() throws Exception {
String customerReference = "monitor-user-" + Instant.now();
// Create
WatchlistScreeningRequestSearchTerms searchTerms = new WatchlistScreeningRequestSearchTerms();
searchTerms.setWatchlistProgramId(WATCHLIST_PROGRAM_ID);
searchTerms.setLegalName("Domingo Huang");
searchTerms.setDocumentNumber("123456789");
searchTerms.setDateOfBirth(LocalDate.of(1990, 1, 1));
searchTerms.setCountry("US");
WatchlistScreeningIndividualCreateRequest watchlistScreeningIndividualCreateRequest =
new WatchlistScreeningIndividualCreateRequest();
watchlistScreeningIndividualCreateRequest.setClientUserId(customerReference);
watchlistScreeningIndividualCreateRequest.setSearchTerms(searchTerms);
Response<WatchlistScreeningIndividualCreateResponse> watchlistScreeningIndividualCreateResponse = client()
.watchlistScreeningIndividualCreate(watchlistScreeningIndividualCreateRequest)
.execute();
assertSuccessResponse(watchlistScreeningIndividualCreateResponse);
assertEquals(WatchlistScreeningStatus.CLEARED, watchlistScreeningIndividualCreateResponse.body().getStatus());
// Get
WatchlistScreeningIndividualGetRequest watchlistScreeningIndividualGetRequest =
new WatchlistScreeningIndividualGetRequest();
watchlistScreeningIndividualGetRequest
.setWatchlistScreeningId(watchlistScreeningIndividualCreateResponse.body().getId());
Response<WatchlistScreeningIndividualGetResponse> watchlistScreeningIndividualGetResponse = client()
.watchlistScreeningIndividualGet(watchlistScreeningIndividualGetRequest)
.execute();
assertEquals(
watchlistScreeningIndividualCreateResponse.body().getClientUserId(),
watchlistScreeningIndividualGetResponse.body().getClientUserId()
);
// Update
WatchlistScreeningIndividualUpdateRequest watchlistScreeningIndividualUpdateRequest =
new WatchlistScreeningIndividualUpdateRequest();
watchlistScreeningIndividualUpdateRequest
.setWatchlistScreeningId(watchlistScreeningIndividualCreateResponse.body().getId());
watchlistScreeningIndividualUpdateRequest.setStatus(WatchlistScreeningStatus.PENDING_REVIEW);
Response<WatchlistScreeningIndividualUpdateResponse> watchlistScreeningIndividualUpdateResponse = client()
.watchlistScreeningIndividualUpdate(watchlistScreeningIndividualUpdateRequest)
.execute();
assertSuccessResponse(watchlistScreeningIndividualUpdateResponse);
assertEquals(
watchlistScreeningIndividualCreateResponse.body().getId(),
watchlistScreeningIndividualUpdateResponse.body().getId()
);
assertEquals(
WatchlistScreeningStatus.PENDING_REVIEW,
watchlistScreeningIndividualUpdateResponse.body().getStatus()
);
// List
WatchlistScreeningIndividualListRequest watchlistScreeningIndividualListRequest =
new WatchlistScreeningIndividualListRequest();
watchlistScreeningIndividualListRequest.setWatchlistProgramId(WATCHLIST_PROGRAM_ID);
watchlistScreeningIndividualListRequest.setStatus(WatchlistScreeningStatus.CLEARED);
Response<WatchlistScreeningIndividualListResponse> watchlistScreeningIndividualListResponse = client()
.watchlistScreeningIndividualList(watchlistScreeningIndividualListRequest)
.execute();
assertSuccessResponse(watchlistScreeningIndividualListResponse);
assertFalse(watchlistScreeningIndividualListResponse.body().getWatchlistScreenings().isEmpty());
// List History
WatchlistScreeningIndividualHistoryListRequest watchlistScreeningIndividualHistoryListRequest =
new WatchlistScreeningIndividualHistoryListRequest();
watchlistScreeningIndividualHistoryListRequest
.setWatchlistScreeningId(watchlistScreeningIndividualCreateResponse.body().getId());
Response<WatchlistScreeningIndividualHistoryListResponse> watchlistScreeningIndividualHistoryListResponse =
client().watchlistScreeningIndividualHistoryList(watchlistScreeningIndividualHistoryListRequest).execute();
assertEquals(2, watchlistScreeningIndividualHistoryListResponse.body().getWatchlistScreenings().size());
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/ItemApexProcessorTokenCreateTest.java | src/test/java/com/plaid/client/integration/ItemApexProcessorTokenCreateTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.ProcessorApexProcessorTokenCreateRequest;
import com.plaid.client.model.ProcessorTokenCreateResponse;
import com.plaid.client.model.Products;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import org.junit.Test;
import retrofit2.Response;
public class ItemApexProcessorTokenCreateTest
extends AbstractItemIntegrationTest {
@Override
protected List<Products> setupItemProducts() {
return Arrays.asList(Products.AUTH);
}
@Override
protected String setupItemInstitutionId() {
return TARTAN_BANK_INSTITUTION_ID;
}
@Test
public void testError() throws Exception {
ProcessorApexProcessorTokenCreateRequest request = new ProcessorApexProcessorTokenCreateRequest()
.accessToken(getItemPublicTokenExchangeResponse().getAccessToken())
.accountId("FooBarAccountId");
Response<ProcessorTokenCreateResponse> response = client()
.processorApexProcessorTokenCreate(request)
.execute();
// Just assert that some error was returned - due to the nature of the
// integration and required configuration at the API key level, we don't
// know the exact error code to expect.
assertErrorResponse(
response,
PlaidErrorType.INVALID_REQUEST,
"INVALID_FIELD"
);
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
plaid/plaid-java | https://github.com/plaid/plaid-java/blob/130671fed6ef990db562aa6571e181ce08270945/src/test/java/com/plaid/client/integration/AbstractIntegrationTest.java | src/test/java/com/plaid/client/integration/AbstractIntegrationTest.java | package com.plaid.client.integration;
import static org.junit.Assert.*;
import com.google.gson.Gson;
import com.plaid.client.ApiClient;
import com.plaid.client.model.PlaidError;
import com.plaid.client.model.PlaidErrorType;
import com.plaid.client.model.Item;
import com.plaid.client.model.ItemWithConsentFields;
import com.plaid.client.request.PlaidApi;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.util.HashMap;
import okhttp3.Interceptor;
import okhttp3.Request;
import okhttp3.ResponseBody;
import org.junit.Before;
import retrofit2.Converter;
import retrofit2.Response;
import retrofit2.Retrofit;
/**
* Abstract base class for integration tests which gets configuration from the
* environment.
*
* PLAID_CLIENT_ID, PLAID_SECRET, and PLAID_BASE_URL must be
* defined or errors will be thrown.
*/
public abstract class AbstractIntegrationTest {
/**
* Sandbox-specific institution IDs used for testing. See sandbox documentation
* for more information.
*/
public static final String FIRST_PLATYPUS_BANK_INSTITUTION_ID = "ins_109508";
public static final String FIRST_GINGHAM_CREDIT_UNION_INSTITION_ID =
"ins_109509";
public static final String TATTERSALL_FEDERAL_CREDIT_UNION_INSTITUTION_ID =
"ins_109510";
public static final String TARTAN_BANK_INSTITUTION_ID = "ins_109511";
public static final String HOUNDSTOOTH_BANK_INSTITUTION_ID = "ins_109512";
public static final String INCOME_INSTITUTION_ID = "ins_135842";
private PlaidApi plaidClient;
private ApiClient apiClient;
@Before
public void setUpClient() throws Exception {
String plaidClientId = System.getenv("PLAID_CLIENT_ID");
String plaidSecret = System.getenv("PLAID_SECRET");
assertNotNull(
"PLAID_CLIENT_ID environment variable is required",
plaidClientId
);
assertNotNull("PLAID_SECRET environment variable is required", plaidSecret);
HashMap<String, String> apiKeys = new HashMap<String, String>();
apiKeys.put("clientId", plaidClientId);
apiKeys.put("secret", plaidSecret);
apiKeys.put("plaidVersion", "2020-09-14");
apiClient = new ApiClient(apiKeys);
apiClient.setPlaidAdapter(ApiClient.Sandbox);
apiClient.setTimeout(61);
plaidClient = apiClient.createService(PlaidApi.class);
}
protected PlaidApi client() {
return plaidClient;
}
protected ApiClient apiClient() {
return apiClient;
}
protected static void assertSuccessResponse(Response response) {
assertTrue(response.isSuccessful());
}
void assertErrorResponse(
Response response,
PlaidErrorType expectedErrorType,
String expectedErrorCode
)
throws Exception {
assertFalse(response.isSuccessful());
assertNotNull(response.errorBody());
try {
Gson gson = new Gson();
PlaidError error = gson.fromJson(response.errorBody().string(), PlaidError.class);
assertNotNull(error);
assertNotNull(error.getRequestId());
assertEquals(expectedErrorType, error.getErrorType());
assertEquals(expectedErrorCode, error.getErrorCode());
} catch (Exception e) {
throw new Exception(
String.format(
"Failed converting from API Response PlaidError Body to PlaidError %f",
response.errorBody().string()
)
);
}
}
protected static void assertItemEquals(Item expectedItem, Item actualItem) {
assertEquals(expectedItem.getError(), actualItem.getError());
assertEquals(
expectedItem.getAvailableProducts(),
actualItem.getAvailableProducts()
);
assertEquals(
expectedItem.getBilledProducts(),
actualItem.getBilledProducts()
);
assertEquals(
expectedItem.getInstitutionId(),
actualItem.getInstitutionId()
);
assertEquals(expectedItem.getItemId(), actualItem.getItemId());
assertEquals(expectedItem.getWebhook(), actualItem.getWebhook());
assertEquals(
expectedItem.getConsentExpirationTime(),
actualItem.getConsentExpirationTime()
);
assertEquals(
expectedItem.getUpdateType(),
actualItem.getUpdateType()
);
}
public Item getItemFromItemWithConsentFields(ItemWithConsentFields itemWithConsentFields) {
Item item = new Item()
.error(itemWithConsentFields.getError())
.availableProducts(itemWithConsentFields.getAvailableProducts())
.billedProducts(itemWithConsentFields.getBilledProducts())
.institutionId(itemWithConsentFields.getInstitutionId())
.itemId(itemWithConsentFields.getItemId())
.webhook(itemWithConsentFields.getWebhook())
.consentExpirationTime(itemWithConsentFields.getConsentExpirationTime())
.updateType(Item.UpdateTypeEnum.fromValue(itemWithConsentFields.getUpdateType().getValue()));
return item;
}
}
| java | MIT | 130671fed6ef990db562aa6571e181ce08270945 | 2026-01-05T02:42:29.116648Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.