feat: Add endpoint to retrieve available slots for a TP collection

src/Curation/ItemCuration/ItemCuration.model.ts

@@ -1,4 +1,5 @@
 import { Model, raw, SQL } from 'decentraland-server'
+import { Collection } from '../../Collection'
 import { Item } from '../../Item'
 import { CurationType } from '../Curation.types'
 import { ItemCurationAttributes } from './ItemCuration.types'
@@ -14,4 +15,18 @@ export class ItemCuration extends Model<ItemCurationAttributes> {
       FROM ${raw(this.tableName)} ic
       INNER JOIN ${raw(Item.tableName)} i ON i.id = ic.item_id AND i.collection_id = ${collectionId}`)
   }
+
+  static async getItemCurationCountByThirdPartyId(thirdPartyId: string) {
+    return this.query(
+      SQL`SELECT COUNT(DISTINCT ${raw(ItemCuration.tableName)}.id) as Count
+        FROM ${raw(ItemCuration.tableName)}
+        JOIN ${raw(Item.tableName)} ON ${raw(Item.tableName)}.id=${raw(
+        ItemCuration.tableName
+      )}.item_id
+        JOIN ${raw(Collection.tableName)} ON ${raw(
+        Collection.tableName
+      )}.id=${raw(Item.tableName)}.collection_id
+        WHERE ${raw(Collection.tableName)}.third_party_id=${thirdPartyId}`
+    )
+  }
 }

src/ThirdParty/ThirdParty.router.spec.ts

@@ -1,5 +1,6 @@
 import supertest from 'supertest'
 import { createAuthHeaders, buildURL } from '../../spec/utils'
+import { ItemCuration } from '../Curation/ItemCuration'
 import {
   ThirdPartyFragment,
   ThirdPartyMetadataType,
@@ -12,6 +13,7 @@ import { toThirdParty } from './utils'
 const server = supertest(app.getApp())
 
 jest.mock('../ethereum/api/thirdParty')
+jest.mock('../Curation/ItemCuration')
 
 describe('ThirdParty router', () => {
   let fragments: ThirdPartyFragment[]
@@ -93,4 +95,38 @@ describe('ThirdParty router', () => {
         })
     })
   })
+
+  describe('when retreiving the available slots for a third party', () => {
+    let url: string
+    const maxSlots = 10
+    const itemsInCuration = 6
+
+    beforeEach(() => {
+      ;(thirdPartyAPI.fetchMaxItemsByThirdParty as jest.Mock).mockResolvedValueOnce(
+        maxSlots
+      )
+      ;(thirdPartyAPI.isManager as jest.Mock).mockResolvedValueOnce(true)
+      ;(ItemCuration.getItemCurationCountByThirdPartyId as jest.Mock).mockResolvedValueOnce(
+        [{ count: itemsInCuration }]
+      )
+      url = '/thirdParties/aThirdPartyId/slots'
+    })
+
+    afterEach(() => {
+      jest.restoreAllMocks()
+    })
+
+    it('should respond with the correct count', () => {
+      return server
+        .get(buildURL(url))
+        .set(createAuthHeaders('get', url))
+        .expect(200)
+        .then((response: any) => {
+          expect(response.body).toEqual({
+            data: maxSlots - itemsInCuration,
+            ok: true,
+          })
+        })
+    })
+  })
 })

src/ThirdParty/ThirdParty.router.ts

@@ -1,8 +1,10 @@
 import { server } from 'decentraland-server'
 
 import { Router } from '../common/Router'
+import { HTTPError, STATUS_CODES } from '../common/HTTPError'
 import { AuthRequest, withAuthentication } from '../middleware/authentication'
 import { thirdPartyAPI } from '../ethereum/api/thirdParty'
+import { ItemCuration } from '../Curation/ItemCuration'
 import { ThirdParty } from './ThirdParty.types'
 import { toThirdParty } from './utils'
 
@@ -16,6 +18,14 @@ export class ThirdPartyRouter extends Router {
       withAuthentication,
       server.handleRequest(this.getThirdParties)
     )
+    /**
+     * Get third party available slots
+     */
+    this.router.get(
+      '/thirdParties/:id/slots',
+      withAuthentication,
+      server.handleRequest(this.getThirdPartyAvailableSlots)
+    )
   }
 
   async getThirdParties(req: AuthRequest): Promise<ThirdParty[]> {
@@ -28,4 +38,21 @@ export class ThirdPartyRouter extends Router {
     const fragments = await thirdPartyAPI.fetchThirdPartiesByManager(manager)
     return fragments.map(toThirdParty)
   }
+
+  async getThirdPartyAvailableSlots(req: AuthRequest): Promise<number> {
+    const thirdPartyId = server.extractFromReq(req, 'id')
+    const eth_address = req.auth.ethAddress
+    if (!(await thirdPartyAPI.isManager(thirdPartyId, eth_address))) {
+      throw new HTTPError(
+        'Unauthorized access. Account is not manager of the collection',
+        { eth_address },
+        STATUS_CODES.unauthorized
+      )
+    }
+    const maxItems = await thirdPartyAPI.fetchMaxItemsByThirdParty(thirdPartyId)
+    const itemCurationsCount = await ItemCuration.getItemCurationCountByThirdPartyId(
+      thirdPartyId
+    )
+    return maxItems - itemCurationsCount[0].count
+  }
 }

src/ethereum/api/thirdParty.ts

@@ -53,6 +53,14 @@ const getItemsByThirdPartyIdsQuery = () => gql`
   ${thirdPartyItemFragment()}
 `
 
+const getThirdPartyMaxItems = () => gql`
+  query getThirdPartyAvailableSlots($thirdPartyId: String!) {
+    thirdParties(where: { id: $thirdPartyId }) {
+      maxItems
+    }
+  }
+`
+
 const getItemsByCollectionQuery = () => gql`
   query getItemsByCollection(${PAGINATION_VARIABLES}, $thirdPartiesId: String!, $collectionId: String!) {
     items(${PAGINATION_ARGUMENTS}, where: { thirdParty: $thirdPartiesId, searchCollectionId: $collectionId }) {
@@ -171,6 +179,18 @@ export class ThirdPartyAPI extends BaseGraphAPI {
     })
   }
 
+  fetchMaxItemsByThirdParty = async (thirdPartyId: string): Promise<number> => {
+    const {
+      data: { thirdParties },
+    } = await this.query<{
+      thirdParties: { maxItems: string }[]
+    }>({
+      query: getThirdPartyMaxItems(),
+      variables: { thirdPartyId },
+    })
+    return +thirdParties[0].maxItems
+  }
+
   fetchItems = async (): Promise<ThirdPartyItemFragment[]> => {
     return this.paginate(['items'], {
       query: getItemsQuery(),