フロントエンド側とAPI通信を行うControllerの作成-SpringBoot入門⑨

package com.ozack.todoapp.service.authority;

import java.util.List;

import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ozack.todoapp.exception.DeleteException;
import com.ozack.todoapp.exception.InsertException;
import com.ozack.todoapp.exception.TodoAppException;
import com.ozack.todoapp.exception.UpdateException;
import com.ozack.todoapp.repository.AuthorityRepository;
import com.ozack.todoapp.repository.entity.Authority;

/* 権限に関する処理を行うサービス */
@Service
public class AuthorityServiceImpl implements AuthorityService {

    private final String loadErrorMessage = "authority テーブルのデータ取得に失敗しました。";
    private final String insertErrorMessageByDataAccess = "authority データ登録時にデータベース関連のエラーが発生しました。";
    private final String updateErrorMessageByDataAccess = "authority データ更新時にデータベース関連のエラーが発生しました。";
    private final String deleteErrorMessageByLoad = "authority データを削除できませんでした。";

    private final AuthorityRepository authorityRepository;

    public AuthorityServiceImpl(AuthorityRepository authorityRepository) {
        this.authorityRepository = authorityRepository;
    }

    /* 全ての権限一覧を取得するメソッド */
    public List<Authority> selectAllAuthorities() {
        return authorityRepository.findAll();
    }

    /* データを登録するメソッド */
    @Transactional(rollbackFor = TodoAppException.class)
    public Authority insertAuthority(Authority authority) throws TodoAppException {
        try {
            authorityRepository.save(authority);
            Authority res = authorityRepository.findById(authority.getId()).orElse(null);
            if (res == null) throw new InsertException(loadErrorMessage);
            return res;
        } catch (DataAccessException e) {
            throw new InsertException(insertErrorMessageByDataAccess, e);
        }
    }

    /* データを更新するメソッド */
    @Transactional(rollbackFor = TodoAppException.class)
    public Authority updateAuthority(Authority authority) throws TodoAppException {
        try {
            authorityRepository.save(authority);
            Authority res = authorityRepository.findById(authority.getId()).orElse(null);
            if (res == null) throw new UpdateException(loadErrorMessage);
            return res;
        } catch (DataAccessException e) {
            throw new UpdateException(updateErrorMessageByDataAccess, e);
        }
    }

    /* データを削除するメソッド */
    @Transactional(rollbackFor = TodoAppException.class)
    public void deleteAuthority(Long authorityId) throws TodoAppException {
        authorityRepository.deleteById(authorityId);
        Authority res = authorityRepository.findById(authorityId).orElse(null);
        if (res != null) throw new DeleteException(deleteErrorMessageByLoad);
    }

}

package com.ozack.todoapp.service.category;

import java.util.List;

import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ozack.todoapp.exception.DeleteException;
import com.ozack.todoapp.exception.InsertException;
import com.ozack.todoapp.exception.TodoAppException;
import com.ozack.todoapp.exception.UpdateException;
import com.ozack.todoapp.repository.CategoryRepository;
import com.ozack.todoapp.repository.entity.Category;

/* カテゴリーに関する処理を行うサービス */
@Service
public class CategoryServiceImpl implements CategoryService {

    private final String loadErrorMessage = "category テーブルのデータ取得に失敗しました。";
    private final String insertErrorMessageByDataAccess = "category データ登録時にデータベース関連のエラーが発生しました。";
    private final String updateErrorMessageByDataAccess = "category データ更新時にデータベース関連のエラーが発生しました。";
    private final String deleteErrorMessageByLoad = "category データを削除できませんでした。";

    private final CategoryRepository categoryRepository;

    public CategoryServiceImpl(CategoryRepository categoryRepository) {
        this.categoryRepository = categoryRepository;
    }

    /* 全てのカテゴリー一覧を取得するメソッド */
    @Override
    public List<Category> selectAllCategories() {
        return categoryRepository.findAll();
    }

    /* データを登録するメソッド */
    @Override
    @Transactional(rollbackFor = TodoAppException.class)
    public Category insertCategory(Category category) throws TodoAppException {
        try {
            categoryRepository.save(category);
            Category res = categoryRepository.findById(category.getId()).orElse(null);
            if (res == null) throw new InsertException(loadErrorMessage);
            return res;
        } catch (DataAccessException e) {
            throw new InsertException(insertErrorMessageByDataAccess, e);
        }
    }

    /* データを更新するメソッド */
    @Override
    @Transactional(rollbackFor = TodoAppException.class)
    public Category updateCategory(Category category) throws TodoAppException {
        try {
            categoryRepository.save(category);
            Category res = categoryRepository.findById(category.getId()).orElse(null);
            if (res == null) throw new UpdateException(loadErrorMessage);
            return res;
        } catch (DataAccessException e) {
            throw new UpdateException(updateErrorMessageByDataAccess, e);
        }
    }

    /* データを削除するメソッド */
    @Override
    @Transactional(rollbackFor = TodoAppException.class)
    public void deleteCategory(Long categoryId) throws TodoAppException {
        categoryRepository.deleteById(categoryId);
        Category res = categoryRepository.findById(categoryId).orElse(null);
        if (res != null) throw new DeleteException(deleteErrorMessageByLoad);
    }

}

package com.ozack.todoapp.service.todo;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ozack.todoapp.dto.response.ResponseTodoCategoryDto;
import com.ozack.todoapp.dto.response.ResponseTodoDto;
import com.ozack.todoapp.exception.DeleteException;
import com.ozack.todoapp.exception.InsertException;
import com.ozack.todoapp.exception.TodoAppException;
import com.ozack.todoapp.exception.UpdateException;
import com.ozack.todoapp.repository.TodoRepository;
import com.ozack.todoapp.repository.entity.Category;
import com.ozack.todoapp.repository.entity.Todo;

/* カテゴリーに関する処理を行うサービス */
@Service
public class TodoServiceImpl implements TodoService {

    private final String loadErrorMessage = "todo テーブルのデータ取得に失敗しました。";
    private final String insertErrorMessageByDataAccess = "todo データ登録時にデータベース関連のエラーが発生しました。";
    private final String updateErrorMessageByDataAccess = "todo データ更新時にデータベース関連のエラーが発生しました。";
    private final String deleteErrorMessageByLoad = "todo データを削除できませんでした。";

    private final TodoRepository todoRepository;

    public TodoServiceImpl(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }

    /* 全てのカテゴリー一覧を取得するメソッド */
    public List<ResponseTodoDto> selectAllTodosByUserIdWithCategories(Long userId) {
        List<Todo> res = todoRepository.findAllByUserIdWithCategories(userId);
        return convertResponseTodoDto(res);
    }

    /* データを登録するメソッド */
    @Transactional(rollbackFor = TodoAppException.class)
    public ResponseTodoDto insertTodo(Todo todo) throws TodoAppException {
        try {
            Todo resTodo = todoRepository.save(todo);
            if (resTodo == null) throw new InsertException(loadErrorMessage);
            // Dto 変換
            ResponseTodoDto res = new ResponseTodoDto(
                resTodo.getId(),
                resTodo.getTitle(),
                resTodo.getIsCheck(),
                null // フロント側で結合するため null で返却
            );
            return res;
        } catch (DataAccessException e) {
            throw new InsertException(insertErrorMessageByDataAccess, e);
        }
    }

    /* データを更新するメソッド */
    @Transactional(rollbackFor = TodoAppException.class)
    public ResponseTodoDto updateTodo(Todo todo) throws TodoAppException {
        try {
            Todo resTodo = todoRepository.save(todo);
            if (resTodo == null) throw new UpdateException(loadErrorMessage);
            // Dto 変換
            ResponseTodoDto res = new ResponseTodoDto(
                resTodo.getId(),
                resTodo.getTitle(),
                resTodo.getIsCheck(),
                null // フロント側で結合するため null で返却
            );
            return res;
        } catch (DataAccessException e) {
            throw new UpdateException(updateErrorMessageByDataAccess, e);
        }
    }

    /* データを削除するメソッド */
    @Transactional(rollbackFor = TodoAppException.class)
    public void deleteTodo(Long todoId) throws TodoAppException {
        todoRepository.deleteById(todoId);
        Todo res = todoRepository.findById(todoId).orElse(null);
        if (res != null) throw new DeleteException(deleteErrorMessageByLoad);
    }

    /* リスト型の Todo エンティティをリスト型の Dto に変換するメソッド */
    public List<ResponseTodoDto> convertResponseTodoDto(List<Todo> todos) {
        return todos.stream()
                    .map(todo -> new ResponseTodoDto(
                            todo.getId(),
                            todo.getTitle(),
                            todo.getIsCheck(),
                            todo.getTodoCategories() == null ? new ArrayList<>() : // カテゴリーが設定されてない場合は空リストを設定
                            todo.getTodoCategories()
                                .stream()
                                .sorted(Comparator.comparing(todoCategory -> todoCategory.getCategory().getName())) // 名前順にソート
                                .map(todoCategory -> new ResponseTodoCategoryDto( // カテゴリー型に変換
                                    todoCategory.getId(),
                                    new Category(
                                        todoCategory.getCategoryId(),
                                        todoCategory.getCategory().getName()
                                    )
                                ))
                                .collect(Collectors.toList())
                    ))
                    .collect(Collectors.toList());
    }

}

package com.ozack.todoapp.service.todocategory;

import java.util.List;

import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ozack.todoapp.dto.response.ResponseTodoCategoryDto;
import com.ozack.todoapp.exception.DeleteException;
import com.ozack.todoapp.exception.InsertException;
import com.ozack.todoapp.exception.TodoAppException;
import com.ozack.todoapp.exception.UpdateException;
import com.ozack.todoapp.repository.TodoCategoryRepository;
import com.ozack.todoapp.repository.entity.Category;
import com.ozack.todoapp.repository.entity.TodoCategory;

/* Todo と Category のマッピング情報を処理するサービス */
@Service
public class TodoCategoryServiceImpl implements TodoCategoryService {

    private final String loadErrorMessage = "todo_category テーブルのデータ取得に失敗しました。";
    private final String insertErrorMessageByDataAccess = "todo_category データ登録時にデータベース関連のエラーが発生しました。";
    private final String updateErrorMessageByDataAccess = "todo_category データ更新時にデータベース関連のエラーが発生しました。";
    private final String deleteErrorMessageByLoad = "todo_category データを削除できませんでした。";

    private final TodoCategoryRepository todoCategoryRepository;

    public TodoCategoryServiceImpl(TodoCategoryRepository todoCategoryRepository) {
        this.todoCategoryRepository = todoCategoryRepository;
    }

    /* データを登録するメソッド */
    @Override
    @Transactional(rollbackFor = TodoAppException.class)
    public List<ResponseTodoCategoryDto> insertTodoCategories(List<TodoCategory> todoCategories) throws TodoAppException {
        try {
            List<TodoCategory> resTodoCategories = todoCategoryRepository.saveAll(todoCategories);
            List<ResponseTodoCategoryDto> res = convertResponseTodoCategoryDto(resTodoCategories);
            if (res == null) throw new InsertException(loadErrorMessage);
            return res;
        } catch (DataAccessException e) {
            throw new InsertException(insertErrorMessageByDataAccess, e);
        }
    }

    /* データを更新するメソッド */
    @Override
    @Transactional(rollbackFor = TodoAppException.class)
    public List<ResponseTodoCategoryDto> updateTodoCategories(List<TodoCategory> todoCategories) throws TodoAppException {
        try {
            List<TodoCategory> resTodoCategories = todoCategoryRepository.saveAll(todoCategories);
            List<ResponseTodoCategoryDto> res = convertResponseTodoCategoryDto(resTodoCategories);
            if (res == null) throw new UpdateException(loadErrorMessage);
            return res;
        } catch (DataAccessException e) {
            throw new UpdateException(updateErrorMessageByDataAccess, e);
        }
    }

    /* データを削除するメソッド */
    @Override
    @Transactional(rollbackFor = TodoAppException.class)
    public void deleteTodoCategories(List<Long> todoCategoryIds) throws TodoAppException {
        todoCategoryRepository.deleteAllById(todoCategoryIds);
        List<TodoCategory> res = todoCategoryRepository.findAllById(todoCategoryIds);
        if (!res.isEmpty()) throw new DeleteException(deleteErrorMessageByLoad);
    }

    /* Dto 変換メソッド */
    public List<ResponseTodoCategoryDto> convertResponseTodoCategoryDto(List<TodoCategory> todoCategories) {
        return todoCategories
            .stream()
            .map(todoCategory ->
                new ResponseTodoCategoryDto(
                    todoCategory.getId(),
                    new Category(todoCategory.getCategoryId(), null)
                )
            )
            .toList();
    }

}