[BMOL-30] 책 삭제 기능 - DELETE v1/library/mylist/:bookId 구현

src/controllers/bookShelfController.js

@@ -1,6 +1,7 @@
 const { BookShelfService, MissingRequestParameter } = require("../services");
 
-const bookShelfController = async (ctx) => {
+// 책 등록
+const registerBookController = async (ctx) => {
     const bookShelfService = new BookShelfService();
 
     const {
@@ -56,6 +57,36 @@ const bookShelfController = async (ctx) => {
     ctx.body = await bookShelfService.registerBook(bookData);
 };
 
+// 책 삭제
+const deleteBookController = async (ctx) => {
+    const bookShelfService = new BookShelfService();
+
+    const { bookId } = ctx.params;
+
+    // check if book_id is missing
+    if (!bookId) {
+        throw new MissingRequestParameter("bookId");
+    }
+
+    const user_id = ctx.request.headers.user_id;
+
+    // check user_id value
+    if (!user_id) {
+        throw new MissingRequestParameter("user_id");
+    }
+
+    const bookData = {
+        user_id,
+        book_id: bookId,
+        meta: {
+            requestId: ctx.state.requestId,
+            now: +new Date(),
+        },
+    };
+    ctx.body = await bookShelfService.deleteBook(bookData);
+};
+
 module.exports = {
-    bookShelfController,
+    registerBookController,
+    deleteBookController,
 };

src/dao/bookShelfDao.js

@@ -1,4 +1,8 @@
-const { DuplicateBook } = require("../services/errorService");
+const {
+    DuplicateBook,
+    InvalidUUID,
+    MyBookNotFound,
+} = require("../services/errorService");
 const { BookShelfRepository } = require("./repositories/bookShelfRepository");
 
 class BookShelfDao {
@@ -36,6 +40,29 @@ class BookShelfDao {
 
         return updatedRows;
     }
+
+    async deleteBook(book) {
+        const bookShelfRepo = new BookShelfRepository();
+
+        const { user_id, book_id } = book;
+
+        const checkUser = await bookShelfRepo.getBookByUserId(user_id);
+        if (checkUser.length === 0) {
+            throw new InvalidUUID(user_id);
+        }
+
+        const checkBook = await bookShelfRepo.getBookByBookId(book_id);
+        if (checkBook.length === 0) {
+            throw new MyBookNotFound(book_id);
+        }
+
+        const updatedRows = await bookShelfRepo.deleteBook({
+            user_id,
+            book_id,
+        });
+
+        return updatedRows;
+    }
 }
 
 module.exports = { BookShelfDao };

src/dao/bookTimerDao.js

@@ -1,137 +1,155 @@
-const { BookHistoryRepository } = require('./repositories/bookHistoryRepository')
-const { AccountRepository } = require('./repositories/accountRepository')
-const { BookTimerDecorator } = require('./bookTimerDecorator')
-
-const { MyBookNotFound, InternalServerError, BookHistoryNotFound } = require('../services/errorService')
+const {
+    BookHistoryRepository,
+} = require("./repositories/bookHistoryRepository");
+const { AccountRepository } = require("./repositories/accountRepository");
+const { BookTimerDecorator } = require("./bookTimerDecorator");
+
+const {
+    MyBookNotFound,
+    InternalServerError,
+    BookHistoryNotFound,
+} = require("../services/errorService");
 
 class BookTimerDao {
-    constructor(){
-        this._daoName = 'BookTimerDao'
+    constructor() {
+        this._daoName = "BookTimerDao";
         this._repo = {
             bookHistory: new BookHistoryRepository(),
             account: new AccountRepository(),
-        }
+        };
     }
 
-    get daoName(){
-        return this._daoName
+    get daoName() {
+        return this._daoName;
     }
 
-    async getBookTimerInfoByBookId(bookId){
-        const bookTimerDecorator = new BookTimerDecorator()
+    async getBookTimerInfoByBookId(bookId) {
+        const bookTimerDecorator = new BookTimerDecorator();
 
         const [accountInfo, bookHistoryInfo] = await Promise.all([
             this._repo.account.getAccountByBookId(bookId),
-            this._repo.bookHistory.getBookHistoryListByBookId(bookId)
-        ])
+            this._repo.bookHistory.getBookHistoryListByBookId(bookId),
+        ]);
 
         // deleted book check
-        if (!accountInfo || !bookHistoryInfo){
-            throw new MyBookNotFound(bookId)
+        if (!accountInfo || !bookHistoryInfo) {
+            throw new MyBookNotFound(bookId);
         }
 
-        const bookTimerInfo = bookTimerDecorator.decorateBookTimer(bookId, {accountInfo, bookHistoryInfo})
+        const bookTimerInfo = bookTimerDecorator.decorateBookTimer(bookId, {
+            accountInfo,
+            bookHistoryInfo,
+        });
 
         const result = {
-            data : bookTimerInfo
-        }
-        return result
+            data: bookTimerInfo,
+        };
+        return result;
     }
 
-    async postReadingTimeInfo(bookId, reading_time){
-        const accountRepo = new AccountRepository()
-        const bookHistoryRepo = new BookHistoryRepository()
+    async postReadingTimeInfo(bookId, reading_time) {
+        const accountRepo = new AccountRepository();
+        const bookHistoryRepo = new BookHistoryRepository();
 
-        const accountInfo = await accountRepo.getAccountByBookId(bookId)
+        const accountInfo = await accountRepo.getAccountByBookId(bookId);
         // deleted book check
-        if (!accountInfo){
-            throw new MyBookNotFound(bookId)
+        if (!accountInfo) {
+            throw new MyBookNotFound(bookId);
         }
 
-        const postResult = await bookHistoryRepo.insertReadingTimeByBookId(accountInfo.user_id, bookId, reading_time)
+        const postResult = await bookHistoryRepo.insertReadingTimeByBookId(
+            accountInfo.user_id,
+            bookId,
+            reading_time
+        );
 
         // postResult check
-        if (!postResult || !postResult.length < 0){
-            throw new InternalServerError()
+        if (!postResult || !postResult.length < 0) {
+            throw new InternalServerError();
         }
 
-        const addedBookHistoryResult = await bookHistoryRepo.getBookHistoryByBookHistoryId(postResult[0].id)
+        const addedBookHistoryResult =
+            await bookHistoryRepo.getBookHistoryByBookHistoryId(
+                postResult[0].id
+            );
 
         // if id of added book history is not in table, throw error
-        if (!addedBookHistoryResult){
-            throw new InternalServerError()
+        if (!addedBookHistoryResult) {
+            throw new InternalServerError();
         }
 
         const result = {
-            data : addedBookHistoryResult
-        }
-        return result
+            data: addedBookHistoryResult,
+        };
+        return result;
     }
 
+    async deleteReadingTimeByHistoryId(bookId, bookHistoryId) {
+        const accountRepo = new AccountRepository();
+        const bookHistoryRepo = new BookHistoryRepository();
 
-    async deleteReadingTimeByHistoryId(bookId, bookHistoryId){
-        const accountRepo = new AccountRepository()
-        const bookHistoryRepo = new BookHistoryRepository()
+        const accountInfo = await accountRepo.getAccountByBookId(bookId);
+        const bookHistoryInfo =
+            await bookHistoryRepo.getBookHistoryByBookHistoryId(bookHistoryId);
 
-        const accountInfo = await accountRepo.getAccountByBookId(bookId)
-        const bookHistoryInfo = await bookHistoryRepo.getBookHistoryByBookHistoryId(bookHistoryId)
-
         // deleted book check
-        if (!accountInfo){
-            throw new MyBookNotFound(bookId)
+        if (!accountInfo) {
+            throw new MyBookNotFound(bookId);
         }
 
         // deleted book history check
-        if (!bookHistoryInfo){
-            throw new BookHistoryNotFound(bookId)
+        if (!bookHistoryInfo) {
+            throw new BookHistoryNotFound(bookId);
         }
 
-        const deleteResults = await bookHistoryRepo.removeReadingTimeByBookHistoryId(bookHistoryId)
+        const deleteResults =
+            await bookHistoryRepo.removeReadingTimeByBookHistoryId(
+                bookHistoryId
+            );
+
+        const removedBookHistoryResult =
+            await bookHistoryRepo.getBookHistoryByBookHistoryId(bookHistoryId);
 
-        const removedBookHistoryResult = 
-                        await bookHistoryRepo.getBookHistoryByBookHistoryId(bookHistoryId)
-
         // if id of added book history is in table, throw error
-        if (removedBookHistoryResult){
-            throw new InternalServerError()
+        if (removedBookHistoryResult) {
+            throw new InternalServerError();
         }
 
         const result = {
-            data : deleteResults
-        }
-        return result
+            data: deleteResults,
+        };
+        return result;
     }
 
-    async deleteReadingTimeByBookId(bookId){
-        const accountRepo = new AccountRepository()
-        const bookHistoryRepo = new BookHistoryRepository()
+    async deleteReadingTimeByBookId(bookId) {
+        const accountRepo = new AccountRepository();
+        const bookHistoryRepo = new BookHistoryRepository();
+
+        const accountInfo = await accountRepo.getAccountByBookId(bookId);
 
-        const accountInfo = await accountRepo.getAccountByBookId(bookId)
-
         // deleted book check
-        if (!accountInfo){
-            throw new MyBookNotFound(bookId)
+        if (!accountInfo) {
+            throw new MyBookNotFound(bookId);
         }
-
-        const deleteResults = await bookHistoryRepo.removeReadingTimeByBookId(bookId)
+
+        const deleteResults = await bookHistoryRepo.removeReadingTimeByBookId(
+            bookId
+        );
 
         //id check
-        const removedBookResult = 
-                        await bookHistoryRepo.getBookHistoryListByBookId(bookId)
+        const removedBookResult =
+            await bookHistoryRepo.getBookHistoryListByBookId(bookId);
 
-
         // if id of added book history is in table, throw error
-        if(removedBookResult && removedBookResult.length > 0)
-            throw new InternalServerError()
+        if (removedBookResult && removedBookResult.length > 0) {
+            throw new InternalServerError();
         }
 
-
         const result = {
-            data : deleteResults
-        }
-        return result
-    } 
-
+            data: deleteResults,
+        };
+        return result;
+    }
 }
 
-module.exports = { BookTimerDao }
+module.exports = { BookTimerDao };

src/dao/repositories/bookShelfRepository.js

@@ -17,6 +17,22 @@ class BookShelfRepository {
             .select();
     }
 
+    async getBookByUserId(userId) {
+        return await pgClient("tbl_mybook")
+            .where({
+                user_id: userId,
+            })
+            .select();
+    }
+
+    async getBookByBookId(bookId) {
+        return await pgClient("tbl_mybook")
+            .where({
+                id: bookId,
+            })
+            .select();
+    }
+
     async registerBook(book) {
         const {
             user_id,
@@ -46,6 +62,18 @@ class BookShelfRepository {
 
         return await query;
     }
+
+    async deleteBook(book) {
+        const { user_id, book_id, meta } = book;
+        const query = pgClient("tbl_mybook")
+            .where({
+                user_id: user_id,
+                id: book_id,
+            })
+            .del();
+
+        return await query;
+    }
 }
 
 module.exports = {

src/routes/v1/bookShelfRouteV1.js

@@ -3,7 +3,10 @@ const BookShelfController = require("../../controllers/bookShelfController");
 
 const bookShelfAPIV1 = (root) => {
     const router = Router();
-    router.post("/book", BookShelfController.bookShelfController);
+
+    router.post("/book", BookShelfController.registerBookController); // 책 등록
+    router.delete("/:bookId", BookShelfController.deleteBookController); // 책 삭제
+
     root.use("/library/mylist", router.routes());
 };
 

src/services/bookShelfService.js

@@ -14,6 +14,12 @@ class BookShelfService {
         const updatedRows = await bookShelfDao.registerBook(book);
         return updatedRows;
     }
+
+    async deleteBook(book) {
+        const bookShelfDao = new BookShelfDao();
+        const updatedRows = await bookShelfDao.deleteBook(book);
+        return updatedRows;
+    }
 }
 
 module.exports = { BookShelfService };