chore: add data to user projects endpoint (#1880)

* chore: add personnel and coauthors to proposal project

* chore: use contract method to get vesting total

* chore: remove unused types

src/clients/VestingData.ts

@@ -1,6 +1,6 @@
 import { ChainId } from '@dcl/schemas'
 import { JsonRpcProvider } from '@ethersproject/providers'
-import { BigNumber, ethers } from 'ethers'
+import { ethers } from 'ethers'
 
 import { VestingStatus } from '../entities/Grant/types'
 import { ErrorService } from '../services/ErrorService'
@@ -155,9 +155,7 @@ async function getVestingContractDataV2(
 
   const released = parseContractValue(await vestingContract.getReleased())
   const releasable = parseContractValue(await vestingContract.getReleasable())
-  const vestedPerPeriod: BigNumber[] = await vestingContract.getVestedPerPeriod()
-
-  const total = vestedPerPeriod.map(parseContractValue).reduce((acc, curr) => acc + curr, 0)
+  const total = parseContractValue(await vestingContract.getTotal())
 
   let status = getInitialVestingStatus(start_at, finish_at)
   const isRevoked = await vestingContract.getIsRevoked()

src/entities/Proposal/model.ts

@@ -15,6 +15,7 @@ import { toLower } from 'lodash'
 import isEthereumAddress from 'validator/lib/isEthereumAddress'
 import isUUID from 'validator/lib/isUUID'
 
+import PersonnelModel from '../../models/Personnel'
 import ProjectModel from '../../models/Project'
 import Time from '../../utils/date/Time'
 import { UnpublishedBidStatus } from '../Bid/types'
@@ -71,16 +72,31 @@ export default class ProposalModel extends Model<ProposalAttributes> {
     }
   }
 
+  static parseProposalWithProject(proposal: any): ProposalWithProject {
+    return {
+      ...proposal,
+      coAuthors: proposal.coauthors,
+      snapshot_proposal: JSON.parse(proposal.snapshot_proposal),
+    }
+  }
+
   static async getProposalWithProject(id: string): Promise<ProposalWithProject> {
     if (!isUUID(id || '')) {
       throw new Error(`Not found proposal: "${id}"`)
     }
 
     const query = SQL`
-      SELECT p.*, pr.id as "project_id", pr.status as "project_status"
+      SELECT p.*, 
+             pr.id as "project_id", 
+             pr.status as "project_status",
+             COALESCE(json_agg(DISTINCT to_jsonb(pe.*)) FILTER (WHERE pe.id IS NOT NULL), '[]')  as personnel,
+             COALESCE(array_agg(co.address) FILTER (WHERE co.address IS NOT NULL), '{}') AS coauthors
       FROM ${table(ProposalModel)} p
       LEFT JOIN ${table(ProjectModel)} pr ON p.id = pr.proposal_id
+      LEFT JOIN ${table(PersonnelModel)} pe ON pr.id = pe.project_id AND pe.deleted = false
+      LEFT JOIN ${table(CoauthorModel)} co ON p.id = co.proposal_id AND co.status = ${CoauthorStatus.APPROVED}
       WHERE p.id = ${id} AND p.deleted = false
+      GROUP BY p.id, pr.id
   `
 
     const result = await this.namedQuery('get_proposal_with_project', query)
@@ -89,7 +105,7 @@ export default class ProposalModel extends Model<ProposalAttributes> {
     }
 
     return {
-      ...this.parse(result[0]),
+      ...this.parseProposalWithProject(result[0]),
     }
   }
 
@@ -460,17 +476,23 @@ export default class ProposalModel extends Model<ProposalAttributes> {
     const proposals = await this.namedQuery(
       'get_project_list',
       SQL`
-        SELECT prop.*, proj.id as project_id
+        SELECT prop.*, 
+               proj.id as project_id,
+               COALESCE(json_agg(DISTINCT to_jsonb(pe.*)) FILTER (WHERE pe.id IS NOT NULL), '[]')  as personnel,
+               COALESCE(array_agg(co.address) FILTER (WHERE co.address IS NOT NULL), '{}') AS coauthors
         FROM ${table(ProposalModel)} prop
         LEFT OUTER JOIN ${table(ProjectModel)} proj on prop.id = proj.proposal_id
-        WHERE "deleted" = FALSE
+        LEFT JOIN ${table(PersonnelModel)} pe ON proj.id = pe.project_id AND pe.deleted = false
+        LEFT JOIN ${table(CoauthorModel)} co ON prop.id = co.proposal_id AND co.status = ${CoauthorStatus.APPROVED}
+        WHERE prop."deleted" = FALSE
           AND prop."type" IN (${join(types)})
           AND prop."status" IN (${join(status)})
-          ORDER BY "created_at" DESC 
+        GROUP BY prop.id, proj.id
+        ORDER BY prop."created_at" DESC 
     `
     )
 
-    return proposals.map(this.parse)
+    return proposals.map(this.parseProposalWithProject)
   }
 
   private static parseTimeframe(timeFrame?: string | null) {

src/entities/Proposal/types.ts

@@ -3,9 +3,9 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import { SQLStatement } from 'decentraland-gatsby/dist/entities/Database/utils'
 
-import { SnapshotProposal } from '../../clients/SnapshotTypes'
 import { CommitteeName } from '../../clients/Transparency'
 import { Vesting } from '../../clients/VestingData'
+import { PersonnelAttributes } from '../../models/Personnel'
 import { UnpublishedBidInfo } from '../Bid/types'
 import {
   CategoryAssessmentQuestions,
@@ -74,6 +74,8 @@ export type ProposalAttributes<C extends Record<string, unknown> = any> = {
 export interface ProposalWithProject extends ProposalAttributes {
   project_id?: string | null
   project_status?: ProjectStatus | null
+  personnel: PersonnelAttributes[]
+  coAuthors?: string[]
 }
 
 export type ProposalListFilter = {
@@ -122,9 +124,6 @@ export enum SortingOrder {
   DESC = 'DESC',
 }
 
-export type GovernanceProcessType = ProposalType.Poll | ProposalType.Draft | ProposalType.Governance
-export type BiddingProcessType = ProposalType.Pitch | ProposalType.Tender | ProposalType.Bid
-
 export enum PoiType {
   AddPOI = 'add_poi',
   RemovePOI = 'remove_poi',
@@ -178,24 +177,6 @@ export function isSortingOrder(value: string | null | undefined): boolean {
   }
 }
 
-export function getPoiTypeAction(poiType: PoiType) {
-  return poiType.split('_')[0] // "add" | "remove"
-}
-
-export function isHiringType(value: string | null | undefined): boolean {
-  switch (value) {
-    case HiringType.Add:
-    case HiringType.Remove:
-      return true
-    default:
-      return false
-  }
-}
-
-export function toHiringType<T>(value: string | null | undefined, orElse: () => T): HiringType | T {
-  return isHiringType(value) ? (value as HiringType) : orElse()
-}
-
 function requiredVotingPower(value: string | undefined | null, defaultValue: number) {
   if (value === undefined || value === null) {
     return defaultValue
@@ -828,6 +809,8 @@ export type ProposalProject = {
   status: ProjectStatus
   title: string
   user: string
+  coAuthors?: string[]
+  personnel: PersonnelAttributes[]
   size: number
   type: ProposalType
   about: string
@@ -845,8 +828,6 @@ export type ProposalProjectWithUpdate = ProposalProject & {
   update_timestamp?: number
 }
 
-export type PendingProposalsQuery = { start: Date; end: Date; fields: (keyof SnapshotProposal)[]; limit: number }
-
 export enum PriorityProposalType {
   ActiveGovernance = 'active_governance',
   OpenPitch = 'open_pitch',

src/routes/project.ts

@@ -9,6 +9,7 @@ import {
   ProjectLinkInCreationSchema,
   ProjectMilestoneInCreationSchema,
 } from '../entities/Project/types'
+import { ProposalProjectWithUpdate } from '../entities/Proposal/types'
 import PersonnelModel, { PersonnelAttributes } from '../models/Personnel'
 import ProjectLinkModel, { ProjectLink } from '../models/ProjectLink'
 import ProjectMilestoneModel, { ProjectMilestone } from '../models/ProjectMilestone'
@@ -30,15 +31,15 @@ export default routes((route) => {
   route.get('/projects/tenders-total', handleJSON(getOpenTendersTotal))
 })
 
-type ProjectsReturnType = Awaited<ReturnType<typeof ProjectService.getProposalProjects>>
-
-function filterProjectsByDate(projects: ProjectsReturnType, from?: Date, to?: Date): ProjectsReturnType {
-  return {
-    data: projects.data.filter((project) => {
-      const createdAt = new Date(project.created_at)
-      return (!from || createdAt >= from) && (!to || createdAt < to)
-    }),
-  }
+function filterProjectsByDate(
+  projects: ProposalProjectWithUpdate[],
+  from?: Date,
+  to?: Date
+): ProposalProjectWithUpdate[] {
+  return projects.filter((project) => {
+    const createdAt = new Date(project.created_at)
+    return (!from || createdAt >= from) && (!to || createdAt < to)
+  })
 }
 
 async function getProjects(req: Request) {
@@ -50,21 +51,20 @@ async function getProjects(req: Request) {
   }
 
   const cacheKey = `projects`
-  const cachedProjects = CacheService.get<ProjectsReturnType>(cacheKey)
+  const cachedProjects = CacheService.get<ProposalProjectWithUpdate[]>(cacheKey)
   if (cachedProjects) {
-    return filterProjectsByDate(cachedProjects, from, to)
+    return { data: filterProjectsByDate(cachedProjects, from, to) }
   }
   const projects = await ProjectService.getProposalProjects()
   CacheService.set(cacheKey, projects, TTL_1_HS)
-  return filterProjectsByDate(projects, from, to)
+  return { data: filterProjectsByDate(projects, from, to) }
 }
 
 async function getProject(req: Request<{ project: string }>) {
   const id = validateId(req.params.project)
   try {
     return await ProjectService.getUpdatedProject(id)
   } catch (e) {
-    console.log(`Error getting project: ${e}`) //TODO: remove before merging projects to main
     throw new RequestError(`Project "${id}" not found`, RequestError.NotFound)
   }
 }

src/routes/proposal.ts

@@ -105,7 +105,7 @@ export default routes((route) => {
   route.post('/proposals/bid', withAuth, handleAPI(createProposalBid))
   route.post('/proposals/hiring', withAuth, handleAPI(createProposalHiring))
   route.get('/proposals/priority/:address?', handleJSON(getPriorityProposals))
-  route.get('/proposals/grants/:address', handleAPI(getGrantsByUser))
+  route.get('/proposals/grants/:address', handleAPI(getProjectsByUser)) //TODO: move to project routes
   route.get('/proposals/:proposal', handleAPI(getProposalWithProject))
   route.patch('/proposals/:proposal', withAuth, handleAPI(updateProposalStatus))
   route.delete('/proposals/:proposal', withAuth, handleAPI(removeProposal))
@@ -591,22 +591,24 @@ async function validateSubmissionThreshold(user: string, submissionThreshold?: s
   }
 }
 
-async function getGrantsByUser(req: Request) {
+async function getProjectsByUser(req: Request) {
   const address = validateAddress(req.params.address)
 
   const coauthoring = await CoauthorModel.findProposals(address, CoauthorStatus.APPROVED)
   const coauthoringProposalIds = new Set(coauthoring.map((coauthoringAttributes) => coauthoringAttributes.proposal_id))
 
   const projects = await ProjectService.getProposalProjects()
-  const filteredGrants = projects.data.filter(
+  const filteredProposalProjectsWithUpdates = projects.filter(
     (project) =>
       project.type === ProposalType.Grant &&
-      (isSameAddress(project.user, address) || coauthoringProposalIds.has(project.id))
+      (isSameAddress(project.user, address) ||
+        coauthoringProposalIds.has(project.id) ||
+        project.personnel.some((person) => isSameAddress(person.address, address)))
   )
 
   return {
-    data: filteredGrants,
-    total: filteredGrants.length,
+    data: filteredProposalProjectsWithUpdates,
+    total: filteredProposalProjectsWithUpdates.length,
   }
 }
 

src/services/ProjectService.ts

@@ -46,12 +46,12 @@ function newestVestingFirst(a: TransparencyVesting, b: TransparencyVesting): num
 
 export class ProjectService {
   public static async getProposalProjects() {
-    const data = await ProposalModel.getProjectList()
+    const proposalWithProjects = await ProposalModel.getProjectList()
     const vestings = await VestingService.getAllVestings()
     const projects: ProposalProjectWithUpdate[] = []
 
     await Promise.all(
-      data.map(async (proposal) => {
+      proposalWithProjects.map(async (proposal) => {
         try {
           const proposalVestings = vestings.filter((item) => item.proposal_id === proposal.id).sort(newestVestingFirst)
           const prioritizedVesting: TransparencyVesting | undefined =
@@ -80,9 +80,7 @@ export class ProjectService {
       })
     )
 
-    return {
-      data: projects,
-    }
+    return projects
   }
 
   private static getUpdateData(update: (UpdateAttributes & { index: number }) | null) {

src/utils/projects.ts

@@ -68,6 +68,8 @@ export function createProposalProject(proposal: ProposalWithProject, vesting?: T
     status,
     title: proposal.title,
     user: proposal.user,
+    personnel: proposal.personnel,
+    coAuthors: proposal.coAuthors,
     about: proposal.configuration.abstract,
     type: proposal.type,
     size: proposal.configuration.size || proposal.configuration.funding,