manage proposal resolve and close

index.ts

@@ -42,7 +42,7 @@ program.command('main')
     while (true) {
       const role: Role = await getRole(tezos)
 
-      console.log(chalk.bgBlue(`\nVous êtes connecté en tant que ${role}\n`))
+      console.log(`Vous êtes connecté en tant que ${chalk.bgBlue(role)}\n`)
 
       const questions = [
         {
@@ -65,7 +65,7 @@ program.command('main')
         case 'ADHERENT':
           // VOTER POUR UNE PROPOSITION
           // CLOTURER ET RESOUDRE LES PROPOSITIONS DONT IL EST LE CREATEUR
-          questions[0].choices = ['Faire une proposition', 'Créer un token']
+          questions[0].choices = ['Faire une proposition', 'Voir les propositions', 'Créer un token']
 
           if (await handleHasToken(tezos)) { questions[0].choices.push('Bruler des tokens') }
 

src/features/proposal/closeProposal.ts

 import { type TezosToolkit } from '@taquito/taquito'
 import chalk from 'chalk'
-import { handleGetProposals, handleCloseProposal } from '../../handlers/proposal/proposalHandlers.js'
+import { handleGetOpenProposals, handleCloseProposal } from '../../handlers/proposal/proposalHandlers.js'
 
 async function closeProposal (tezos: TezosToolkit): Promise<void> {
-  await handleGetProposals(tezos).then(async (response) => {
+  await handleGetOpenProposals(tezos).then(async (response) => {
     const proposalsByTitle: string[] = response
 
+    if (response.length === 0) throw new Error("Aucune proposition n'est ouverte")
+
     await handleCloseProposal(proposalsByTitle, tezos).then(() => {
       console.log(chalk.bgGreenBright('\nVous avez clôturé la proposition !!\n'))
     }).catch((error) => {

src/features/proposal/resolveProposal.ts

 import { type TezosToolkit } from '@taquito/taquito'
 import chalk from 'chalk'
-import { handleGetProposals, handleResolveProposal } from '../../handlers/proposal/proposalHandlers.js'
+import { handleGetSolvableProposals, handleResolveProposal } from '../../handlers/proposal/proposalHandlers.js'
 
 async function resolveProposal (tezos: TezosToolkit): Promise<void> {
-  await handleGetProposals(tezos).then(async (response) => {
+  await handleGetSolvableProposals(tezos).then(async (response) => {
     const proposalsByTitle: string[] = response
 
+    if (response.length === 0) throw new Error("Aucune proposition n'est résoluble")
+
     await handleResolveProposal(proposalsByTitle, tezos).then(() => {
       console.log(chalk.bgGreenBright('\nVous avez résolue la proposition !!\n'))
     }).catch((error) => {

src/handlers/association/associationHandlers.ts

@@ -57,7 +57,8 @@ async function handleCreateAssociation (tezos: TezosToolkit): Promise<void> {
   try {
     await createAssociation(association, tezos)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 
@@ -86,20 +87,23 @@ async function handleJoinAssociation (associations: string[], tezos: TezosToolki
   try {
     await joinAssociation(associationName, tezos)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 
 /**
  * Handles the process of listing associations.
  * @param {TezosToolkit} tezos - The TezosToolkit instance used for blockchain operations.
- * @returns {Promise<string[]>} A promise with a string of association name.
+ * @returns {Promise<string[]>} A promise with a list of string of association name.
  */
 async function handleGetAssociations (tezos: TezosToolkit): Promise<string[]> {
   try {
-    return await getAssociations(tezos)
+    const associations = await getAssociations(tezos)
+    return associations.map(association => association.name)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 
@@ -128,7 +132,8 @@ async function handleGetAssociationDetails (associations: string[], tezos: Tezos
   try {
     return await getAssociationDetails(associationName, tezos)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 
@@ -141,7 +146,8 @@ async function handleIsAdmin (tezos: TezosToolkit): Promise<boolean> {
   try {
     return await isAdminOfAssociation(tezos)
   } catch (error) {
-    throw new Error(`${error}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 

src/handlers/proposal/proposalHandlers.ts

@@ -57,7 +57,8 @@ async function handleCreateProposal (tezos: TezosToolkit): Promise<void> {
   try {
     await createProposal(proposal, tezos)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 
@@ -86,7 +87,8 @@ async function handleResolveProposal (proposals: string[], tezos: TezosToolkit):
   try {
     await resolveProposal(associationName, tezos)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 
@@ -101,7 +103,7 @@ async function handleCloseProposal (proposals: string[], tezos: TezosToolkit): P
     {
       type: 'list',
       name: 'choice',
-      message: 'Quelle proposition voulez-vous clôturé ?',
+      message: 'Quelle proposition voulez-vous clôturer ?',
       choices: proposals
     }
   ]
@@ -115,21 +117,54 @@ async function handleCloseProposal (proposals: string[], tezos: TezosToolkit): P
   try {
     await closeProposal(associationName, tezos)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 
 /**
  * Handles the process of listing proposals.
  * @param {TezosToolkit} tezos - The TezosToolkit instance used for blockchain operations.
- * @returns {Promise<string[]>} A promise with a string of proposal title.
+ * @returns {Promise<Proposal[]>} A promise with a list of proposal title.
  */
 async function handleGetProposals (tezos: TezosToolkit): Promise<string[]> {
   try {
-    return await getProposals(tezos)
+    const proposals: Proposal[] = await getProposals(tezos)
+    return proposals.map(proposal => proposal.title)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 
-export { handleCreateProposal, handleResolveProposal, handleGetProposals, handleCloseProposal }
+/**
+ * Handles the process of listing open proposals.
+ * @param {TezosToolkit} tezos - The TezosToolkit instance used for blockchain operations.
+ * @returns {Promise<string[]>} A promise with a list of open proposal title.
+ */
+async function handleGetOpenProposals (tezos: TezosToolkit): Promise<string[]> {
+  try {
+    const proposals: Proposal[] = await getProposals(tezos)
+    return proposals.filter(proposal => proposal.isOpen).map(proposal => proposal.title)
+  } catch (error) {
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
+  }
+}
+
+/**
+ * Handles the process of listing solvable proposals.
+ * @param {TezosToolkit} tezos - The TezosToolkit instance used for blockchain operations.
+ * @returns {Promise<string[]>} A promise with a list of solvable proposal title.
+ */
+async function handleGetSolvableProposals (tezos: TezosToolkit): Promise<string[]> {
+  try {
+    const proposals: Proposal[] = await getProposals(tezos)
+    return proposals.filter(proposal => proposal.approveRate >= 51).map(proposal => proposal.title)
+  } catch (error) {
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
+  }
+}
+
+export { handleCreateProposal, handleResolveProposal, handleGetProposals, handleCloseProposal, handleGetOpenProposals, handleGetSolvableProposals }

src/handlers/roleHandlers.ts

@@ -58,6 +58,9 @@ async function handleAdherentChoice (choice: string, tezos: TezosToolkit): Promi
     case 'Créer un token':
       await createToken(tezos)
       break
+    case 'Voir les propositions':
+      await showProposals(tezos)
+      break
     case 'Voir mon portefeuille':
       await showBalance(tezos)
       break

src/handlers/token/tokenHandlers.ts

@@ -38,7 +38,8 @@ async function handleCreateToken (tezos: TezosToolkit): Promise<void> {
   try {
     await createFAToken(nbTokenFungible, tezos)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 
@@ -75,7 +76,8 @@ async function handleBurnToken (tezos: TezosToolkit): Promise<void> {
   try {
     await burnToken(nbTokenToBurn, tezos)
   } catch (error) {
-    throw new Error(`${error.lastError.with.string}`)
+    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
   }
 }
 

src/services/association.service.ts

@@ -21,7 +21,6 @@ async function createAssociation (association: Association, tezos: TezosToolkit)
   const op: Operation = await contract.methodsObject.registerAssociation(association).send()
 
   await op.confirmation()
-  console.log(op.hash)
 }
 
 // NEED UPDATE ENTRYPOINT !!
@@ -33,7 +32,7 @@ async function joinAssociation (associationName: string, tezos: TezosToolkit): P
 }
 
 // NEED UPDATE ENTRYPOINT !!
-async function getAssociations (tezos: TezosToolkit): Promise<string[]> {
+async function getAssociations (tezos: TezosToolkit): Promise<Association[]> {
   // const contract = await tezos.contract.at(address)
   // const op: Operation = await contract.methodsObject.getAssociations().send()
 
@@ -41,7 +40,7 @@ async function getAssociations (tezos: TezosToolkit): Promise<string[]> {
   // return op
 
   // MOCK
-  return mockAssociations.map(association => association.name)
+  return mockAssociations
 }
 
 async function getAssociationDetails (associationName: string, tezos: TezosToolkit): Promise<Association> {

src/services/proposal.service.ts

@@ -7,7 +7,9 @@ const address = 'KT1QZJzhSPQ89K4eC59tmQYCt44qph7wXoJu'
 const mockProposals: Proposal[] = [
   {
     title: 'Proposal 1',
-    description: 'Ceci est la proposition 1'
+    description: 'Ceci est la proposition 1',
+    isOpen: true,
+    approveRate: 50
   },
   {
     title: 'Proposal 2',
@@ -61,14 +63,14 @@ async function viewVoteInProgressProposal (proposalName: string, tezos: TezosToo
 }
 
 // NEED UPDATE ENTRYPOINT !!
-async function getProposals (tezos: TezosToolkit): Promise<string[]> {
+async function getProposals (tezos: TezosToolkit): Promise<Proposal[]> {
   // const contract = await tezos.contract.at(address)
   // const op: Operation = await contract.methodsObject.resolveProposal(proposalName).send()
 
   // await op.confirmation()
 
   // MOCK
-  return mockProposals.map(association => association.title)
+  return mockProposals
 }
 
 export { createProposal, voteForProposal, viewVoteInProgressProposal, closeProposal, resolveProposal, getProposals }

src/services/token.service.ts

@@ -30,7 +30,7 @@ async function hasToken (tezos: TezosToolkit): Promise<boolean> {
 
   // await op.confirmation()
 
-  return false
+  return true
 }
 
 export { createFAToken, burnToken, hasToken }

src/types/Proposal.ts

@@ -4,4 +4,5 @@ export interface Proposal {
   fct?: () => void
   participationRate?: number
   approveRate?: number
+  isOpen?: boolean
 }

src/utils/getRole.ts

 import { type TezosToolkit } from '@taquito/taquito'
 import { type Role } from '../types/Role'
-// import { handleIsAdmin } from '../handlers/association/associationHandlers.js'
+import { handleIsAdmin } from '../handlers/association/associationHandlers.js'
 
 export async function getRole (tezos: TezosToolkit): Promise<Role> {
-  // const isAdmin = await handleIsAdmin(tezos)
+  const isAdmin = await handleIsAdmin(tezos)
 
-  // if (isAdmin) return 'ADMIN'
+  if (isAdmin) return 'ADMIN'
 
   // TEMPORARY
   return 'CONNECTED'

test/handlers/association/associationHandlers.spec.ts

@@ -129,16 +129,12 @@ describe('associationHandlers', () => {
         const associations = await handleGetAssociations(mockedTezosToolkit)
 
         expect(getAssociationsSpy).toBeCalledWith(mockedTezosToolkit)
-        expect(associations).toStrictEqual([
-          {
-            name: 'Association 1',
-            description: 'Association 1 description'
-          },
-          {
-            name: 'Association 2',
-            description: 'Association 2 description'
-          }
-        ])
+        expect(associations).toStrictEqual(
+          [
+            'Association 1',
+            'Association 2'
+          ]
+        )
       })
     })
 

test/handlers/roleHandlers.spec.ts

@@ -157,6 +157,14 @@ describe('roleHandlers', () => {
       })
     })
 
+    describe('when choice is "Voir les propositions"', () => {
+      it('should call showProposals', async () => {
+        await handleAdminChoice('Voir les propositions', mockedTezosToolkit)
+
+        expect(showProposals).toBeCalled()
+      })
+    })
+
     describe('when choice is invalid', () => {
       it('should log "Choix invalide"', async () => {
         const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})