0
package global.module;
1

2
import jakarta.servlet.http.HttpServletRequest;
3
import jakarta.servlet.http.HttpServletResponse;
4
import oauth.account.module.AuthModule;
5
import oauth.account.module.GithubAuthModule;
6
import oauth.account.module.GoogleAuthModule;
7
import oauth.account.module.KakaoAuthModule;
8
import oauth.account.module.NaverAuthModule;
9

10
/**
11
 * 프로세스 추상 클래스
12
 *
13
 * @author RWB
14
 * @since 2021.09.30 Thu 01:14:25
15
 */
16
abstract public class Process
17
{
18
    protected HttpServletRequest request;
19
    protected HttpServletResponse response;
20
    
21
    /**
22
     * 생성자 메서드
23
     *
24
     * @param request: [HttpServletRequest] HttpServletResponse 객체
25
     * @param response: [HttpServletResponse] HttpServletResponse 객체
26
     */
27
    protected Process(HttpServletRequest request, HttpServletResponse response)
28
    {
29
        this.request = request;
30
        this.response = response;
31
    }
32
    
33
    /**
34
     * 인증 모듈 반환 메서드
35
     *
36
     * @param platform: [String] 플랫폼
37
     *
38
     * @return [AuthModule] AuthModule 객체
39
     *
40
     * @throws NullPointerException 유효하지 않은 플랫폼
41
     */
42
    protected AuthModule getAuthModule(String platform) throws NullPointerException
43
    {
44
        return switch (platform)
45
                {
46
                    case "naver" -> NaverAuthModule.getInstance();
47
                    case "google" -> GoogleAuthModule.getInstance();
48
                    case "kakao" -> KakaoAuthModule.getInstance();
49
                    case "github" -> GithubAuthModule.getInstance();
50
                    default -> throw new NullPointerException(Util.builder("'", platform, "' is invalid platform"));
51
                };
52
    }
53
}

0
public Response getAuthorizationUrlResponse(String platform)
1
{
2
    Response response;
3
    
4
    ResponseBean<String> responseBean = new ResponseBean<>();
5
    
6
    // 인증 URL 응답 생성 시도
7
    try
8
    {
9
        String state = UUID.randomUUID().toString();
10
        
11
        request.getSession().setAttribute("state", state);
12
        
13
        AuthModule authModule = getAuthModule(platform);
14
        
15
        responseBean.setFlag(true);
16
        responseBean.setTitle("success");
17
        responseBean.setMessage(Util.builder(platform, " authrorization url response success"));
18
        responseBean.setBody(authModule.getAuthorizationUrl(state));
19
        
20
        response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
21
    }
22
    
23
    // 예외
24
    catch (Exception e)
25
    {
26
        e.printStackTrace();
27
        
28
        responseBean.setFlag(false);
29
        responseBean.setTitle(e.getClass().getSimpleName());
30
        responseBean.setMessage(e.getMessage());
31
        responseBean.setBody(null);
32
        
33
        response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
34
    }
35
    
36
    return response;
37
}

0
public Response getUserInfoResponse(String accessCookie)
1
{
2
    Response response;
3
    
4
    ResponseBean<UserInfoBean> responseBean = new ResponseBean<>();
5
    
6
    // 사용자 정보 응답 생성 시도
7
    try
8
    {
9
        Jws<Claims> jws = JwtModule.openJwt(accessCookie);
10
        
11
        String accessToken = jws.getBody().get("access", String.class);
12
        String platform = jws.getBody().get("platform", String.class);
13
        
14
        AuthModule authModule = getAuthModule(platform);
15
        
16
        com.github.scribejava.core.model.Response userInfoResponse = authModule.getUserInfo(accessToken);
17
        
18
        // 응답이 정상적이지 않을 경우
19
        if (userInfoResponse.getCode() != 200)
20
        {
21
            throw new OAuthResponseException(userInfoResponse);
22
        }
23
        
24
        responseBean.setFlag(true);
25
        responseBean.setTitle("success");
26
        responseBean.setMessage("user info response success");
27
        responseBean.setBody(authModule.getUserInfoBean(userInfoResponse.getBody()));
28
        
29
        response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
30
    }
31
    
32
    // 예외
33
    catch (Exception e)
34
    {
35
        e.printStackTrace();
36
        
37
        responseBean.setFlag(false);
38
        responseBean.setTitle(e.getClass().getSimpleName());
39
        responseBean.setMessage(e.getMessage());
40
        responseBean.setBody(null);
41
        
42
        response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
43
    }
44
    
45
    return response;
46
}

0
package oauth.account.process;
1

2
import com.github.scribejava.core.model.OAuthResponseException;
3
import global.bean.ResponseBean;
4
import global.module.JwtModule;
5
import global.module.Process;
6
import global.module.Util;
7
import io.jsonwebtoken.Claims;
8
import io.jsonwebtoken.Jws;
9
import jakarta.servlet.http.HttpServletRequest;
10
import jakarta.servlet.http.HttpServletResponse;
11
import jakarta.ws.rs.core.MediaType;
12
import jakarta.ws.rs.core.Response;
13
import oauth.account.bean.UserInfoBean;
14
import oauth.account.module.AuthModule;
15

16
import java.util.UUID;
17

18
/**
19
 * 계정 GET 프로세스 클래스
20
 *
21
 * @author RWB
22
 * @since 2021.09.30 Thu 21:00:48
23
 */
24
public class AccountGetProcess extends Process
25
{
26
    /**
27
     * 생성자 메서드
28
     *
29
     * @param request: [HttpServletRequest] HttpServletRequest 객체
30
     * @param response: [HttpServletResponse] HttpServletResponse 객체
31
     */
32
    public AccountGetProcess(HttpServletRequest request, HttpServletResponse response)
33
    {
34
        super(request, response);
35
    }
36
    
37
    /**
38
     * 인증 URL 응답 반환 메서드
39
     *
40
     * @param platform: [String] 플랫폼
41
     *
42
     * @return [Response] 응답 객체
43
     */
44
    public Response getAuthorizationUrlResponse(String platform)
45
    {
46
        Response response;
47
        
48
        ResponseBean<String> responseBean = new ResponseBean<>();
49
        
50
        // 인증 URL 응답 생성 시도
51
        try
52
        {
53
            String state = UUID.randomUUID().toString();
54
            
55
            request.getSession().setAttribute("state", state);
56
            
57
            AuthModule authModule = getAuthModule(platform);
58
            
59
            responseBean.setFlag(true);
60
            responseBean.setTitle("success");
61
            responseBean.setMessage(Util.builder(platform, " authrorization url response success"));
62
            responseBean.setBody(authModule.getAuthorizationUrl(state));
63
            
64
            response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
65
        }
66
        
67
        // 예외
68
        catch (Exception e)
69
        {
70
            e.printStackTrace();
71
            
72
            responseBean.setFlag(false);
73
            responseBean.setTitle(e.getClass().getSimpleName());
74
            responseBean.setMessage(e.getMessage());
75
            responseBean.setBody(null);
76
            
77
            response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
78
        }
79
        
80
        return response;
81
    }
82
    
83
    /**
84
     * 사용자 정보 응답 반환 메서드
85
     *
86
     * @param accessCookie: [String] 접근 토큰 쿠키
87
     *
88
     * @return [Response] 응답 객체
89
     */
90
    public Response getUserInfoResponse(String accessCookie)
91
    {
92
        Response response;
93
        
94
        ResponseBean<UserInfoBean> responseBean = new ResponseBean<>();
95
        
96
        // 사용자 정보 응답 생성 시도
97
        try
98
        {
99
            Jws<Claims> jws = JwtModule.openJwt(accessCookie);
100
            
101
            String accessToken = jws.getBody().get("access", String.class);
102
            String platform = jws.getBody().get("platform", String.class);
103
            
104
            AuthModule authModule = getAuthModule(platform);
105
            
106
            com.github.scribejava.core.model.Response userInfoResponse = authModule.getUserInfo(accessToken);
107
            
108
            // 응답이 정상적이지 않을 경우
109
            if (userInfoResponse.getCode() != 200)
110
            {
111
                throw new OAuthResponseException(userInfoResponse);
112
            }
113
            
114
            responseBean.setFlag(true);
115
            responseBean.setTitle("success");
116
            responseBean.setMessage("user info response success");
117
            responseBean.setBody(authModule.getUserInfoBean(userInfoResponse.getBody()));
118
            
119
            response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
120
        }
121
        
122
        // 예외
123
        catch (Exception e)
124
        {
125
            e.printStackTrace();
126
            
127
            responseBean.setFlag(false);
128
            responseBean.setTitle(e.getClass().getSimpleName());
129
            responseBean.setMessage(e.getMessage());
130
            responseBean.setBody(null);
131
            
132
            response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
133
        }
134
        
135
        return response;
136
    }
137
}

0
public Response postLoginResponse(String platform, String code, String state)
1
{
2
    Response response;
3
    
4
    ResponseBean<String> responseBean = new ResponseBean<>();
5
    
6
    HttpSession session = request.getSession();
7
    
8
    // 로그인 응답 생성 시도
9
    try
10
    {
11
        Object sessionState = Objects.requireNonNull(session.getAttribute("state"));
12
        
13
        // 고유 상태값이 일치하지 않을 경우
14
        if (!state.equals(sessionState))
15
        {
16
            throw new BadAttributeValueExpException("state is mismatched");
17
        }
18
        
19
        AuthModule authModule = getAuthModule(platform);
20
        
21
        OAuth2AccessToken oAuth2AccessToken = authModule.getAccessToken(code);
22
        
23
        String accessToken = oAuth2AccessToken.getAccessToken();
24
        String refreshToken = oAuth2AccessToken.getRefreshToken();
25
        
26
        HashMap<String, Object> accessMap = new HashMap<>();
27
        accessMap.put("access", accessToken);
28
        accessMap.put("platform", platform);
29
        
30
        HashMap<String, Object> refreshMap = new HashMap<>();
31
        refreshMap.put("refresh", refreshToken);
32
        refreshMap.put("platform", platform);
33
        
34
        String accessJwt = JwtModule.generateJwt(state, accessMap);
35
        String refreshJwt = JwtModule.generateJwt(state, refreshMap);
36
        
37
        NewCookie accessCookie = new NewCookie("access", accessJwt, "/oauth2", ".itcode.dev", "access token", -1, true, true);
38
        NewCookie refreshCookie = new NewCookie("refresh", refreshJwt, "/oauth2", ".itcode.dev", "refresh token", refreshToken == null ? 0 : 86400 * 7 + 3600 * 9, true, true);
39
        
40
        responseBean.setFlag(true);
41
        responseBean.setTitle("success");
42
        responseBean.setMessage("authorized success");
43
        responseBean.setBody(null);
44
        
45
        response = Response.ok(responseBean, MediaType.APPLICATION_JSON).cookie(accessCookie, refreshCookie).build();
46
    }
47
    
48
    // 예외
49
    catch (Exception e)
50
    {
51
        e.printStackTrace();
52
        
53
        responseBean.setFlag(false);
54
        responseBean.setTitle(e.getClass().getSimpleName());
55
        responseBean.setMessage(e.getMessage());
56
        responseBean.setBody(null);
57
        
58
        response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
59
    }
60
    
61
    // 시도 후
62
    finally
63
    {
64
        session.invalidate();
65
    }
66
    
67
    return response;
68
}

0
{
1
    "iss": "oauth2",
2
    "sub": "auth",
3
    "aud": "c9159786-40bf-4cf2-8c93-f683d1070137",
4
    "access": "{ACCESS_TOKEN}",
5
    "platform": "naver",
6
    "exp": 1634986011,
7
    "nbf": 1634982411,
8
    "iat": 1634982411,
9
    "jti": "c9159786-40bf-4cf2-8c93-f683d1070137"
10
}

0
{
1
    "iss": "oauth2",
2
    "sub": "auth",
3
    "aud": "c9159786-40bf-4cf2-8c93-f683d1070137",
4
    "refresh": "{REFRESH_TOKEN}",
5
    "platform": "naver",
6
    "exp": 1634986011,
7
    "nbf": 1634982411,
8
    "iat": 1634982411,
9
    "jti": "c9159786-40bf-4cf2-8c93-f683d1070137"
10
}

0
public Response postAutoLoginResponse(String accessCookie, String refreshCookie)
1
{
2
    Response response;
3
    
4
    ResponseBean<String> responseBean = new ResponseBean<>();
5
    
6
    // 자동 로그인 시도
7
    try
8
    {
9
        // 접근 토큰 쿠키가 있을 경우
10
        if (accessCookie != null)
11
        {
12
            responseBean.setFlag(true);
13
            responseBean.setTitle("success");
14
            responseBean.setMessage("auto authorized success");
15
            responseBean.setBody(null);
16
            
17
            response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
18
        }
19
        
20
        // 리프레쉬 토큰 쿠키가 없을 경우
21
        else if (refreshCookie == null)
22
        {
23
            responseBean.setFlag(false);
24
            responseBean.setTitle("fail");
25
            responseBean.setMessage("refresh token is empty");
26
            responseBean.setBody(null);
27
            
28
            response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
29
        }
30
        
31
        // 리프레쉬 토큰 쿠키가 있을 경우
32
        else
33
        {
34
            Jws<Claims> refreshJws = JwtModule.openJwt(refreshCookie);
35
            
36
            String refreshToken = refreshJws.getBody().get("refresh", String.class);
37
            String platform = refreshJws.getBody().get("platform", String.class);
38
            
39
            AuthModule authModule = getAuthModule(platform);
40
            
41
            OAuth2AccessToken oAuth2AccessToken = authModule.getRefreshAccessToken(refreshToken);
42
            
43
            String accessToken = oAuth2AccessToken.getAccessToken();
44
            
45
            HashMap<String, Object> accessMap = new HashMap<>();
46
            accessMap.put("access", accessToken);
47
            accessMap.put("platform", platform);
48
            
49
            HashMap<String, Object> refreshMap = new HashMap<>();
50
            refreshMap.put("refresh", refreshToken);
51
            refreshMap.put("platform", platform);
52
            
53
            String uuid = UUID.randomUUID().toString();
54
            
55
            String accessJwt = JwtModule.generateJwt(uuid, accessMap);
56
            String refreshJwt = JwtModule.generateJwt(uuid, refreshMap);
57
            
58
            NewCookie newAccessCookie = new NewCookie("access", accessJwt, "/oauth2", ".itcode.dev", "access token", -1, true, true);
59
            NewCookie newRefreshCookie = new NewCookie("refresh", refreshJwt, "/oauth2", ".itcode.dev", "refresh token", 86400 * 7 + 3600 * 9, true, true);
60
            
61
            responseBean.setFlag(true);
62
            responseBean.setTitle("success");
63
            responseBean.setMessage("auto authorized success");
64
            responseBean.setBody(null);
65
            
66
            response = Response.ok(responseBean, MediaType.APPLICATION_JSON).cookie(newAccessCookie, newRefreshCookie).build();
67
        }
68
    }
69
    
70
    // 예외
71
    catch (Exception e)
72
    {
73
        e.printStackTrace();
74
        
75
        responseBean.setFlag(false);
76
        responseBean.setTitle(e.getClass().getSimpleName());
77
        responseBean.setMessage(e.getMessage());
78
        responseBean.setBody(null);
79
        
80
        NewCookie newAccessCookie = new NewCookie("access", null, "/oauth2", ".itcode.dev", "access token", 0, true, true);
81
        NewCookie newRefreshCookie = new NewCookie("refresh", null, "/oauth2", ".itcode.dev", "refresh token", 0, true, true);
82
        
83
        response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).cookie(newAccessCookie, newRefreshCookie).build();
84
    }
85
    
86
    return response;
87
}

0
public Response postLogoutResponse()
1
{
2
    Response response;
3

4
    ResponseBean<String> responseBean = new ResponseBean<>();
5

6
    // 로그아웃 응답 생성 시도
7
    try
8
    {
9
        NewCookie accessCookie = new NewCookie("access", null, "/oauth2", ".itcode.dev", "access token", 0, true, true);
10
        NewCookie refreshCookie = new NewCookie("refresh", null, "/oauth2", ".itcode.dev", "refresh token", 0, true, true);
11

12
        responseBean.setFlag(true);
13
        responseBean.setTitle("success");
14
        responseBean.setMessage("logout success");
15
        responseBean.setBody(null);
16

17
        response = Response.ok(responseBean, MediaType.APPLICATION_JSON).cookie(accessCookie, refreshCookie).build();
18
    }
19

20
    // 예외
21
    catch (Exception e)
22
    {
23
        e.printStackTrace();
24

25
        responseBean.setFlag(false);
26
        responseBean.setTitle(e.getClass().getSimpleName());
27
        responseBean.setMessage(e.getMessage());
28
        responseBean.setBody(null);
29

30
        response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
31
    }
32

33
    return response;
34
}

0
package oauth.account.process;
1

2
import com.github.scribejava.core.model.OAuth2AccessToken;
3
import global.bean.ResponseBean;
4
import global.module.JwtModule;
5
import global.module.Process;
6
import io.jsonwebtoken.Claims;
7
import io.jsonwebtoken.Jws;
8
import jakarta.servlet.http.HttpServletRequest;
9
import jakarta.servlet.http.HttpServletResponse;
10
import jakarta.servlet.http.HttpSession;
11
import jakarta.ws.rs.core.MediaType;
12
import jakarta.ws.rs.core.NewCookie;
13
import jakarta.ws.rs.core.Response;
14
import oauth.account.module.AuthModule;
15

16
import javax.management.BadAttributeValueExpException;
17
import java.util.HashMap;
18
import java.util.Objects;
19
import java.util.UUID;
20

21
/**
22
 * 계정 POST 프로세스 클래스
23
 *
24
 * @author RWB
25
 * @since 2021.10.02 Sat 00:53:52
26
 */
27
public class AccountPostProcess extends Process
28
{
29
    /**
30
     * 생성자 메서드
31
     *
32
     * @param request: [HttpServletRequest] HttpServletRequest 객체
33
     * @param response: [HttpServletResponse] HttpServletResponse 객체
34
     */
35
    public AccountPostProcess(HttpServletRequest request, HttpServletResponse response)
36
    {
37
        super(request, response);
38
    }
39
    
40
    /**
41
     * 로그인 응답 반환 메서드
42
     *
43
     * @param platform: [String] 플랫폼
44
     * @param code: [String] 인증 코드
45
     * @param state: [String] 고유 상태값
46
     *
47
     * @return [Response] 응답 객체
48
     */
49
    public Response postLoginResponse(String platform, String code, String state)
50
    {
51
        Response response;
52
        
53
        ResponseBean<String> responseBean = new ResponseBean<>();
54
        
55
        HttpSession session = request.getSession();
56
        
57
        // 로그인 응답 생성 시도
58
        try
59
        {
60
            Object sessionState = Objects.requireNonNull(session.getAttribute("state"));
61
            
62
            // 고유 상태값이 일치하지 않을 경우
63
            if (!state.equals(sessionState))
64
            {
65
                throw new BadAttributeValueExpException("state is mismatched");
66
            }
67
            
68
            AuthModule authModule = getAuthModule(platform);
69
            
70
            OAuth2AccessToken oAuth2AccessToken = authModule.getAccessToken(code);
71
            
72
            String accessToken = oAuth2AccessToken.getAccessToken();
73
            String refreshToken = oAuth2AccessToken.getRefreshToken();
74
            
75
            HashMap<String, Object> accessMap = new HashMap<>();
76
            accessMap.put("access", accessToken);
77
            accessMap.put("platform", platform);
78
            
79
            HashMap<String, Object> refreshMap = new HashMap<>();
80
            refreshMap.put("refresh", refreshToken);
81
            refreshMap.put("platform", platform);
82
            
83
            String accessJwt = JwtModule.generateJwt(state, accessMap);
84
            String refreshJwt = JwtModule.generateJwt(state, refreshMap);
85
            
86
            NewCookie accessCookie = new NewCookie("access", accessJwt, "/oauth2", ".itcode.dev", "access token", -1, true, true);
87
            NewCookie refreshCookie = new NewCookie("refresh", refreshJwt, "/oauth2", ".itcode.dev", "refresh token", refreshToken == null ? 0 : 86400 * 7 + 3600 * 9, true, true);
88
            
89
            responseBean.setFlag(true);
90
            responseBean.setTitle("success");
91
            responseBean.setMessage("authorized success");
92
            responseBean.setBody(null);
93
            
94
            response = Response.ok(responseBean, MediaType.APPLICATION_JSON).cookie(accessCookie, refreshCookie).build();
95
        }
96
        
97
        // 예외
98
        catch (Exception e)
99
        {
100
            e.printStackTrace();
101
            
102
            responseBean.setFlag(false);
103
            responseBean.setTitle(e.getClass().getSimpleName());
104
            responseBean.setMessage(e.getMessage());
105
            responseBean.setBody(null);
106
            
107
            response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
108
        }
109
        
110
        // 시도 후
111
        finally
112
        {
113
            session.invalidate();
114
        }
115
        
116
        return response;
117
    }
118
    
119
    /**
120
     * 자동 로그인 응답 반환 메서드
121
     *
122
     * @param accessCookie: [String] 접근 토큰 쿠키
123
     * @param refreshCookie: [String] 리프레쉬 토큰 쿠키
124
     *
125
     * @return [Response] 응답 객체
126
     */
127
    public Response postAutoLoginResponse(String accessCookie, String refreshCookie)
128
    {
129
        Response response;
130
        
131
        ResponseBean<String> responseBean = new ResponseBean<>();
132
        
133
        // 자동 로그인 시도
134
        try
135
        {
136
            // 접근 토큰 쿠키가 있을 경우
137
            if (accessCookie != null)
138
            {
139
                responseBean.setFlag(true);
140
                responseBean.setTitle("success");
141
                responseBean.setMessage("auto authorized success");
142
                responseBean.setBody(null);
143
                
144
                response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
145
            }
146
            
147
            // 리프레쉬 토큰 쿠키가 없을 경우
148
            else if (refreshCookie == null)
149
            {
150
                responseBean.setFlag(false);
151
                responseBean.setTitle("fail");
152
                responseBean.setMessage("refresh token is empty");
153
                responseBean.setBody(null);
154
                
155
                response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
156
            }
157
            
158
            // 리프레쉬 토큰 쿠키가 있을 경우
159
            else
160
            {
161
                Jws<Claims> refreshJws = JwtModule.openJwt(refreshCookie);
162
                
163
                String refreshToken = refreshJws.getBody().get("refresh", String.class);
164
                String platform = refreshJws.getBody().get("platform", String.class);
165
                
166
                AuthModule authModule = getAuthModule(platform);
167
                
168
                OAuth2AccessToken oAuth2AccessToken = authModule.getRefreshAccessToken(refreshToken);
169
                
170
                String accessToken = oAuth2AccessToken.getAccessToken();
171
                
172
                HashMap<String, Object> accessMap = new HashMap<>();
173
                accessMap.put("access", accessToken);
174
                accessMap.put("platform", platform);
175
                
176
                HashMap<String, Object> refreshMap = new HashMap<>();
177
                refreshMap.put("refresh", refreshToken);
178
                refreshMap.put("platform", platform);
179
                
180
                String uuid = UUID.randomUUID().toString();
181
                
182
                String accessJwt = JwtModule.generateJwt(uuid, accessMap);
183
                String refreshJwt = JwtModule.generateJwt(uuid, refreshMap);
184
                
185
                NewCookie newAccessCookie = new NewCookie("access", accessJwt, "/oauth2", ".itcode.dev", "access token", -1, true, true);
186
                NewCookie newRefreshCookie = new NewCookie("refresh", refreshJwt, "/oauth2", ".itcode.dev", "refresh token", 86400 * 7 + 3600 * 9, true, true);
187
                
188
                responseBean.setFlag(true);
189
                responseBean.setTitle("success");
190
                responseBean.setMessage("auto authorized success");
191
                responseBean.setBody(null);
192
                
193
                response = Response.ok(responseBean, MediaType.APPLICATION_JSON).cookie(newAccessCookie, newRefreshCookie).build();
194
            }
195
        }
196
        
197
        // 예외
198
        catch (Exception e)
199
        {
200
            e.printStackTrace();
201
            
202
            responseBean.setFlag(false);
203
            responseBean.setTitle(e.getClass().getSimpleName());
204
            responseBean.setMessage(e.getMessage());
205
            responseBean.setBody(null);
206
            
207
            NewCookie newAccessCookie = new NewCookie("access", null, "/oauth2", ".itcode.dev", "access token", 0, true, true);
208
            NewCookie newRefreshCookie = new NewCookie("refresh", null, "/oauth2", ".itcode.dev", "refresh token", 0, true, true);
209
            
210
            response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).cookie(newAccessCookie, newRefreshCookie).build();
211
        }
212
        
213
        return response;
214
    }
215
    
216
    /**
217
     * 로그아웃 응답 반환 메서드
218
     *
219
     * @return [Response] 응답 객체
220
     */
221
    public Response postLogoutResponse()
222
    {
223
        Response response;
224
        
225
        ResponseBean<String> responseBean = new ResponseBean<>();
226
        
227
        // 로그아웃 응답 생성 시도
228
        try
229
        {
230
            NewCookie accessCookie = new NewCookie("access", null, "/oauth2", ".itcode.dev", "access token", 0, true, true);
231
            NewCookie refreshCookie = new NewCookie("refresh", null, "/oauth2", ".itcode.dev", "refresh token", 0, true, true);
232
            
233
            responseBean.setFlag(true);
234
            responseBean.setTitle("success");
235
            responseBean.setMessage("logout success");
236
            responseBean.setBody(null);
237
            
238
            response = Response.ok(responseBean, MediaType.APPLICATION_JSON).cookie(accessCookie, refreshCookie).build();
239
        }
240
        
241
        // 예외
242
        catch (Exception e)
243
        {
244
            e.printStackTrace();
245
            
246
            responseBean.setFlag(false);
247
            responseBean.setTitle(e.getClass().getSimpleName());
248
            responseBean.setMessage(e.getMessage());
249
            responseBean.setBody(null);
250
            
251
            response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
252
        }
253
        
254
        return response;
255
    }
256
}

0
public Response putUpdateAuthorizationUrl(String accessCookie)
1
{
2
    Response response;
3

4
    ResponseBean<String> responseBean = new ResponseBean<>();
5

6
    // 정보 제공 동의 갱신 URL 응답 생성 시도
7
    try
8
    {
9
        String state = UUID.randomUUID().toString();
10

11
        Jws<Claims> jws = JwtModule.openJwt(accessCookie);
12

13
        String platform = jws.getBody().get("platform", String.class);
14

15
        AuthModule authModule = getAuthModule(platform);
16

17
        String url = authModule.getUpdateAuthorizationUrl(state);
18

19
        // URL이 null일 경우
20
        if (url == null)
21
        {
22
            responseBean.setFlag(false);
23
            responseBean.setTitle("skipped");
24
            responseBean.setMessage(Util.builder(platform, " doesn't need that service"));
25
            responseBean.setBody(null);
26
        }
27

28
        // URL이 유효할 경우
29
        else
30
        {
31
            request.getSession().setAttribute("state", state);
32

33
            responseBean.setFlag(true);
34
            responseBean.setTitle("success");
35
            responseBean.setMessage(Util.builder(platform, " reauthrorization url response success"));
36
            responseBean.setBody(url);
37
        }
38

39
        response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
40
    }
41

42
    // 예외
43
    catch (Exception e)
44
    {
45
        e.printStackTrace();
46

47
        responseBean.setFlag(false);
48
        responseBean.setTitle(e.getClass().getSimpleName());
49
        responseBean.setMessage(e.getMessage());
50
        responseBean.setBody(null);
51

52
        response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
53
    }
54

55
    return response;
56
}

0
package oauth.account.process;
1

2
import global.bean.ResponseBean;
3
import global.module.JwtModule;
4
import global.module.Process;
5
import global.module.Util;
6
import io.jsonwebtoken.Claims;
7
import io.jsonwebtoken.Jws;
8
import jakarta.servlet.http.HttpServletRequest;
9
import jakarta.servlet.http.HttpServletResponse;
10
import jakarta.ws.rs.core.MediaType;
11
import jakarta.ws.rs.core.Response;
12
import oauth.account.module.AuthModule;
13

14
import java.util.UUID;
15

16
/**
17
 * 계정 PUT 프로세스 클래스
18
 *
19
 * @author RWB
20
 * @since 2021.10.19 Tue 21:56:32
21
 */
22
public class AccountPutProcess extends Process
23
{
24
    /**
25
     * 생성자 메서드
26
     *
27
     * @param request: [HttpServletRequest] HttpServletRequest 객체
28
     * @param response: [HttpServletResponse] HttpServletResponse 객체
29
     */
30
    public AccountPutProcess(HttpServletRequest request, HttpServletResponse response)
31
    {
32
        super(request, response);
33
    }
34
    
35
    /**
36
     * 정보 제공 동의 갱신 URL 응답 반환 메서드
37
     *
38
     * @param accessCookie: [String] 접근 토큰 쿠키
39
     *
40
     * @return [Response] 응답 객체
41
     */
42
    public Response putUpdateAuthorizationUrl(String accessCookie)
43
    {
44
        Response response;
45
        
46
        ResponseBean<String> responseBean = new ResponseBean<>();
47
        
48
        // 정보 제공 동의 갱신 URL 응답 생성 시도
49
        try
50
        {
51
            String state = UUID.randomUUID().toString();
52
            
53
            Jws<Claims> jws = JwtModule.openJwt(accessCookie);
54
            
55
            String platform = jws.getBody().get("platform", String.class);
56
            
57
            AuthModule authModule = getAuthModule(platform);
58
            
59
            String url = authModule.getUpdateAuthorizationUrl(state);
60
            
61
            // URL이 null일 경우
62
            if (url == null)
63
            {
64
                responseBean.setFlag(false);
65
                responseBean.setTitle("skipped");
66
                responseBean.setMessage(Util.builder(platform, " doesn't need that service"));
67
                responseBean.setBody(null);
68
            }
69
            
70
            // URL이 유효할 경우
71
            else
72
            {
73
                request.getSession().setAttribute("state", state);
74
                
75
                responseBean.setFlag(true);
76
                responseBean.setTitle("success");
77
                responseBean.setMessage(Util.builder(platform, " reauthrorization url response success"));
78
                responseBean.setBody(url);
79
            }
80
            
81
            response = Response.ok(responseBean, MediaType.APPLICATION_JSON).build();
82
        }
83
        
84
        // 예외
85
        catch (Exception e)
86
        {
87
            e.printStackTrace();
88
            
89
            responseBean.setFlag(false);
90
            responseBean.setTitle(e.getClass().getSimpleName());
91
            responseBean.setMessage(e.getMessage());
92
            responseBean.setBody(null);
93
            
94
            response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
95
        }
96
        
97
        return response;
98
    }
99
}

0
public Response deleteInfoResponse(String accessCookie)
1
{
2
    Response response;
3

4
    ResponseBean<String> responseBean = new ResponseBean<>();
5

6
    // 연동 해제 응답 생성 시도
7
    try
8
    {
9
        Jws<Claims> jws = JwtModule.openJwt(accessCookie);
10

11
        String accessToken = jws.getBody().get("access", String.class);
12
        String platform = jws.getBody().get("platform", String.class);
13

14
        AuthModule authModule = getAuthModule(platform);
15

16
        // 연동 해제에 성공할 경우
17
        if (authModule.deleteInfo(accessToken))
18
        {
19
            response = new AccountPostProcess(request, this.response).postLogoutResponse();
20
        }
21

22
        // 아닐 경우
23
        else
24
        {
25
            throw new RequestAuthenticationException("revoke fail");
26
        }
27
    }
28

29
    // 예외
30
    catch (Exception e)
31
    {
32
        e.printStackTrace();
33

34
        responseBean.setFlag(false);
35
        responseBean.setTitle(e.getClass().getSimpleName());
36
        responseBean.setMessage(e.getMessage());
37
        responseBean.setBody(null);
38

39
        response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
40
    }
41

42
    return response;
43
}

0
package oauth.account.process;
1

2
import global.bean.ResponseBean;
3
import global.module.JwtModule;
4
import global.module.Process;
5
import io.jsonwebtoken.Claims;
6
import io.jsonwebtoken.Jws;
7
import jakarta.servlet.http.HttpServletRequest;
8
import jakarta.servlet.http.HttpServletResponse;
9
import jakarta.ws.rs.core.MediaType;
10
import jakarta.ws.rs.core.Response;
11
import oauth.account.module.AuthModule;
12
import org.glassfish.jersey.client.authentication.RequestAuthenticationException;
13

14
/**
15
 * 계정 DELETE 프로세스 클래스
16
 *
17
 * @author RWB
18
 * @since 2021.10.02 Sat 00:53:52
19
 */
20
public class AccountDeleteProcess extends Process
21
{
22
    /**
23
     * 생성자 메서드
24
     *
25
     * @param request: [HttpServletRequest] HttpServletRequest 객체
26
     * @param response: [HttpServletResponse] HttpServletResponse 객체
27
     */
28
    public AccountDeleteProcess(HttpServletRequest request, HttpServletResponse response)
29
    {
30
        super(request, response);
31
    }
32
    
33
    /**
34
     * 연동 해제 응답 반환 메서드
35
     *
36
     * @param accessCookie: [String] 접근 토큰 쿠키
37
     *
38
     * @return [Response] 응답 객체
39
     */
40
    public Response deleteInfoResponse(String accessCookie)
41
    {
42
        Response response;
43
        
44
        ResponseBean<String> responseBean = new ResponseBean<>();
45
        
46
        // 연동 해제 응답 생성 시도
47
        try
48
        {
49
            Jws<Claims> jws = JwtModule.openJwt(accessCookie);
50
            
51
            String accessToken = jws.getBody().get("access", String.class);
52
            String platform = jws.getBody().get("platform", String.class);
53
            
54
            AuthModule authModule = getAuthModule(platform);
55
            
56
            // 연동 해제에 성공할 경우
57
            if (authModule.deleteInfo(accessToken))
58
            {
59
                response = new AccountPostProcess(request, this.response).postLogoutResponse();
60
            }
61
            
62
            // 아닐 경우
63
            else
64
            {
65
                throw new RequestAuthenticationException("revoke fail");
66
            }
67
        }
68
        
69
        // 예외
70
        catch (Exception e)
71
        {
72
            e.printStackTrace();
73
            
74
            responseBean.setFlag(false);
75
            responseBean.setTitle(e.getClass().getSimpleName());
76
            responseBean.setMessage(e.getMessage());
77
            responseBean.setBody(null);
78
            
79
            response = Response.status(Response.Status.BAD_REQUEST).entity(responseBean).type(MediaType.APPLICATION_JSON).build();
80
        }
81
        
82
        return response;
83
    }
84
}