[Improvement][api] Introduce access token service interface for clear code (#3438)

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/AccessTokenController.java

@@ -17,6 +17,12 @@
 package org.apache.dolphinscheduler.api.controller;
 
 
+import static org.apache.dolphinscheduler.api.enums.Status.CREATE_ACCESS_TOKEN_ERROR;
+import static org.apache.dolphinscheduler.api.enums.Status.DELETE_ACCESS_TOKEN_ERROR;
+import static org.apache.dolphinscheduler.api.enums.Status.GENERATE_TOKEN_ERROR;
+import static org.apache.dolphinscheduler.api.enums.Status.QUERY_ACCESSTOKEN_LIST_PAGING_ERROR;
+import static org.apache.dolphinscheduler.api.enums.Status.UPDATE_ACCESS_TOKEN_ERROR;
+
 import org.apache.dolphinscheduler.api.enums.Status;
 import org.apache.dolphinscheduler.api.exceptions.ApiException;
 import org.apache.dolphinscheduler.api.service.AccessTokenService;
@@ -24,20 +30,26 @@ import org.apache.dolphinscheduler.api.utils.Result;
 import org.apache.dolphinscheduler.common.Constants;
 import org.apache.dolphinscheduler.common.utils.ParameterUtils;
 import org.apache.dolphinscheduler.dao.entity.User;
-import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiImplicitParam;
-import io.swagger.annotations.ApiImplicitParams;
-import io.swagger.annotations.ApiOperation;
+
+import java.util.Map;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
-import org.springframework.web.bind.annotation.*;
-import springfox.documentation.annotations.ApiIgnore;
-
-import java.util.Map;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestAttribute;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
 
-import static org.apache.dolphinscheduler.api.enums.Status.*;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiImplicitParams;
+import io.swagger.annotations.ApiOperation;
+import springfox.documentation.annotations.ApiIgnore;
 
 /**
  * access token controller

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/AccessTokenService.java

@@ -16,35 +16,14 @@
  */
 package org.apache.dolphinscheduler.api.service;
 
-import org.apache.dolphinscheduler.api.enums.Status;
-import org.apache.dolphinscheduler.api.utils.PageInfo;
-import org.apache.dolphinscheduler.common.Constants;
-import org.apache.dolphinscheduler.common.enums.UserType;
-import org.apache.dolphinscheduler.dao.entity.AccessToken;
 import org.apache.dolphinscheduler.dao.entity.User;
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import org.apache.dolphinscheduler.common.utils.DateUtils;
-import org.apache.dolphinscheduler.common.utils.EncryptionUtils;
-import org.apache.dolphinscheduler.dao.mapper.AccessTokenMapper;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
 
-import java.util.*;
+import java.util.Map;
 
 /**
- * user service
+ * access token service
  */
-@Service
-public class AccessTokenService extends BaseService {
-
-    private static final Logger logger = LoggerFactory.getLogger(AccessTokenService.class);
-
-    @Autowired
-    private AccessTokenMapper accessTokenMapper;
-
+public interface AccessTokenService {
 
     /**
      * query access token list
@@ -55,123 +34,44 @@ public class AccessTokenService extends BaseService {
      * @param pageSize page size
      * @return token list for page number and page size
      */
-    public Map<String, Object> queryAccessTokenList(User loginUser, String searchVal, Integer pageNo, Integer pageSize) {
-        Map<String, Object> result = new HashMap<>(5);
-
-        PageInfo<AccessToken> pageInfo = new PageInfo<>(pageNo, pageSize);
-        Page<AccessToken> page = new Page(pageNo, pageSize);
-        int userId = loginUser.getId();
-        if (loginUser.getUserType() == UserType.ADMIN_USER){
-            userId = 0;
-        }
-        IPage<AccessToken> accessTokenList = accessTokenMapper.selectAccessTokenPage(page, searchVal, userId);
-        pageInfo.setTotalCount((int)accessTokenList.getTotal());
-        pageInfo.setLists(accessTokenList.getRecords());
-        result.put(Constants.DATA_LIST, pageInfo);
-        putMsg(result, Status.SUCCESS);
-
-        return result;
-    }
+    Map<String, Object> queryAccessTokenList(User loginUser, String searchVal, Integer pageNo, Integer pageSize);
 
     /**
      * create token
+     *
      * @param userId token for user
      * @param expireTime token expire time
      * @param token token string
      * @return create result code
      */
-    public Map<String, Object> createToken(int userId, String expireTime, String token) {
-        Map<String, Object> result = new HashMap<>(5);
-
-        if (userId <= 0) {
-            throw new IllegalArgumentException("User id should not less than or equals to 0.");
-        }
-        AccessToken accessToken = new AccessToken();
-        accessToken.setUserId(userId);
-        accessToken.setExpireTime(DateUtils.stringToDate(expireTime));
-        accessToken.setToken(token);
-        accessToken.setCreateTime(new Date());
-        accessToken.setUpdateTime(new Date());
-
-        // insert
-        int insert = accessTokenMapper.insert(accessToken);
-
-        if (insert > 0) {
-            putMsg(result, Status.SUCCESS);
-        } else {
-            putMsg(result, Status.CREATE_ACCESS_TOKEN_ERROR);
-        }
-
-        return result;
-    }
+    Map<String, Object> createToken(int userId, String expireTime, String token);
 
     /**
      * generate token
+     *
      * @param userId token for user
      * @param expireTime token expire time
      * @return token string
      */
-    public Map<String, Object> generateToken(int userId, String expireTime) {
-        Map<String, Object> result = new HashMap<>(5);
-        String token = EncryptionUtils.getMd5(userId + expireTime + String.valueOf(System.currentTimeMillis()));
-        result.put(Constants.DATA_LIST, token);
-        putMsg(result, Status.SUCCESS);
-        return result;
-    }
+    Map<String, Object> generateToken(int userId, String expireTime);
 
     /**
-     *  delete access token
+     * delete access token
+     *
      * @param loginUser login user
      * @param id token id
      * @return delete result code
      */
-    public Map<String, Object> delAccessTokenById(User loginUser, int id) {
-        Map<String, Object> result = new HashMap<>(5);
-
-        AccessToken accessToken = accessTokenMapper.selectById(id);
-
-        if (accessToken == null) {
-            logger.error("access token not exist,  access token id {}", id);
-            putMsg(result, Status.ACCESS_TOKEN_NOT_EXIST);
-            return result;
-        }
-
-        if (loginUser.getId() != accessToken.getUserId() &&
-                loginUser.getUserType() != UserType.ADMIN_USER) {
-            putMsg(result, Status.USER_NO_OPERATION_PERM);
-            return result;
-        }
-
-        accessTokenMapper.deleteById(id);
-        putMsg(result, Status.SUCCESS);
-        return result;
-    }
+    Map<String, Object> delAccessTokenById(User loginUser, int id);
 
     /**
      * update token by id
+     *
      * @param id token id
      * @param userId token for user
      * @param expireTime token expire time
      * @param token token string
      * @return update result code
      */
-    public Map<String, Object> updateToken(int id,int userId, String expireTime, String token) {
-        Map<String, Object> result = new HashMap<>(5);
-
-        AccessToken accessToken = accessTokenMapper.selectById(id);
-        if (accessToken == null) {
-            logger.error("access token not exist,  access token id {}", id);
-            putMsg(result, Status.ACCESS_TOKEN_NOT_EXIST);
-            return result;
-        }
-        accessToken.setUserId(userId);
-        accessToken.setExpireTime(DateUtils.stringToDate(expireTime));
-        accessToken.setToken(token);
-        accessToken.setUpdateTime(new Date());
-
-        accessTokenMapper.updateById(accessToken);
-
-        putMsg(result, Status.SUCCESS);
-        return result;
-    }
+    Map<String, Object> updateToken(int id, int userId, String expireTime, String token);
 }

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/AccessTokenServiceImpl.java

@@ -0,0 +1,186 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.dolphinscheduler.api.service.impl;
+
+import org.apache.dolphinscheduler.api.enums.Status;
+import org.apache.dolphinscheduler.api.service.AccessTokenService;
+import org.apache.dolphinscheduler.api.service.BaseService;
+import org.apache.dolphinscheduler.api.utils.PageInfo;
+import org.apache.dolphinscheduler.common.Constants;
+import org.apache.dolphinscheduler.common.enums.UserType;
+import org.apache.dolphinscheduler.common.utils.DateUtils;
+import org.apache.dolphinscheduler.common.utils.EncryptionUtils;
+import org.apache.dolphinscheduler.dao.entity.AccessToken;
+import org.apache.dolphinscheduler.dao.entity.User;
+import org.apache.dolphinscheduler.dao.mapper.AccessTokenMapper;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+
+/**
+ * access token service impl
+ */
+@Service
+public class AccessTokenServiceImpl extends BaseService implements AccessTokenService {
+
+    private static final Logger logger = LoggerFactory.getLogger(AccessTokenServiceImpl.class);
+
+    @Autowired
+    private AccessTokenMapper accessTokenMapper;
+
+    /**
+     * query access token list
+     *
+     * @param loginUser login user
+     * @param searchVal search value
+     * @param pageNo page number
+     * @param pageSize page size
+     * @return token list for page number and page size
+     */
+    public Map<String, Object> queryAccessTokenList(User loginUser, String searchVal, Integer pageNo, Integer pageSize) {
+        Map<String, Object> result = new HashMap<>(5);
+
+        PageInfo<AccessToken> pageInfo = new PageInfo<>(pageNo, pageSize);
+        Page<AccessToken> page = new Page<>(pageNo, pageSize);
+        int userId = loginUser.getId();
+        if (loginUser.getUserType() == UserType.ADMIN_USER) {
+            userId = 0;
+        }
+        IPage<AccessToken> accessTokenList = accessTokenMapper.selectAccessTokenPage(page, searchVal, userId);
+        pageInfo.setTotalCount((int) accessTokenList.getTotal());
+        pageInfo.setLists(accessTokenList.getRecords());
+        result.put(Constants.DATA_LIST, pageInfo);
+        putMsg(result, Status.SUCCESS);
+
+        return result;
+    }
+
+    /**
+     * create token
+     *
+     * @param userId token for user
+     * @param expireTime token expire time
+     * @param token token string
+     * @return create result code
+     */
+    public Map<String, Object> createToken(int userId, String expireTime, String token) {
+        Map<String, Object> result = new HashMap<>(5);
+
+        if (userId <= 0) {
+            throw new IllegalArgumentException("User id should not less than or equals to 0.");
+        }
+        AccessToken accessToken = new AccessToken();
+        accessToken.setUserId(userId);
+        accessToken.setExpireTime(DateUtils.stringToDate(expireTime));
+        accessToken.setToken(token);
+        accessToken.setCreateTime(new Date());
+        accessToken.setUpdateTime(new Date());
+
+        // insert
+        int insert = accessTokenMapper.insert(accessToken);
+
+        if (insert > 0) {
+            putMsg(result, Status.SUCCESS);
+        } else {
+            putMsg(result, Status.CREATE_ACCESS_TOKEN_ERROR);
+        }
+
+        return result;
+    }
+
+    /**
+     * generate token
+     *
+     * @param userId token for user
+     * @param expireTime token expire time
+     * @return token string
+     */
+    public Map<String, Object> generateToken(int userId, String expireTime) {
+        Map<String, Object> result = new HashMap<>(5);
+        String token = EncryptionUtils.getMd5(userId + expireTime + String.valueOf(System.currentTimeMillis()));
+        result.put(Constants.DATA_LIST, token);
+        putMsg(result, Status.SUCCESS);
+        return result;
+    }
+
+    /**
+     * delete access token
+     *
+     * @param loginUser login user
+     * @param id token id
+     * @return delete result code
+     */
+    public Map<String, Object> delAccessTokenById(User loginUser, int id) {
+        Map<String, Object> result = new HashMap<>(5);
+
+        AccessToken accessToken = accessTokenMapper.selectById(id);
+
+        if (accessToken == null) {
+            logger.error("access token not exist,  access token id {}", id);
+            putMsg(result, Status.ACCESS_TOKEN_NOT_EXIST);
+            return result;
+        }
+
+        if (loginUser.getId() != accessToken.getUserId() &&
+                loginUser.getUserType() != UserType.ADMIN_USER) {
+            putMsg(result, Status.USER_NO_OPERATION_PERM);
+            return result;
+        }
+
+        accessTokenMapper.deleteById(id);
+        putMsg(result, Status.SUCCESS);
+        return result;
+    }
+
+    /**
+     * update token by id
+     *
+     * @param id token id
+     * @param userId token for user
+     * @param expireTime token expire time
+     * @param token token string
+     * @return update result code
+     */
+    public Map<String, Object> updateToken(int id, int userId, String expireTime, String token) {
+        Map<String, Object> result = new HashMap<>(5);
+
+        AccessToken accessToken = accessTokenMapper.selectById(id);
+        if (accessToken == null) {
+            logger.error("access token not exist,  access token id {}", id);
+            putMsg(result, Status.ACCESS_TOKEN_NOT_EXIST);
+            return result;
+        }
+        accessToken.setUserId(userId);
+        accessToken.setExpireTime(DateUtils.stringToDate(expireTime));
+        accessToken.setToken(token);
+        accessToken.setUpdateTime(new Date());
+
+        accessTokenMapper.updateById(accessToken);
+
+        putMsg(result, Status.SUCCESS);
+        return result;
+    }
+}

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/AccessTokenServiceTest.java

@@ -16,10 +16,12 @@
  */
 package org.apache.dolphinscheduler.api.service;
 
-import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import java.util.Calendar;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
 import org.apache.dolphinscheduler.api.enums.Status;
+import org.apache.dolphinscheduler.api.service.impl.AccessTokenServiceImpl;
 import org.apache.dolphinscheduler.api.utils.PageInfo;
 import org.apache.dolphinscheduler.common.Constants;
 import org.apache.dolphinscheduler.common.enums.UserType;
@@ -27,9 +29,14 @@ import org.apache.dolphinscheduler.common.utils.DateUtils;
 import org.apache.dolphinscheduler.dao.entity.AccessToken;
 import org.apache.dolphinscheduler.dao.entity.User;
 import org.apache.dolphinscheduler.dao.mapper.AccessTokenMapper;
-import org.junit.After;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
 import org.junit.Assert;
-import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
@@ -38,131 +45,109 @@ import org.mockito.junit.MockitoJUnitRunner;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 
 @RunWith(MockitoJUnitRunner.class)
 public class AccessTokenServiceTest {
 
-
     private static final Logger logger = LoggerFactory.getLogger(AccessTokenServiceTest.class);
 
-
     @InjectMocks
-    private AccessTokenService accessTokenService ;
+    private AccessTokenServiceImpl accessTokenService;
 
     @Mock
     private AccessTokenMapper accessTokenMapper;
 
-    @Before
-    public void setUp() {
-
-    }
-
-
-    @After
-    public void after(){
-
-    }
-
-
 
     @Test
-    public  void testQueryAccessTokenList(){
+    @SuppressWarnings("unchecked")
+    public void testQueryAccessTokenList() {
 
         IPage<AccessToken> tokenPage = new Page<>();
         tokenPage.setRecords(getList());
         tokenPage.setTotal(1L);
-        when(accessTokenMapper.selectAccessTokenPage(any(Page.class),eq("zhangsan"),eq(0))).thenReturn(tokenPage);
+        when(accessTokenMapper.selectAccessTokenPage(any(Page.class), eq("zhangsan"), eq(0))).thenReturn(tokenPage);
 
-        User user =new User();
-        Map<String, Object> result = accessTokenService.queryAccessTokenList(user,"zhangsan",1,10);
+        User user = new User();
+        Map<String, Object> result = accessTokenService.queryAccessTokenList(user, "zhangsan", 1, 10);
         logger.info(result.toString());
-        Assert.assertEquals(Status.SUCCESS,result.get(Constants.STATUS));
+        Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
         PageInfo<AccessToken> pageInfo = (PageInfo<AccessToken>) result.get(Constants.DATA_LIST);
-        Assert.assertTrue(pageInfo.getTotalCount()>0);
+        Assert.assertTrue(pageInfo.getTotalCount() > 0);
     }
 
     @Test
-    public  void testCreateToken(){
-
+    public void testCreateToken() {
 
-       when(accessTokenMapper.insert(any(AccessToken.class))).thenReturn(2);
-        Map<String, Object> result = accessTokenService.createToken(1,getDate(),"AccessTokenServiceTest");
+        when(accessTokenMapper.insert(any(AccessToken.class))).thenReturn(2);
+        Map<String, Object> result = accessTokenService.createToken(1, getDate(), "AccessTokenServiceTest");
         logger.info(result.toString());
-        Assert.assertEquals(Status.SUCCESS,result.get(Constants.STATUS));
+        Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
     }
 
     @Test
-    public  void testGenerateToken(){
+    public void testGenerateToken() {
 
-        Map<String, Object> result = accessTokenService.generateToken(Integer.MAX_VALUE,getDate());
+        Map<String, Object> result = accessTokenService.generateToken(Integer.MAX_VALUE, getDate());
         logger.info(result.toString());
-        Assert.assertEquals(Status.SUCCESS,result.get(Constants.STATUS));
+        Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
         String token = (String) result.get(Constants.DATA_LIST);
         Assert.assertNotNull(token);
     }
 
     @Test
-    public  void testDelAccessTokenById(){
+    public void testDelAccessTokenById() {
 
         when(accessTokenMapper.selectById(1)).thenReturn(getEntity());
         User userLogin = new User();
         // not exist
-        Map<String, Object> result = accessTokenService.delAccessTokenById(userLogin,0);
+        Map<String, Object> result = accessTokenService.delAccessTokenById(userLogin, 0);
         logger.info(result.toString());
-        Assert.assertEquals(Status.ACCESS_TOKEN_NOT_EXIST,result.get(Constants.STATUS));
+        Assert.assertEquals(Status.ACCESS_TOKEN_NOT_EXIST, result.get(Constants.STATUS));
         // no operate
-        result = accessTokenService.delAccessTokenById(userLogin,1);
+        result = accessTokenService.delAccessTokenById(userLogin, 1);
         logger.info(result.toString());
-        Assert.assertEquals(Status.USER_NO_OPERATION_PERM,result.get(Constants.STATUS));
+        Assert.assertEquals(Status.USER_NO_OPERATION_PERM, result.get(Constants.STATUS));
         //success
         userLogin.setId(1);
         userLogin.setUserType(UserType.ADMIN_USER);
-        result = accessTokenService.delAccessTokenById(userLogin,1);
+        result = accessTokenService.delAccessTokenById(userLogin, 1);
         logger.info(result.toString());
-        Assert.assertEquals(Status.SUCCESS,result.get(Constants.STATUS));
+        Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
     }
 
     @Test
-    public  void testUpdateToken(){
+    public void testUpdateToken() {
 
         when(accessTokenMapper.selectById(1)).thenReturn(getEntity());
-        Map<String, Object> result = accessTokenService.updateToken(1,Integer.MAX_VALUE,getDate(),"token");
+        Map<String, Object> result = accessTokenService.updateToken(1, Integer.MAX_VALUE, getDate(), "token");
         logger.info(result.toString());
-        Assert.assertEquals(Status.SUCCESS,result.get(Constants.STATUS));
+        Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
         // not exist
-        result = accessTokenService.updateToken(2,Integer.MAX_VALUE,getDate(),"token");
+        result = accessTokenService.updateToken(2, Integer.MAX_VALUE, getDate(), "token");
         logger.info(result.toString());
-        Assert.assertEquals(Status.ACCESS_TOKEN_NOT_EXIST,result.get(Constants.STATUS));
+        Assert.assertEquals(Status.ACCESS_TOKEN_NOT_EXIST, result.get(Constants.STATUS));
 
     }
 
     /**
      * create entity
-     * @return
      */
-    private AccessToken getEntity(){
+    private AccessToken getEntity() {
         AccessToken accessToken = new AccessToken();
         accessToken.setId(1);
         accessToken.setUserId(1);
         accessToken.setToken("AccessTokenServiceTest");
-        Date date = DateUtils.add(new Date(),Calendar.DAY_OF_MONTH, 30);
+        Date date = DateUtils.add(new Date(), Calendar.DAY_OF_MONTH, 30);
         accessToken.setExpireTime(date);
         return accessToken;
     }
 
     /**
      * entity list
-     * @return
      */
-    private List<AccessToken> getList(){
+    private List<AccessToken> getList() {
 
         List<AccessToken> list = new ArrayList<>();
         list.add(getEntity());
@@ -170,13 +155,11 @@ public class AccessTokenServiceTest {
     }
 
 
-
     /**
      * get dateStr
-     * @return
      */
-    private String getDate(){
+    private String getDate() {
         Date date = DateUtils.add(new Date(), Calendar.DAY_OF_MONTH, 30);
-       return DateUtils.dateToString(date);
+        return DateUtils.dateToString(date);
     }
 }