feat(ads): add options to getRandom function

Now accepts additional options for filtering the results.

The options include ignoreId, ownerId, and tryOtherOwners.

This allows for more flexibility in retrieving random advertisements based on specific criteria.

models/advertisement.js

@@ -1,10 +1,22 @@
 import database from 'infra/database';
 
-async function getRandom(limit) {
+async function getRandom(limit, options = {}) {
+  const { ignoreId, ownerId, tryOtherOwners } = options;
+
   const query = {
     values: [limit],
   };
 
+  let where = "type = 'ad' AND status = 'published'";
+
+  if (ownerId) {
+    where += ` AND c.owner_id = '${ownerId}'`;
+  }
+
+  if (ignoreId) {
+    where += ` AND c.id != '${ignoreId}'`;
+  }
+
   query.text = `
     SELECT
       c.id,
@@ -15,13 +27,17 @@ async function getRandom(limit) {
       'markdown' as ad_type
     FROM contents c
     INNER JOIN users u ON c.owner_id = u.id
-    WHERE type = 'ad' AND status = 'published'
+    WHERE ${where}
     ORDER BY RANDOM()
     LIMIT $1;
   `;
 
   const results = await database.query(query);
 
+  if (!results.rows.length && ownerId && tryOtherOwners) {
+    return getRandom(limit, { ignoreId });
+  }
+
   return results.rows;
 }
 

models/validator.js

@@ -393,6 +393,20 @@ const schemas = {
     });
   },
 
+  ignore_id: function () {
+    return Joi.object({
+      ignore_id: schemas.id().extract('id'),
+    });
+  },
+
+  flexible: function () {
+    return Joi.object({
+      flexible: Joi.boolean()
+        .default(false)
+        .when('$required.optional', { is: 'required', then: Joi.required(), otherwise: Joi.optional() }),
+    });
+  },
+
   where: function () {
     let whereSchema = Joi.object({}).optional().min(1);
 

pages/[username]/[slug]/index.public.js

@@ -418,7 +418,11 @@ export const getStaticProps = getStaticPropsRevalidate(async (context) => {
     secureParentContentFound.body = removeMarkdown(secureParentContentFound.body, { maxLength: 50 });
   }
 
-  const adsFound = await ad.getRandom(1);
+  const adsFound = await ad.getRandom(1, {
+    ignoreId: secureContentFound.id,
+    ownerId: secureContentFound.owner_id,
+    tryOtherOwners: secureContentFound.type === 'content',
+  });
   const secureAdValues = authorization.filterOutput(userTryingToGet, 'read:ad:list', adsFound);
 
   return {

pages/api/v1/sponsored-beta/index.public.js

@@ -19,6 +19,9 @@ export default nextConnect({
 function getValidationHandler(request, response, next) {
   const cleanValues = validator(request.query, {
     per_page: 'optional',
+    owner_id: 'optional',
+    ignore_id: 'optional',
+    flexible: 'optional',
   });
 
   request.query = cleanValues;
@@ -29,7 +32,11 @@ function getValidationHandler(request, response, next) {
 async function getHandler(request, response) {
   const userTryingToList = user.createAnonymous();
 
-  const ads = await ad.getRandom(request.query.per_page);
+  const ads = await ad.getRandom(request.query.per_page, {
+    ignoreId: request.query.ignore_id,
+    ownerId: request.query.owner_id,
+    tryOtherOwners: request.query.flexible,
+  });
 
   const secureOutputValues = authorization.filterOutput(userTryingToList, 'read:ad:list', ads);
 

tests/integration/api/v1/sponsored-beta/get.test.js

@@ -84,12 +84,64 @@ describe('GET /api/v1/sponsored-beta', () => {
       expect(createdAds).toContainEqual(responseBody[0]);
       expect(createdAds).toContainEqual(responseBody[1]);
     });
+
+    it('should ignore specific ad', async () => {
+      const createdAds = await createAds(1, owner);
+
+      const { response, responseBody } = await adsRequestBuilder.get(`?ignore_id=${createdAds[0].id}`);
+
+      expect.soft(response.status).toBe(200);
+      expect(responseBody).toEqual([]);
+    });
+
+    it('should get from specific owner', async () => {
+      const specificOwner = await orchestrator.createUser();
+
+      orchestrator.createBalance({
+        balanceType: 'user:tabcash',
+        recipientId: specificOwner.id,
+        amount: defaultTabCashForAdCreation,
+      });
+
+      await createAds(10, owner);
+      const specificAd = await createAds(1, specificOwner);
+      await createAds(10, owner, 10);
+
+      const { response, responseBody } = await adsRequestBuilder.get(`?owner_id=${specificOwner.id}`);
+
+      expect.soft(response.status).toBe(200);
+      expect(responseBody).toStrictEqual(specificAd);
+    });
+
+    it('should try get from another owner', async () => {
+      const specificOwner = await orchestrator.createUser();
+
+      const createdAds = await createAds(1, owner);
+
+      const { response, responseBody } = await adsRequestBuilder.get(`?flexible=true&owner_id=${specificOwner.id}`);
+
+      expect.soft(response.status).toBe(200);
+      expect(responseBody).toStrictEqual(createdAds);
+    });
+
+    it('should try get from another owner and ignore specific ad', async () => {
+      const specificOwner = await orchestrator.createUser();
+
+      const createdAds = await createAds(2, owner);
+
+      const { response, responseBody } = await adsRequestBuilder.get(
+        `?flexible=true&owner_id=${specificOwner.id}&ignore_id=${createdAds[1].id}`,
+      );
+
+      expect.soft(response.status).toBe(200);
+      expect(responseBody).toStrictEqual([createdAds[0]]);
+    });
   });
 });
 
-async function createAds(count, owner) {
+async function createAds(count, owner, indexOffset = 0) {
   const ads = [];
-  for (let i = 0; i < count; i++) {
+  for (let i = indexOffset; i < count + indexOffset; i++) {
     const ad = await orchestrator.createContent({
       owner_id: owner.id,
       title: `Ad #${i}`,