trello-cli-unofficial 0.7.6 → 0.8.0

package/src/presentation/cli/CardController.ts

@@ -1,5 +1,7 @@
-import type { CardEntity, ListEntity } from '@domain/entities';
+import type { BoardEntity, CardEntity, ListEntity } from '@domain/entities';
 import type { TrelloRepository } from '@domain/repositories';
+import type { BoardController } from './BoardController';
+import type { OutputFormatter } from '@/shared';
 
 import {
   CreateCardUseCase,
@@ -20,7 +22,8 @@ export class CardController {
 
   constructor(
     private trelloRepository: TrelloRepository,
-    private boardController: unknown, // Will be injected to avoid circular dependency
+    private boardController: BoardController, // Will be injected to avoid circular dependency
+    private outputFormatter: OutputFormatter,
   ) {
     this.createCardUseCase = new CreateCardUseCase(trelloRepository);
     this.updateCardUseCase = new UpdateCardUseCase(trelloRepository);
@@ -29,28 +32,28 @@ export class CardController {
   }
 
   async createCardInteractive(): Promise<void> {
-    const boards = await (this.boardController as any).getBoards();
+    const boards = await this.boardController.getBoards();
 
     const { selectedBoard } = await inquirer.prompt([
       {
         type: 'list',
         name: 'selectedBoard',
         message: t('card.selectBoard'),
-        choices: boards.map((board: any) => ({
+        choices: boards.map((board: BoardEntity) => ({
           name: board.name,
           value: board.id,
         })),
       },
     ]);
 
-    const lists = await (this.boardController as any).getLists(selectedBoard);
+    const lists = await this.boardController.getLists(selectedBoard);
 
     const { selectedList } = await inquirer.prompt([
       {
         type: 'list',
         name: 'selectedList',
         message: t('card.selectList'),
-        choices: lists.map((list: any) => ({
+        choices: lists.map((list: ListEntity) => ({
           name: list.name,
           value: list.id,
         })),
@@ -62,7 +65,8 @@ export class CardController {
         type: 'input',
         name: 'cardName',
         message: t('card.enterName'),
-        validate: input => input.length > 0 || 'Nome é obrigatório',
+        validate: input =>
+          input.length > 0 || t('card.validation.requiredName'),
       },
       {
         type: 'input',
@@ -92,7 +96,7 @@ export class CardController {
       },
     ]);
 
-    const cards = await (this.boardController as any).getCards(selectedList);
+    const cards = await this.boardController.getCards(selectedList);
 
     if (cards.length === 0) {
       console.log(t('card.emptyList'));
@@ -100,18 +104,20 @@ export class CardController {
     }
 
     console.log(
-      `🃏 Cartões em "${lists.find(l => l.id === selectedList)?.name}":`,
+      t('card.cardsInList', {
+        listName: lists.find(l => l.id === selectedList)?.name,
+      }),
     );
-    cards.forEach((card: any, index: number) => {
+    cards.forEach((card: CardEntity, index: number) => {
       console.log(`${index + 1}. ${card.name}`);
       if (card.desc) {
         const desc
           = card.desc.length > 100
             ? `${card.desc.substring(0, 100)}...`
             : card.desc;
-        console.log(`   📝 ${desc}`);
+        console.log(t('card.cardDescription', { description: desc }));
       }
-      console.log(`   🔗 ${card.url}\n`);
+      console.log(`${t('card.cardUrl', { url: card.url })}\n`);
     });
 
     // Opções adicionais
@@ -124,7 +130,7 @@ export class CardController {
           { name: t('card.actions.back'), value: CARD_ACTIONS.BACK },
           { name: t('card.actions.edit'), value: CARD_ACTIONS.EDIT },
           { name: t('card.actions.delete'), value: CARD_ACTIONS.DELETE },
-          { name: '📦 Mover cartão', value: CARD_ACTIONS.MOVE },
+          { name: t('card.actions.moveCard'), value: CARD_ACTIONS.MOVE },
         ],
       },
     ]);
@@ -135,14 +141,16 @@ export class CardController {
           type: 'list',
           name: 'selectedCard',
           message: t('card.selectCard'),
-          choices: cards.map((card: any) => ({
+          choices: cards.map((card: CardEntity) => ({
             name: card.name,
             value: card.id,
           })),
         },
       ]);
 
-      const selectedCardEntity = cards.find((c: any) => c.id === selectedCard)!;
+      const selectedCardEntity = cards.find(
+        (c: CardEntity) => c.id === selectedCard,
+      )!;
 
       switch (nextAction) {
         case CARD_ACTIONS.EDIT:
@@ -195,7 +203,7 @@ export class CardController {
     ]);
 
     if (confirm) {
-      await this.deleteCard(cardId, card);
+      await this.deleteCard(cardId);
     }
   }
 
@@ -226,15 +234,15 @@ export class CardController {
     cardName: string,
     description?: string,
   ): Promise<void> {
-    const boards = await (this.boardController as any).getBoards();
-    const board = boards.find((b: any) => b.name === boardName);
+    const boards = await this.boardController.getBoards();
+    const board = boards.find((b: BoardEntity) => b.name === boardName);
 
     if (!board) {
       throw new Error(t('board.notFound', { name: boardName }));
     }
 
-    const lists = await (this.boardController as any).getLists(board.id);
-    const list = lists.find((l: any) => l.name === listName);
+    const lists = await this.boardController.getLists(board.id);
+    const list = lists.find((l: ListEntity) => l.name === listName);
 
     if (!list) {
       throw new Error(t('list.notFound', { listName, boardName }));
@@ -255,20 +263,22 @@ export class CardController {
   async moveCard(cardId: string, targetListName: string): Promise<void> {
     // Primeiro precisamos encontrar em qual board o cartão está
     // Para isso, vamos buscar todas as listas de todos os boards
-    const boards = await (this.boardController as any).getBoards();
+    const boards = await this.boardController.getBoards();
 
     for (const board of boards) {
-      const lists = await (this.boardController as any).getLists(board.id);
+      const lists = await this.boardController.getLists(board.id);
 
       // Verificar se alguma lista contém o cartão
       for (const list of lists) {
         try {
-          const cards = await (this.boardController as any).getCards(list.id);
-          const card = cards.find((c: any) => c.id === cardId);
+          const cards = await this.boardController.getCards(list.id);
+          const card = cards.find((c: CardEntity) => c.id === cardId);
 
           if (card) {
             // Encontrou o cartão! Agora procurar a lista de destino
-            const targetList = lists.find((l: any) => l.name === targetListName);
+            const targetList = lists.find(
+              (l: ListEntity) => l.name === targetListName,
+            );
 
             if (!targetList) {
               throw new Error(
@@ -295,38 +305,152 @@ export class CardController {
     throw new Error(t('card.notFound', { cardId }));
   }
 
-  async deleteCard(cardId: string, card?: CardEntity): Promise<void> {
-    // Se não passou o card, tentar encontrar
+  async deleteCard(cardId: string): Promise<void> {
+    // Primeiro precisamos encontrar o cartão para mostrar informações
+    const boards = await this.trelloRepository.getBoards();
+    let card: CardEntity | undefined;
+
+    for (const board of boards) {
+      const lists = await this.trelloRepository.getLists(board.id);
+
+      for (const list of lists) {
+        try {
+          const cards = await this.trelloRepository.getCards(list.id);
+          card = cards.find((c: CardEntity) => c.id === cardId);
+
+          if (card) {
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+      if (card) {
+        break;
+      }
+    }
+
     if (!card) {
-      const boards = await (this.boardController as any).getBoards();
+      throw new Error(t('card.notFound', { cardId }));
+    }
+
+    await this.deleteCardUseCase.execute(cardId);
+    console.log(t('card.deleted'));
+    console.log(t('card.cardName', { name: card.name }));
+  }
+
+  async createCardByListId(
+    listId: string,
+    cardName: string,
+    description?: string,
+  ): Promise<void> {
+    const newCard = await this.createCardUseCase.execute({
+      name: cardName,
+      desc: description || '',
+      listId,
+    });
+
+    console.log(t('card.created'));
+    console.log(t('card.cardName', { name: newCard.name }));
+    console.log(t('card.cardUrl', { url: newCard.url }));
+    console.log(t('card.cardId', { id: newCard.id }));
+  }
 
-      for (const board of boards) {
-        const lists = await (this.boardController as any).getLists(board.id);
+  async updateCard(
+    cardId: string,
+    name?: string,
+    desc?: string,
+  ): Promise<void> {
+    // Primeiro precisamos encontrar o cartão para mostrar informações
+    const boards = await this.trelloRepository.getBoards();
+    let card: CardEntity | undefined;
 
-        for (const list of lists) {
-          try {
-            const cards = await (this.boardController as any).getCards(list.id);
-            card = cards.find((c: any) => c.id === cardId);
+    for (const board of boards) {
+      const lists = await this.trelloRepository.getLists(board.id);
 
-            if (card) {
-              break;
-            }
-          } catch {
-            continue;
+      for (const list of lists) {
+        try {
+          const cards = await this.trelloRepository.getCards(list.id);
+          card = cards.find((c: CardEntity) => c.id === cardId);
+
+          if (card) {
+            break;
           }
+        } catch {
+          continue;
         }
-        if (card) {
-          break;
+      }
+      if (card) {
+        break;
+      }
+    }
+
+    if (!card) {
+      throw new Error(t('card.notFound', { cardId }));
+    }
+
+    const updateData: { name?: string; desc?: string } = {};
+    if (name !== undefined) {
+      updateData.name = name;
+    }
+    if (desc !== undefined) {
+      updateData.desc = desc;
+    }
+
+    const updatedCard = await this.updateCardUseCase.execute(
+      cardId,
+      updateData,
+    );
+    console.log(t('card.updated'));
+    console.log(t('card.cardName', { name: updatedCard.name }));
+  }
+
+  async moveCardToList(cardId: string, targetListId: string): Promise<void> {
+    // Primeiro precisamos encontrar o cartão para mostrar informações
+    const boards = await this.trelloRepository.getBoards();
+    let card: CardEntity | undefined;
+
+    for (const board of boards) {
+      const lists = await this.trelloRepository.getLists(board.id);
+
+      for (const list of lists) {
+        try {
+          const cards = await this.trelloRepository.getCards(list.id);
+          card = cards.find((c: CardEntity) => c.id === cardId);
+
+          if (card) {
+            break;
+          }
+        } catch {
+          continue;
         }
       }
+      if (card) {
+        break;
+      }
+    }
+
+    if (!card) {
+      throw new Error(t('card.notFound', { cardId }));
+    }
 
-      if (!card) {
-        throw new Error(t('card.notFound', { cardId }));
+    // Verificar se a lista de destino existe procurando em todos os boards
+    let targetList: ListEntity | undefined;
+    for (const board of boards) {
+      const lists = await this.trelloRepository.getLists(board.id);
+      targetList = lists.find((l: ListEntity) => l.id === targetListId);
+      if (targetList) {
+        break;
       }
     }
 
-    await this.deleteCardUseCase.execute(cardId);
-    console.log(t('card.deleted'));
+    if (!targetList) {
+      throw new Error(t('list.notFound', { listId: targetListId }));
+    }
+
+    await this.moveCardUseCase.execute(cardId, targetListId);
+    console.log(t('card.moved'));
     console.log(t('card.cardName', { name: card.name }));
+    console.log(t('card.movedTo', { listName: targetList.name }));
   }
 }