Project Lab 10. 로그인 구현(Spring Security) - 1

<module-app-web/src/main/java/kr/ac/univ/config/SecurityConfig.java>

package kr.ac.univ.config;

import kr.ac.univ.handler.CustomAuthenticationFailureHandler;
import kr.ac.univ.handler.CustomAuthenticationSuccessHandler;
import kr.ac.univ.user.service.UserService;
import lombok.AllArgsConstructor;
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.web.builders.HttpSecurity;
import org.springframework.Security.config.annotation.web.builders.WebSecurity;
import org.springframework.Security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.Security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.Security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.Security.crypto.password.PasswordEncoder;
import org.springframework.Security.web.authentication.AuthenticationFailureHandler;
import org.springframework.Security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.Security.web.header.writers.frameoptions.WhiteListedAllowFromStrategy;
import org.springframework.Security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter;
import org.springframework.Security.web.util.matcher.AntPathRequestMatcher;

import java.util.Arrays;

@Configuration
@EnableWebSecurity
@AllArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   private UserService userService;

   @Override
   public void configure(WebSecurity web) throws Exception {
       // static 디렉터리의 하위 파일 목록은 인증 무시 ( = 항상통과 )
       web.ignoring().antMatchers("/css/**", "/js/**", "/imgages/**", "/summernote/**");
   }

   @Override
   protected void configure(HttpSecurity http) throws Exception {
       http.authorizeRequests()
               // 페이지 권한 설정
               .antMatchers("/user/list").hasAuthority("root")
               .antMatchers("/h2-console/**").permitAll() // h2-console 접근 허용
               .antMatchers("/**").permitAll()
               .and()
               .csrf().ignoringAntMatchers("/console/**") // h2-console csrf 제외
               .and()
               .headers().addHeaderWriter(new XFrameOptionsHeaderWriter(new WhiteListedAllowFromStrategy(Arrays.asList("localhost")))) // he-console X-Frame-Options 제외
               .frameOptions().sameOrigin()
               .and()
               // 로그인 설정
               .formLogin()
               .loginPage("/user/login")   // login 페이지 URL
               // 사용자 정의 handler
               .successHandler(CustomAuthenticationSuccessHandler())
               .failureHandler(CustomAuthenticationFailureHandler())
               .defaultSuccessUrl("/user/index")   // login 성공 URL
               .permitAll()
               .and()
               // 로그아웃 설정
               .logout()
               .logoutRequestMatcher(new AntPathRequestMatcher("/user/logout"))
               .logoutSuccessUrl("/user/logout/success")
               .invalidateHttpSession(true)
               .and()
               // 권한이 없는 경우, 403 예외처리 핸들링
               .exceptionHandling().accessDeniedPage("/user/permission-denied");
   }

   @Bean
   public PasswordEncoder passwordEncoder() {
       return new BCryptPasswordEncoder();
   }

   /**
    * 비밀번호 암호화에 사용될 PasswordEncoder를 BCryptPasswordEncoder로 사용
    * BCryptPasswordEncoder는 해시 뿐만 아니라 Salt를 넣는 작업을 수행하므로, 입력 값이 같음에도 매번 다른 encoded된 값을 반환함
    *
    * @return
    */
   @Override
   public void configure(AuthenticationManagerBuilder auth) throws Exception {
       auth.userDetailsService(userService).passwordEncoder(passwordEncoder());
   }

   /**
    * 로그인 성공 후 수행하는 handler
    *
    * @return
    */
   @Bean
   public AuthenticationSuccessHandler CustomAuthenticationSuccessHandler() {
       return new CustomAuthenticationSuccessHandler();
   }

   /**
    * 로그인 실패 후 수행하는 handler
    *
    * @return
    */
   @Bean
   public AuthenticationFailureHandler CustomAuthenticationFailureHandler() {
       return new CustomAuthenticationFailureHandler();
   }

   /**
    * 개발자가 원하는 시점에 로그인을 할 수 있도록 구현 가능
    *
    * @return
    * @throws Exception
    */
   @Override
   @Bean
   public AuthenticationManager authenticationManagerBean() throws Exception {
       return super.authenticationManagerBean();
   }
}

<module-app-web/src/main/java/kr/ac/univ/handler/CustomAuthenticationFailureHandler.java>

package kr.ac.univ.handler;

import org.springframework.Security.authentication.*;
import org.springframework.Security.core.AuthenticationException;
import org.springframework.Security.web.authentication.AuthenticationFailureHandler;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class CustomAuthenticationFailureHandler implements AuthenticationFailureHandler {
   @Override
   public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
       // 로그인 실패시 기능 구현
       String username = request.getParameter("username");
       String errormsg = null;

       if (exception instanceof BadCredentialsException) {
           errormsg = "The email or passwords do not match.";
       } else if (exception instanceof InternalAuthenticationServiceException) {
           errormsg = "The authentication is not processed due to system problem that occured internally.";
       } else if (exception instanceof AuthenticationCredentialsNotFoundException) {
           errormsg = "The authentication is not found.";
       }
       // 추후 잠금 및 비활성화 기능 구현
       else if (exception instanceof LockedException) {
           errormsg = "This user is locked.";
       } else if (exception instanceof DisabledException) {
           errormsg = "This user is disabled.";
       }

       request.setAttribute("username", username);
       request.setAttribute("errormsg", errormsg);

       request.getRequestDispatcher("/user/login/fail").forward(request, response);
   }

}

<module-app-web/src/main/java/kr/ac/univ/handler/CustomAuthenticationSuccessHandler.java>

package kr.ac.univ.handler;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.context.annotation.Configuration;
import org.springframework.Security.core.Authentication;
import org.springframework.Security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler;

@Configuration
public class CustomAuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {
   @Override
   public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws ServletException, IOException {
       // 로그인 성공시 기능 구현
       super.onAuthenticationSuccess(request, response, authentication);
   }
}

<module-domain-core/src/main/java/kr/ac/univ/user/dto/UserPrincipal.java>

package kr.ac.univ.user.dto;

import kr.ac.univ.common.domain.enums.ActiveStatus;
import kr.ac.univ.user.domain.User;
import kr.ac.univ.user.domain.enums.AuthorityType;
import lombok.*;
import org.springframework.Security.core.GrantedAuthority;
import org.springframework.Security.core.authority.SimpleGrantedAuthority;
import org.springframework.Security.core.userdetails.UserDetails;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@Getter
@Setter
@NoArgsConstructor
@ToString
public class UserPrincipal implements UserDetails {
   private long idx;
   @Getter(value = AccessLevel.NONE)
   private String username;
   @Getter(value = AccessLevel.NONE)
   private String password;

   private String koreanName;
   private String englishName;

   private ActiveStatus activeStatus;
   private AuthorityType authorityType;

   public UserPrincipal(User user) {
       setIdx(user.getIdx());
       setUsername(user.getUsername());
       setPassword(user.getPassword());
       setKoreanName(user.getKoreanName());
       setEnglishName(user.getEnglishName());
       setActiveStatus(user.getActiveStatus());
       setAuthorityType(user.getAuthorityType());
   }

   @Override
   public Collection<? extends GrantedAuthority> getAuthorities() {
       List<GrantedAuthority> authorities = new ArrayList<>();

       switch (this.getAuthorityType()) {
           case ROOT:
               authorities.add(new SimpleGrantedAuthority(AuthorityType.ROOT.getAuthorityType()));
               break;
           case MANAGER:
               authorities.add(new SimpleGrantedAuthority(AuthorityType.MANAGER.getAuthorityType()));
               break;
           case GENERAL:
               authorities.add(new SimpleGrantedAuthority(AuthorityType.GENERAL.getAuthorityType()));
               break;
           default:
               authorities.add(new SimpleGrantedAuthority(AuthorityType.NON_USER.getAuthorityType()));
               break;
       }

       return authorities;
   }

   @Override
   public String getPassword() {
       return this.password;
   }

   @Override
   public String getUsername() {
       return this.username;
   }

   @Override
   public boolean isAccountNonExpired() {
       return true;
   }

   @Override
   public boolean isAccountNonLocked() {
       return true;
   }

   @Override
   public boolean isCredentialsNonExpired() {
       return true;
   }

   @Override
   public boolean isEnabled() {
       return this.getActiveStatus() == ActiveStatus.ACTIVE;
   }
}

<module-domain-core/src/main/java/kr/ac/univ/user/repository/UserRepository.java>

package kr.ac.univ.user.repository;

import kr.ac.univ.noticeBoard.domain.NoticeBoard;
import kr.ac.univ.user.domain.User;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
   Long countByUsername(String username);

   User findByUsername(String username);

   Page<User> findAllByUsernameContaining(Pageable pageable, String username);

   Page<User> findAllByKoreanNameContaining(Pageable pageable, String koreanName);

   Page<User> findAllByEmailContaining(Pageable pageable, String email);
}

<module-domain-core/src/main/java/kr/ac/univ/user/service/UserService.java>

package kr.ac.univ.user.service;

import kr.ac.univ.common.dto.SearchDto;
import kr.ac.univ.user.domain.User;
import kr.ac.univ.user.dto.UserDto;
import kr.ac.univ.user.dto.UserPrincipal;
import kr.ac.univ.user.dto.mapper.UserMapper;
import kr.ac.univ.user.repository.UserRepository;
import kr.ac.univ.util.EmptyUtil;
import org.springframework.data.domain.*;
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;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService implements UserDetailsService {
   private final UserRepository userRepository;

   public UserService(UserRepository userRepository) {
       this.userRepository = userRepository;
   }

   public Page<UserDto> findUserList(Pageable pageable, SearchDto searchDto) {
       Page<User> userList = null;
       Page<UserDto> userDtoList = null;

       pageable = PageRequest.of(pageable.getPageNumber() <= 0 ? 0 : pageable.getPageNumber() - 1, pageable.getPageSize(), Sort.Direction.DESC, "idx");

       switch (searchDto.getSearchType()) {
           case "USER_ID":
               userList = userRepository.findAllByUsernameContaining(pageable, searchDto.getKeyword());
               break;
           case "KOREAN_NAME":
               userList = userRepository.findAllByKoreanNameContaining(pageable, searchDto.getKeyword());
               break;
           case "Email":
               userList = userRepository.findAllByEmailContaining(pageable, searchDto.getKeyword());
               break;
           default:
               userList = userRepository.findAll(pageable);
               break;
       }

       userDtoList = new PageImpl<UserDto>(UserMapper.INSTANCE.toDto(userList.getContent()), pageable, userList.getTotalElements());

       return userDtoList;
   }

   /**
    * 회원 가입
    *
    * @param userDto
    * @return
    */
   @Transactional
   public Long joinUser(UserDto userDto) {
       // 비밀번호 암호화
       BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
       userDto.setPassword(passwordEncoder.encode(userDto.getPassword()));

       return userRepository.save(UserMapper.INSTANCE.toEntity(userDto)).getIdx();
   }

   /**
    * 사용자 정의 로그인
    *
    * @param username
    * @return
    * @throws UsernameNotFoundException
    */
   @Override
   public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
       User user = userRepository.findByUsername(username);
       UserPrincipal userPrincipal = null;

       if(EmptyUtil.isEmpty(user)) {
           // 추후 변경: 에러 처리
           throw new UsernameNotFoundException("Username is not found");
       } else {
           userPrincipal = new UserPrincipal(user);
       }

       return userPrincipal;
   }

   public Long insertUser(User user) {
       return userRepository.save(user).getIdx();
   }

   public User findUserByIdx(Long idx) {

       return userRepository.findById(idx).orElse(new User());
   }

   @Transactional
   public Long updateUser(Long idx, UserDto userDto) {
       User persistUser = userRepository.getOne(idx);
       User user = UserMapper.INSTANCE.toEntity(userDto);

       persistUser.update(user);

       return userRepository.save(persistUser).getIdx();
   }

   public void deleteUserByIdx(Long idx) {
       userRepository.deleteById(idx);
   }

   public boolean isDupulicationUserByUsername(String username) {
       return (userRepository.countByUsername(username) > 0) ? true : false;
   }

   public User findByUsername(String username) {
       return userRepository.findByUsername(username);
   }
}

<module-app-web/src/main/java/kr/ac/univ/controller/UserController.java>

package kr.ac.univ.controller;

import kr.ac.univ.common.dto.SearchDto;
import kr.ac.univ.user.dto.UserDto;
import kr.ac.univ.user.dto.UserPrincipal;
import kr.ac.univ.user.dto.mapper.UserMapper;
import kr.ac.univ.user.service.UserAttachedFileService;
import kr.ac.univ.user.service.UserService;
import org.springframework.data.domain.Pageable;
import org.springframework.data.web.PageableDefault;
import org.springframework.Security.core.annotation.AuthenticationPrincipal;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpServletRequest;

@Controller
@RequestMapping("/user")
public class UserController {
   private final UserService userService;
   private final UserAttachedFileService userAttachedFileService;

   public UserController(UserService userService, UserAttachedFileService userAttachedFileService) {
       this.userService = userService;
       this.userAttachedFileService = userAttachedFileService;
   }

   // Login Index
   @GetMapping("/index")
   public String index(@AuthenticationPrincipal UserPrincipal userPrincipal, Model model) {
       model.addAttribute("userDto", userPrincipal);

       return "/user/index";
   }

   //Login Page
   @GetMapping("/login")
   public String login() {

       return "/user/login";
   }

   // Login Fail
   @PostMapping("/login/fail")
   public String loginFail(HttpServletRequest request, String errormsg) {

       return "/user/login";
   }

   // Logout
   @GetMapping("/logout/success")
   public String logout() {

       return "/user/logoutSuccess";
   }

   // Permission Denied
   @GetMapping("/permission-denied")
   public String permissionDenied() {

       return "/user/permission-denied";
   }

   // List
   @GetMapping("/list")
   public String noticeBoardList(@PageableDefault Pageable pageable, SearchDto searchDto, Model model) {
       model.addAttribute("userDtoList", userService.findUserList(pageable, searchDto));

       return "/user/list";
   }

   // Form Update
   @GetMapping("/form{idx}")
   public String loginForm(@RequestParam(value = "idx", defaultValue = "0") Long idx, Model model) {
       UserDto userDto = null;
       userDto = UserMapper.INSTANCE.toDto(userService.findUserByIdx(idx));
       userDto = UserMapper.INSTANCE.toDto(userDto, userAttachedFileService.findAttachedFileByUserIdx(idx));

       model.addAttribute("userDto", userDto);

       return "/user/form";
   }

   // Read
   @GetMapping({"", "/"})
   public String noticeBoardRead(@RequestParam(value = "idx", defaultValue = "0") Long idx, Model model) {
       UserDto userDto = null;
       userDto = UserMapper.INSTANCE.toDto(userService.findUserByIdx(idx));
       userDto = UserMapper.INSTANCE.toDto(userDto, userAttachedFileService.findAttachedFileByUserIdx(idx));

       model.addAttribute("userDto", userDto);

       return "/user/read";
   }
}

<module-app-api/src/main/java/kr/ac/univ/controller/UserRestController.java>

...

@PostMapping
public ResponseEntity<?> postUser(@RequestBody UserDto userDto) {
   // 추후 변경
   if (userService.isDupulicationUserByUsername(userDto.getUsername())) {

   }

   Long idx = userService.joinUser(userDto);

   return new ResponseEntity<>(idx, HttpStatus.CREATED);
}


...

<module-system-common/src/main/java/kr/ac/univ/util/AccessCheck.java>

package kr.ac.univ.util;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;

public class AccessCheck {
    /**
     * [일반적인 상황에서 사용자 권한에 따른 접근 가능 여부]
     * <p>
     * 비인증 사용자인 경우 접근 불가
     * root: 모든 권한에 대한 접근 허용
     * manager: 생성자가 root인 경우 접근 허용, 로그인한 사용자의 username과 생성자가 같은 경우 접근 허용
     *
     * @param createdBy
     * @return
     */
    public static Boolean isAccessInGeneral(String createdBy, String authorityType) {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        boolean result = false;

        // 비인증 사용자, 인증이 안된 경우, authentication 객체가 null인 경우
        // -> 접근 불가
        if (!"anonymousUser".equals(authentication.getPrincipal()) || !authentication.isAuthenticated() || EmptyUtil.isEmpty(authentication)) {
            UserDetails userDetails = (UserDetails) authentication.getPrincipal();
            String authenticationUsername = userDetails.getUsername();

            for (GrantedAuthority grantedAuthority : userDetails.getAuthorities()) {
                switch (grantedAuthority.getAuthority()) {
                    // 로그인한 사용자의 권한: root
                    // -> 접근 가능
                    case "root":
                        result = true;
                        break;
                    case "manager":
                        // createdBy: root
                        // -> 접근 불가
                        if ("root".equals(createdBy)) {
                            result = false;
                        }
                        // username authority: MANAGER
                        // 로그인한 사용자의 username과 username: 다름
                        // -> 접근 불가
                        else if ("manager".equals(authorityType) && !authenticationUsername.equals(createdBy)) {
                            result = false;
                        }
                        // 나머지 조건
                        // -> 접근 가능
                        else {
                            result = true;
                        }
                        break;
                    default:
                        // 로그인한 사용자의 username과 createdBy: 같음
                        // -> 접근 가능
                        if (authenticationUsername.equals(createdBy)) {
                            result = true;
                        }
                        // 로그인한 사용자의 username과 createdBy: 다름
                        // -> 접근 불가
                        else {
                            result = false;
                        }
                        break;
                }
            }
        }

        return result;
    }

    /**
     * [module-app-admin user에서 사용자 권한에 따른 접근 가능 여부]
     * <p>
     * 비인증 사용자인 경우 접근 불가
     * root: 모든 권한에 대한 접근 허용
     * manager: 생성자가 root인 경우 접근 허용, 로그인한 사용자의 username과 생성자가 같은 경우 접근 허용
     *
     * @param createdBy
     * @return
     */
    public static Boolean isAccessInModuleAdminUser(String createdBy, String username, String authorityType) {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        boolean result = false;

        // 비인증 사용자, 인증이 안된 경우, authentication 객체가 null인 경우
        // -> 접근 불가
        if (!"anonymousUser".equals(authentication.getPrincipal()) || !authentication.isAuthenticated() || EmptyUtil.isEmpty(authentication)) {
            UserDetails userDetails = (UserDetails) authentication.getPrincipal();
            String authenticationUsername = userDetails.getUsername();

            for (GrantedAuthority grantedAuthority : userDetails.getAuthorities()) {
                switch (grantedAuthority.getAuthority()) {
                    // 로그인한 사용자의 권한: root
                    // -> 접근 가능
                    case "root":
                        result = true;
                        break;
                    case "manager":
                        // 로그인한 사용자의 권한: manager
                        // 로그인한 사용자의 username과 createdBy: 같음
                        // -> 접근 가능
                        if (authenticationUsername.equals(createdBy)) {
                            result = true;
                        }
                        // 로그인한 사용자의 권한: manager
                        // username의 권한 general || non_user
                        // -> 접근 가능
                        else if (("general".equals(authorityType) || "non_user".equals(authorityType))) {
                            result = true;
                        }
                        // 로그인한 사용자의 권한: manager
                        // 로그인한 사용자의 username과 username: 같음
                        // -> 접근 가능
                        else if(authenticationUsername.equals(username)) {
                            result = true;
                        }
                        // 이외
                        // -> 접근 불가
                        else {
                            result = false;
                        }
                        break;
                    default:
                        result = false;
                        break;
                }
            }
        }

        return result;
    }

    /**
     * [module-app-web user에서 사용자 권한에 따른 접근 가능 여부]
     * <p>
     * 비인증 사용자인 경우 접근 불가
     * 생성자가 root인 경우 접근 허용
     * 생성자 권한이 MANAGER인 경우 접근 허용
     * 생성자와 사용자 아이디가 같은 경우 접근 허용
     *
     * @param createdBy
     * @return
     */
    public static Boolean isAccessInModuleWebUser(String createdBy, String username, String authorityType) {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        boolean result = false;

        // 비인증 사용자, 인증이 안된 경우, authentication 객체가 null인 경우
        // -> 접근 불가
        if ("anonymousUser".equals(authentication.getPrincipal()) || !authentication.isAuthenticated() || EmptyUtil.isEmpty(authentication)) {
            result = false;
        } else {
            UserDetails userDetails = (UserDetails) authentication.getPrincipal();
            String authenticationUsername = userDetails.getUsername();

            // createdBy: root
            // username authority: MANAGER
            // 로그인한 사용자의 username과 username: 같음
            // -> 접근 가능
            if ("root".equals(createdBy) || "MANAGER".equals(authorityType) && username.equals(authenticationUsername)) {
                result = true;
            }
            // 로그인한 사용자의 username과 createdBy: 같음
            // -> 접근 가능
            else if (authenticationUsername.equals(createdBy)) {
                result = true;
            } else {
                result = false;
            }
        }

        return result;
    }
}

<module-system-common/src/main/java/kr/ac/univ/util/EmptyUtil.java>

package kr.ac.univ.util;

import java.util.List;
import java.util.Map;

public class EmptyUtil {
   public static boolean isEmpty(Object obj) {
       if (obj == null)
           return true;

       if ((obj instanceof String) && (((String) obj).trim().length() == 0)) {
           return true;
       }
       if (obj instanceof Map) {
           return ((Map<?, ?>) obj).isEmpty();
       }
       if (obj instanceof Map) {
           return ((Map<?, ?>) obj).isEmpty();
       }
       if (obj instanceof List) {
           return ((List<?>) obj).isEmpty();
       }
       if (obj instanceof Object[]) {
           return (((Object[]) obj).length == 0);
       }

       return false;
   }

}

<module-app-web/src/main/java/kr/ac/univ/ModuleWebApplication.java>

package kr.ac.univ;

import kr.ac.univ.common.domain.enums.ActiveStatus;
import kr.ac.univ.noticeBoard.repository.NoticeBoardRepository;
import kr.ac.univ.user.domain.enums.AuthorityType;
import kr.ac.univ.user.domain.enums.UserType;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.Security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.bind.annotation.RestController;

import kr.ac.univ.user.domain.User;
import kr.ac.univ.user.repository.UserRepository;

@RestController
@SpringBootApplication
public class ModuleWebApplication {
   BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

   public static void main(String[] args) {
       SpringApplication.run(ModuleWebApplication.class, args);
   }

   @Bean
   public CommandLineRunner runner(NoticeBoardRepository noticeBoardRepository, UserRepository userRepository) {
       return (args) -> {
           /* 게시글 모두 삭제 */
           /* noticeBoardRepository.deleteAll(); */

           /* 게시글 등록 */
           /*
           IntStream.rangeClosed(1, 200).forEach(index ->
               noticeBoardRepository.save(NoticeBoard.builder()
                   .title("게시글" + index)
                   .content("컨텐츠" + index)
                   .activeStatus(ActiveStatus.ACTIVE)
                   .build()));
           */

           /* 사용자 모두 삭제 */
          /* userRepository.deleteAll(); */

           /* 사용자 생성 */
           /* userRepository.save(User.builder()
                   .username("root")
                   .password(passwordEncoder.encode("123123123"))
                   .userType(UserType.PART_TIME_MS)
                   .authorityType(AuthorityType.ROOT)
                   .activeStatus(ActiveStatus.ACTIVE)
                   .build());

           userRepository.save(User.builder()
                   .username("manager")
                   .password(passwordEncoder.encode("123123123"))
                   .userType(UserType.PART_TIME_MS)
                   .authorityType(AuthorityType.MANAGER)
                   .activeStatus(ActiveStatus.ACTIVE)
                   .build());

           userRepository.save(User.builder()
                   .username("manager2")
                   .password(passwordEncoder.encode("123123123"))
                   .userType(UserType.PART_TIME_MS)
                   .authorityType(AuthorityType.MANAGER)
                   .activeStatus(ActiveStatus.ACTIVE)
                   .build());

           userRepository.save(User.builder()
                   .username("general")
                   .password(passwordEncoder.encode("123123123"))
                   .userType(UserType.PART_TIME_MS)
                   .authorityType(AuthorityType.GENERAL)
                   .activeStatus(ActiveStatus.ACTIVE)
                   .build());

           userRepository.save(User.builder()
                   .username("general2")
                   .password(passwordEncoder.encode("123123123"))
                   .userType(UserType.PART_TIME_MS)
                   .authorityType(AuthorityType.GENERAL)
                   .activeStatus(ActiveStatus.ACTIVE)
                   .build());

           userRepository.save(User.builder()
                   .username("non_user")
                   .password(passwordEncoder.encode("123123123"))
                   .userType(UserType.PART_TIME_MS)
                   .authorityType(AuthorityType.NON_USER)
                   .activeStatus(ActiveStatus.ACTIVE)
                   .build());
           */
       };
   }
}