개발일지-14 [🌮메뉴, 원산지 도메인: 등록, 수정, 조회]

메뉴, 원산지 도메인 기능 정의 포스팅

---

1. [Post] /jat/menus

메인/사이드 메뉴, 원산지 등록

• 메뉴의 이미지는 등록해도되고 안해도됨.
• 이미지 정보를 서버에서 유지하기 위해 AWS S3 서비스를 이용.
• 웹 애플리케이션에서 AWS S3 접근 인가는 AWS IAM 계정의 액세스키 활용

(1) 로직 플로우
1. 메뉴 정보를 Post로 요청받음.
2. 사용자가 이미 메뉴를 등록했는지 확인
3. 사용자의 가게를 조회하여 가게에 메뉴 등록할 준비
4. 메인/사이드 메뉴, 원산지 등록
5. 판매자의 로그인 status 변경(메뉴 등록완료 상태)

• 요청 바디
  
• 응답 바디
  

• MenuController.java
  

• MenuService.java
  1. 사용자 메뉴 등록 가능 여부확인. 사용자 가게 조회

    @Transactional(rollbackFor = BaseException.class)
    public PostMenuRes menuRegister(int sellerIdx, PostMenuReq postMenuReq) throws BaseException {
        // 0) 사용자 메뉴 등록 여부 확인
        // (index)  0 :first_login, 1: menu_register
        int[] loginStatus = sellerDao.checkRegisterd(sellerIdx);
        if(loginStatus[0] == 0 && loginStatus[1] == 0){
            throw new BaseException(STORE_MENU_ALREADY_SAVED); // 4034 : 메뉴 등록이 이미 이루어진 판매자 입니다.
        }
        if(loginStatus[0] == 1){
            throw new BaseException(STORE_REGISTER_NOT_PERMITTED); // 4035 : 관리자에게 가게 승인되지 않은 판매자 계정입니다.
        }
        // first_login == 1, menu_register == 0 일때 메뉴등록가능

        // 1)사용자 가게 조회
        int storeIdx;
        try{
            storeIdx = storeDao.storeIdxBySellerIdx(sellerIdx);
        } catch (Exception e) {
            throw new BaseException(POST_STORES_NOT_REGISTERD); // 2030 : 사용자의 가게가 등록되어있지 않습니다.
        }

우선 메뉴를 이미 등록했다면 해당 서비스 플로우 상 맞지 않는 요청이기 때문에 확인을 하였고, 확인 후 상요자의 가게를 조회하여 메뉴등록 시 외래키 값으로 주어줄 준비를 하였다.

2. 메인/사이드 메뉴, 원산지 등록

        // 2) 가게 메뉴/원산지 등록
        int mainMenuItemCount = 0, sideMenuItemCount = 0, ingredientCount = 0;
        List<PostMenuUrlItem> urlItems = null;
        try { // 2-1) 메인 메뉴 등록
            if (postMenuReq.getMainMenuItems() != null && postMenuReq.getMainMenuItems().size() != 0) {
                urlItems = convertToUrlFileNames(postMenuReq.getMainMenuItems());
                mainMenuItemCount = menuDao.menuRegister(storeIdx, urlItems, "M");
            }
            else
                throw new BaseException(STORE_MAINMENU_SAVE_ERROR);
            //mainMenuItemCount = 0;// 2031 : 메인 메뉴 등록 정보가 올바르지 않습니다.
        } catch (Exception e) {
            throw new BaseException(STORE_MAINMENU_SAVE_ERROR); // 4031 : 메인메뉴 등록에 실패하였습니다.
        }

        try { // 2-2) 사이드 메뉴 등록
            if (postMenuReq.getSideMenuItems() != null && postMenuReq.getSideMenuItems().size() != 0) {
                urlItems = convertToUrlFileNames(postMenuReq.getSideMenuItems());
                sideMenuItemCount = menuDao.menuRegister(storeIdx, urlItems, "S");
            }
            else
                sideMenuItemCount = 0;//throw new BaseException(STORE_SIDEMENU_SAVE_ERROR);
            // // 2032 : 사이드 메뉴 등록 정보가 올바르지 않습니다.
        } catch (Exception e) {
            //System.out.println("2:" + e);
            throw new BaseException(STORE_SIDEMENU_SAVE_ERROR); // 4032: 사이드메뉴 등록에 실패하였습니다.
        }

        try { // 2-3) 원산지 등록
            if (postMenuReq.getIngredientItems() != null && postMenuReq.getIngredientItems().size() != 0) {
                ingredientCount = menuDao.ingredientRegister(storeIdx, postMenuReq.getIngredientItems());
            }
            else
                throw new BaseException(STORE_INGREDIENT_SAVE_ERROR);
        } catch (Exception e) {
            //System.out.println("3:" + e);
            throw new BaseException(STORE_INGREDIENT_SAVE_ERROR); // 4033 : 원산지 등록에 실패하였습니다.
        }

각각 들어온 정보들을 DB에 등록하였다. 등록 시에 등록이 올바로 되었는지 확인하기 위해서 JdbcTempalte 함수 중 batchUpdate의 반환 값을 확인하여 등록이 얼마나 되었는지 개수를 확인.

3. 등록 완료 후 판매자 서비스 이용 상태 변경

        // 3) 판매자 최초로그인,
        // 판매자 가게등록여부 필드 변경 : 1, 1 -> 0, 0
        try {
            sellerDao.registerMenuNIngredient(sellerIdx);
            storeDao.convertStoreOpen(storeIdx);
        } catch(Exception e){
            throw new BaseException(SELLER_ALL_REGISTER_COMPLETE_ERROR); // 4030 : 판매자의 최초로그인, 메뉴/원산지 등록이 완료되지 못하였습니다.
        }

        if(postMenuReq.getMainMenuItems() != null && postMenuReq.getMainMenuItems().size() > 0 && mainMenuItemCount == 0){
            throw new BaseException(STORE_MAINMENU_SAVE_ERROR);
        }
        if(postMenuReq.getSideMenuItems() != null && postMenuReq.getMainMenuItems().size() > 0 && sideMenuItemCount == 0){
            throw new BaseException(STORE_SIDEMENU_SAVE_ERROR);
        }
        if(postMenuReq.getIngredientItems() != null && postMenuReq.getIngredientItems().size() > 0 && ingredientCount == 0){
            throw new BaseException(STORE_INGREDIENT_SAVE_ERROR);
        }

        return new PostMenuRes(storeIdx, mainMenuItemCount, sideMenuItemCount, ingredientCount);
    }

등록 완료후 판매자의 서비스 이용을 위해 최초로그인, 가게, 메뉴 등록 여부를 모두 완료 상태로 변경하고 로그인 후 본격적인 서비스를 시작할 수 있도록 준비한다.
또 요청받은 등록 정보의 개수와 DB에 등록된 개수가 맞지 않을 경우 예외처리를 하였다.

• MenuDao.java

// 판매자의 메뉴 등록 여부 확인
public int[] checkRegisterd(int sellerIdx) {
        String query = "SELECT " +
                "first_login, menu_register " +
                "FROM Merchandisers " +
                "WHERE sellerIdx = ?";
        return this.jdbcTemplate.queryForObject(query,
                (rs, rowNum) -> new int[]{
                        rs.getInt("first_login"),
                        rs.getInt("menu_register")}
        , sellerIdx);
    }

// 메뉴를 등록할 판매자의 가게 Id 
 public int storeIdxBySellerIdx(int sellerIdx){
        String query = "SELECT storeIdx FROM Stores WHERE sellerIdx = ?";

        return this.jdbcTemplate.queryForObject(query,
                (rs, rowNum) -> rs.getInt("storeIdx"), sellerIdx);
   }

// 메인/사이드 메뉴 일괄 등록 쿼리
public int menuRegister(int storeIdx, List<PostMenuUrlItem> mainMenuList, String mOrS)  {
        String query = "INSERT INTO Menu (" +
                "storeIdx, " +
                "menu_name, " +
                "price, " +
                "composition," +
                "description," +
                "menu_url," +
                "status)\n" +
                "VALUES (?,?,?,?,?,?,?);";

            this.jdbcTemplate.batchUpdate(query,
                    mainMenuList,
                    mainMenuList.size(),
                    (PreparedStatement ps, PostMenuUrlItem menuItem) ->{
                        ps.setInt(1, storeIdx);
                        ps.setString(2, menuItem.getMenuName());
                        ps.setInt(3, menuItem.getPrice());
                        ps.setString(4, menuItem.getComposition());
                        ps.setString(5, menuItem.getDescription());
                        ps.setString(6, menuItem.getMenuUrl());
                        ps.setString(7, mOrS);
                    });

        return mainMenuList.size();
    }

// 원산지 일괄등록 쿼리
public int ingredientRegister(int storeIdx, List<PostIngredientItem> ingredientList)  {
        String query ="INSERT INTO Ingredients (storeIdx, ingredient_name, origin, menu_names)\n" +
                "VALUES (?,?,?,?);";

        this.jdbcTemplate.batchUpdate(query,
                ingredientList,
                ingredientList.size(),
                (PreparedStatement ps, PostIngredientItem postIngredientItem) ->{
                    ps.setInt(1, storeIdx);
                    ps.setString(2, postIngredientItem.getIngredientName());
                    ps.setString(3, postIngredientItem.getOrigin());
                    ps.setString(4, postIngredientItem.getMenuName());
                });

        return ingredientList.size();
    }

// 판매자 서비스 이용 가능 상태로 변경
public void registerMenuNIngredient(int sellerIdx){
        String query = "UPDATE Merchandisers\n" +
                "SET menu_register = 0\n" +
                "WHERE sellerIdx = ?";
        this.jdbcTemplate.update(query, sellerIdx);
    }

테스트

테스트는 API요청이 아닌 프론트화면으로 진행해보겠다.

1. 로그인 시 관리자 승인이 아직 안 났을때, 메뉴를 등록 할 수 없다.

• 
• 

2. 임의로 DB 값을 수정하여 가게 승인을 완료한 후, 메뉴 등록화면 이동

• 메인 메뉴 등록란
  
• 사이드 메뉴 등록란
  
• 이미지 등록과정
  
• 등록 준비완료
  
• 원산지 등록 준비완료
  

3. 메뉴 등록 완료하기 후 DB상태를 확인해 보겠다.

잘 들어옴

개발후 느꼈던 점

이전 포스팅에서 작성했듯 S3 기능을 맨 처음에 달지 않았었는데, 이미지 처리를 프론트에서 하는 줄 알았다..ㅎㅎ
프론트에서 이미지를 그대로 보낸다고해서 구글링을 해보니 AWS S3를 통해서 URL을 만들 수 있다는 사실을 알게 되었고, 프론트에서 보내주는 이미지 파일을 S3 버킷에 등록하여, 서비스를 구현하기로 하였다.

---

2. [GET] /jat/menus

등록한 메뉴 조회

• 메뉴 등록 후 떨이메뉴화면에서 보이는 메뉴는 따로 만들기로하였다.
• 메뉴 수정시 등록한 메뉴를 확인하기 위한 API 기능이다.

로직 플로우
1. JWT 토큰에 들어있는 판매자 식별자를 통해 가게의 메뉴를 조회한다!
2. 메뉴를 조회할때 필요한 이미지의 URL을 서버에서 만들어서 결과에 같이 포함함!

• 응답 바디
  메뉴 Idx를 반환하는 이유는 수정시에 어느 메뉴를 수정했는지 식별하기 위함!
  

• MenuController.java
  

• MenuService.java

1. 모든 서비스 이용이 가능한 판매자인지 우선 확인, 확인 후 사용자의 가게에 등록된 메뉴를 확인하기 위해 가게 Idx 가져오기

    public GetMenuItemsRes getStoreMenuList(int sellerIdx) throws BaseException {
        int[] loginStatus = sellerDao.checkRegisterd(sellerIdx);
        if(loginStatus[0] != 0 && loginStatus[1] != 0){
            throw new BaseException(STORE_REGISTER_NOT_PERMITTED); // 4035 : 관리자에게 가게 승인되지 않은 판매자 계정입니다.
        }

        // 1) 사용자 가게 조회
        int storeIdx;
        try{
            storeIdx = storeDao.storeIdxBySellerIdx(sellerIdx);
        } catch (Exception e) {
            throw new BaseException(POST_STORES_NOT_REGISTERD); // 2030 : 사용자의 가게가 등록되어있지 않습니다.
        }

2. 메인/사이드 메뉴 기본정보 조회,
   메뉴의 이미지를 가져오는 방법 : DB에 등록되어있는 메뉴 도메인에 S3버킷에 등록되어있는 해당 메뉴의 이미지 Key값을 가져와서 S3에 URL을 요청한다. 응답받으면 응답 바디에 값을 넣어서 클라이언트에 응답

        List<GetMenuItem> mainMenuList, sideMenuList;
        // 2) 메인 메뉴 조회
        try{
            mainMenuList = menuDao.getStoreMenuList(storeIdx, "M");
        }catch (Exception e) {
            throw new BaseException(GET_MENU_ERROR);
        }

        // 메인 메뉴 url 가져오기
        try{
            for(GetMenuItem item : mainMenuList){
                if (item.getMenuUrl() != null && !item.getMenuUrl().equals("")) {
                    item.setMenuUrl(""+s3Client.getUrl(bucketName, item.getMenuUrl()));
                }
            }
        }catch (Exception e) {
            throw new BaseException(GET_MENU_ERROR);
        }

        // 3) 사이드 메뉴 조회
        try{
            sideMenuList = menuDao.getStoreMenuList(storeIdx, "S");
        }catch (Exception e) {
            throw new BaseException(GET_MENU_ERROR);
        }

        // 사이드 메뉴 url 가져오기
        try{
            for(GetMenuItem item : sideMenuList){
                if (item.getMenuUrl() != null && !item.getMenuUrl().equals("")) {
                    item.setMenuUrl(""+s3Client.getUrl(bucketName, item.getMenuUrl()));
                }
            }
        }catch (Exception e) {
            throw new BaseException(GET_MENU_ERROR);
        }

        return new GetMenuItemsRes(storeIdx, mainMenuList, sideMenuList);

    }

• MenuDao.java

// 가게 등록 여부 확인 first_login = 0, menu_register = 0  일때 가게, 메뉴등록 모두 완료한 판매자
	public int[] checkRegisterd(int sellerIdx) {
        String query = "SELECT " +
                "first_login, menu_register " +
                "FROM Merchandisers " +
                "WHERE sellerIdx = ?";
        return this.jdbcTemplate.queryForObject(query,
                (rs, rowNum) -> new int[]{
                        rs.getInt("first_login"),
                        rs.getInt("menu_register")}
        , sellerIdx);
    }

// 메뉴를 조회하기 위한 사용자의 가게 Idx 가져오기
    public int storeIdxBySellerIdx(int sellerIdx){
        String query = "SELECT storeIdx FROM Stores WHERE sellerIdx = ?";

        return this.jdbcTemplate.queryForObject(query,
                (rs, rowNum) -> rs.getInt("storeIdx"), sellerIdx);
    }

// 메뉴 기본정보 조회 (메뉴Idx, 메뉴 이름, 가격, 구성, 설명, 메뉴 S3 키값)
    public List<GetMenuItem> getStoreMenuList(int storeIdx, String status) {
        String query = "SELECT menuIdx, menu_name, price, composition, description, menu_url\n" +
                "FROM Menu WHERE storeIdx = ? AND status = ?";

        Object[] params = new Object[]{storeIdx, status};

        return this.jdbcTemplate.query(query,
                (rs, rowNum) -> new GetMenuItem(
                        rs.getInt("menuIdx"),
                        rs.getString("menu_name"),
                        rs.getInt("price"),
                        rs.getString("composition"),
                        rs.getString("description"),
                        rs.getString("menu_url"),
                        0
                ), params);
    }

테스트

잘됨.

---

3. [Patch] /jat/menus

메인/사이드 메뉴 수정

• 메뉴/사이드 메뉴를 조회시 받았던 Idx 값을 통해 서버에 수정상태 값을 추가하여 Body 에 담아 수정을 요청한다!
• 수정에 대한 값을 4가지로 구분
  0: 수정안하고 그대로 유지하는 메뉴
  1: 수정할 메뉴
  2: 삭제할 메뉴
  3: 새로운 메뉴

(1 )로직 플로우
1. 수정 정보가 담긴 메뉴 목록을 Body에 담아 서버로 요청
2. 서버에서 사용자의 가게를 조회한다.
3. 각 메뉴에 따라서 수정, 삭제, 추가할 메뉴를 분리한다.
4. 분리한 메뉴 목록들을 DB에 각각 수정, 생성 쿼리를 보낸다

• 요청 바디

• 응답 바디

• MenuController.java
  

• MenuService.java

1. 올바른 접근의 사용자인지 확인, 각 메뉴 수정사항을 확인하여 분리

    @Transactional(rollbackFor = BaseException.class)
    public PatchMenuRes menuUpdate(int sellerIdx, PatchMenuReq postMenuReq) throws BaseException{
        // 1)사용자 가게 조회
        int storeIdx;
        try{
            storeIdx = storeDao.storeIdxBySellerIdx(sellerIdx);
        } catch (Exception e) {
            throw new BaseException(POST_STORES_NOT_REGISTERD); // 2030 : 사용자의 가게가 등록되어있지 않습니다.
        }

        // 0: 수정안하고 그대로 유지메뉴
        // 1: 수정할 메뉴
        // 2: 삭제할 메뉴
        // 3: 새로운 메뉴
        List<PostMenuItem> newMainMenu = new ArrayList<>(), newSideMenu = new ArrayList<>();
        List<PatchMenuItem> updMainMenu = new ArrayList<>(), updSideMenu = new ArrayList<>();
        List<PatchMenuItem> delMainMenu = new ArrayList<>(), delSideMenu = new ArrayList<>();
        int newMainCnt = 0, newSideCnt = 0;
        int updMainCnt = 0, updSideCnt = 0;
        int delMainCnt = 0, delSideCnt = 0;

        // 2-M) 수정/삭제/신규등록 할 메인 메뉴 분리
        if(postMenuReq.getMainMenuItems() != null){
            //ystem.out.println("main");
            for(PatchMenuItem item : postMenuReq.getMainMenuItems()){
                if (item.getIsUpdated() == 0){
                    continue;
                }else if(item.getIsUpdated() == 3){ // 3: 새로운 메뉴
                    newMainMenu.add(new PostMenuItem(item.getMenuName(), item.getPrice(),
                            item.getComposition(),item.getDescription(),item.getMenuUrl()));
                    newMainCnt ++;
                }else if(item.getIsUpdated() == 2){ // 2: 삭제할 메뉴
                    delMainMenu.add(item);
                    delMainCnt++;
                }else if(item.getIsUpdated() == 1){ // 1: 수정할 메뉴
                    updMainMenu.add(new PatchMenuItem(item.getMenuIdx(), item.getMenuName(), item.getPrice(),
                            item.getComposition(),item.getDescription(),item.getMenuUrl(), item.getIsUpdated()));
                    updMainCnt++;
                }
            }
        }
        // 2-S) 수정/삭제/신규등록 할 사이드 메뉴 분리
        if(postMenuReq.getSideMenuItems() != null){
            //System.out.println("side");
            for(PatchMenuItem item : postMenuReq.getSideMenuItems()){
                if (item.getIsUpdated() == 0) {
                    continue;
                } else if(item.getIsUpdated() == 3){
                    newSideMenu.add(new PostMenuItem(item.getMenuName(), item.getPrice(),
                            item.getComposition(),item.getDescription(),item.getMenuUrl()));
                    newSideCnt++;
                } else if(item.getIsUpdated() == 2){
                    delSideMenu.add(item);
                    delSideCnt++;
                }else if(item.getIsUpdated() == 1){
                    updSideMenu.add(new PatchMenuItem(item.getMenuIdx(), item.getMenuName(), item.getPrice(),
                            item.getComposition(),item.getDescription(),item.getMenuUrl(), item.getIsUpdated()));
                    updSideCnt++;
                }
            }
        }

2. 각 수정, 신규 메뉴 Url 담을 리스트

        List<PostMenuUrlItem> urlItemsNew = null;
        List<PatchMenuUrlItem> urlItemsUpd = null;

3. 메뉴 신규 등록
   여기서도 배치 Update를 사용하였는데 배치 업데이트의 반환값인 2차원배열의 값이 예상한대로 나오지 않아서 서비스 흐름을 끊지 않기 위해 검증 로직을 주석처리해놨다..
   ex) 등록 2개 : int[] = { {1}, {2} } 이렇게 일줄 알았는데 { {1, 2} } 이런식으로 나옴..

        // 3-M) 메인 메뉴 신규등록
        try{
            if(newMainMenu != null && newMainMenu.size() != 0){
                urlItemsNew = convertToUrlFileNames(newMainMenu);
                int newComplete = menuDao.menuRegister(storeIdx, urlItemsNew, "M");
                /*if (newMainCnt != newComplete)
                    throw new Exception();*/
            }
        }catch (Exception e){
            throw new BaseException(STORE_MAINMENU_SAVE_ERROR);
        }

        // 3-S) 사이드 메뉴 신규등록
        try{
            if(newSideMenu != null && newSideMenu.size() != 0){
                urlItemsNew = convertToUrlFileNames(newSideMenu);
                int newComplete = menuDao.menuRegister(storeIdx, urlItemsNew, "S");
                /*if (newSideCnt != newComplete)
                    throw new Exception();*/
            }
        }catch (Exception e){
            throw new BaseException(STORE_SIDEMENU_SAVE_ERROR);
        }

4. 메뉴 수정
   같은 이유로 주석 처리

        // 4-M) 메인 메뉴 수정
        try{
            if(updMainMenu != null && updMainMenu.size() != 0){
                urlItemsUpd =convertToUrlFileNamesUpd(updMainMenu);
                int updComplete = menuDao.menuUpdate(urlItemsUpd);
                /*if (updMainCnt != updComplete)
                    throw new Exception();*/
            }
        }catch (Exception e){
            throw new BaseException(STORE_MAINMENU_SAVE_ERROR);
        }
        // 4-S) 사이드 메뉴 수정
        try{
            if(updSideMenu != null && updSideMenu.size() != 0){
                urlItemsUpd =convertToUrlFileNamesUpd(updSideMenu);
                int updComplete = menuDao.menuUpdate(urlItemsUpd);
                /*if (updMainCnt != updComplete)
                    throw new Exception();*/
            }
        }catch (Exception e){
            throw new BaseException(STORE_SIDEMENU_SAVE_ERROR);
        }

5. 메뉴 삭제 처리(상테값을 'D'로 수정)

       // 5) 메인메뉴, 사이드 메뉴 삭제
        try{
            if(delMainMenu != null && delMainMenu.size() != 0){
                int delComplete = menuDao.menuDeActive(delMainMenu);
                /*if (delMainCnt != delComplete)
                    throw new Exception();*/
            }
        }catch (Exception e){
            throw new BaseException(STORE_MAINMENU_SAVE_ERROR);
        }
        try{
            if(delSideMenu != null && delSideMenu.size() != 0){
                int delComplete = menuDao.menuDeActive(delSideMenu);
                /*if (delSideCnt != delComplete)
                    throw new Exception();*/
            }
        }catch (Exception e){
            throw new BaseException(STORE_SIDEMENU_SAVE_ERROR);
        }

6. 결과 반환 : 처리된 값들을 모두 개수로 카운트한 결과

        return new PatchMenuRes(storeIdx,
                (postMenuReq.getMainMenuItems() != null ?  postMenuReq.getMainMenuItems().size(): 0)
                +(postMenuReq.getSideMenuItems() != null ?  postMenuReq.getSideMenuItems().size(): 0),
                newMainCnt,
                updMainCnt,
                newSideCnt,
                updSideCnt
                );
    }

• MenuDao.java

// 메뉴 등록 일과 쿼리
    public int menuRegister(int storeIdx, List<PostMenuUrlItem> mainMenuList, String mOrS)  {
        String query = "INSERT INTO Menu (" +
                "storeIdx, " +
                "menu_name, " +
                "price, " +
                "composition," +
                "description," +
                "menu_url," +
                "status)\n" +
                "VALUES (?,?,?,?,?,?,?);";

            this.jdbcTemplate.batchUpdate(query,
                    mainMenuList,
                    mainMenuList.size(),
                    (PreparedStatement ps, PostMenuUrlItem menuItem) ->{
                        ps.setInt(1, storeIdx);
                        ps.setString(2, menuItem.getMenuName());
                        ps.setInt(3, menuItem.getPrice());
                        ps.setString(4, menuItem.getComposition());
                        ps.setString(5, menuItem.getDescription());
                        ps.setString(6, menuItem.getMenuUrl());
                        ps.setString(7, mOrS);
                    });

        return mainMenuList.size();
    }

// 메뉴 수정 일괄 쿼리 (반환 : 2차원 배열 행 개수)
    public int menuUpdate(List<PatchMenuUrlItem> menuItems){
        String query= "UPDATE Menu\n" +
                "SET menu_name = ?,\n" +
                "    price = ?,\n" +
                "    composition = ?,\n" +
                "    description = ?, \n" +
                "    menu_url = ? \n" +
                "WHERE menuIdx = ?";

        return this.jdbcTemplate.batchUpdate(query,
                menuItems,
                menuItems.size(),
                (PreparedStatement ps, PatchMenuUrlItem item) ->{
                    ps.setString(1, item.getMenuName());
                    ps.setInt(2, item.getPrice());
                    ps.setString(3, item.getComposition());
                    ps.setString(4, item.getDescription());
                    ps.setString(5, item.getMenuUrl());
                    ps.setInt(6, item.getMenuIdx());
                }
        ).length;
    }

// 메뉴 삭제 일괄 쿼리(상태값 'D')로 변경
    public int menuDeActive(List<PatchMenuItem> menuItems){
        String query = "UPDATE Menu\n" +
                "SET status = 'D'\n" +
                "WHERE menuIdx = ?";

        return this.jdbcTemplate.batchUpdate(query,
                menuItems,
                menuItems.size(),
                (PreparedStatement ps, PatchMenuItem item) ->{
                    ps.setInt(1, item.getMenuIdx());
                }
        ).length;
    }

테스트

1. 항목 추가하기 클릭

2. 수정 및 신규등록

맛살샌드위치빵 가격 5000 -> 4500, 꿀토스트식빵 신규등록

3. 하단 메뉴 수정 버튼 클릭

4. 화면 및 DB확인

• 새로고침 해서 조회가 잘되고,
• DB에도 값이 올바르게 적용된 모습

---

느낀점

• S3에 대한 전반적인 서비스를 확인할 수 있었고,
• 수정시에는 S3버킷에 값을 가져와서 다시 입력하는 것이 아니라, 원래 들어있던 버킷의 키값을 삭제하고 새로운 파일 이름을 만들어서 버킷에 새로 등록하는 방식으로 하였다.
• 왜냐면 수정하게되면, 이전 이미지는 더미로 버킷에 들어있게 되기 때문..
• 각 수정을 위해서 조회시 미리 해당 메뉴에 대한 Idx를 주면서 수정할 준비를 미리 하도록 함!
• 이를 잘 이해하도록 명세서에 명시해서 프론트랑 같이 협의를 잘 마칠 수 있었다.