sr-npm 1.7.820 → 1.7.821

package/backend/queries.js

@@ -1,4 +1,4 @@
-const { COLLECTIONS } = require('./collectionConsts');
+const { COLLECTIONS,JOBS_COLLECTION_FIELDS } = require('./collectionConsts');
 const { items: wixData } = require('@wix/data');
 
 
@@ -18,7 +18,11 @@ async function getPositionsByField(field, value) {
     .then(result => result.items);
 }
 
-module.exports = {
-  getAllPositions,
-  getPositionsByField,
-};
+async function getPositionWithMultiRefField(jobId)
+{
+  return wixData
+    .queryReferenced(COLLECTIONS.JOBS,jobId,JOBS_COLLECTION_FIELDS.MULTI_REF_JOBS_CUSTOM_VALUES)
+    .then(result => result.items);
+}
+
+module.exports = { getAllPositions, getPositionsByField, getPositionWithMultiRefField };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sr-npm",
-  "version": "1.7.820",
+  "version": "1.7.821",
   "description": "",
   "main": "index.js",
   "scripts": {

package/pages/positionPage.js

@@ -1,20 +1,41 @@
 const { query } = require("wix-location-frontend");
+const { getPositionWithMultiRefField } = require('../backend/queries');
+const { COLLECTIONS,JOBS_COLLECTION_FIELDS,CUSTOM_FIELDS_COLLECTION_FIELDS } = require('../backend/collectionConsts');
+const { items: wixData } = require('@wix/data');
+const { location } = require("@wix/site-location");
 const {
     htmlToText,
     appendQueryParams
   } = require('../public/utils');
   
   
+
+
   async function positionPageOnReady(_$w) {
 
     await bind(_$w);
+    
+    
 
   }
 
+async function getCategoryValueId(customFields) {
+  const categoryCustomField=await wixData.query(COLLECTIONS.CUSTOM_FIELDS).eq(CUSTOM_FIELDS_COLLECTION_FIELDS.TITLE,"Category").find().then(result => result.items[0]);
+  for(const field of customFields) {
+    if(field.customField===categoryCustomField._id) {
+      return field._id;
+      
+    }
+  }
+}
+
+
   async function bind(_$w) {
     _$w('#datasetJobsItem').onReady(async () => {
 
         const item = await _$w('#datasetJobsItem').getCurrentItem();
+        const multiRefField=await getPositionWithMultiRefField(item._id);
+        const categoryValueId=await getCategoryValueId(multiRefField);
 
         handleReferFriendButton(_$w,item);
 
@@ -24,18 +45,46 @@ const {
         _$w('#responsibilitiesText').text = htmlToText(item.jobDescription.jobDescription.text);
         _$w('#qualificationsText').text = htmlToText(item.jobDescription.qualifications.text);
         _$w('#relatedJobsTitleText').text = `More ${item.department} Positions`;
+        if(_$w('#additionalInfoText'))
+        {
+          _$w('#additionalInfoText').text = htmlToText(item.jobDescription.additionalInformation.text);
+        }
+        if(_$w('#relatedJobsRepNoDepartment')) // when there is no department, we filter based on category
+        {
+        const relatedJobs=await getRelatedJobs(categoryValueId,item._id);
+          _$w('#relatedJobsRepNoDepartment').onItemReady(($item, itemData) => {
+            $item('#relatedJobTitle').text = itemData.title;
+            $item('#relatedJobLocation').text = itemData.location.fullLocation;
+            // $item('#relatedJobTitle').onClick(async () => {
+            //   await location.to(itemData["link-jobs-title"]);
+            // });
+          });
+          _$w('#relatedJobsRepNoDepartment').data = relatedJobs
+          _$w('#relatedJobsNoDepartmentItem').onClick((event) => {
+            const data = _$w("#relatedJobsRepNoDepartment").data;
+            const clickedItemData = data.find(
+              (item) => item._id === event.context.itemId,
+            );
+            location.to(clickedItemData["link-jobs-title"]);
+          });
+
+        }
     });
 
+    if(_$w('#relatedJobsDataset') && _$w('#relatedJobsDataset').length>0)
+    {
     _$w('#relatedJobsDataset').onReady(() => {
         const count = _$w('#relatedJobsDataset').getTotalCount();
        if(!count){
             _$w('#relatedJobsSection').collapse();
        }
     });
+  }
+ 
 }
     
   function handleReferFriendButton(_$w,item) {
-    if(!item.referFriendLink){
+    if(!item.referFriendLink &&  _$w('#referFriendButton')){
       console.log("hiding referFriendButton");
       _$w('#referFriendButton').hide();
     }
@@ -47,6 +96,11 @@ const {
     _$w('#applyButton').link=url; //so it can be clicked
   }
 
+  async function getRelatedJobs(categoryValueId,itemId) {
+    const relatedJobs=await wixData.query(COLLECTIONS.JOBS).include(JOBS_COLLECTION_FIELDS.MULTI_REF_JOBS_CUSTOM_VALUES).hasSome(JOBS_COLLECTION_FIELDS.MULTI_REF_JOBS_CUSTOM_VALUES,[categoryValueId]).ne("_id",itemId).find();
+    return relatedJobs.items;
+  }
+
   module.exports = {
     positionPageOnReady,
   };

package/tests/mockJobBuilder.js

@@ -120,6 +120,67 @@ class MockJobBuilder {
     return this;
   }
 
+  withMultiRefCustomValues(categoryIds) {
+    this.jobData.multiRefJobsCustomValues = categoryIds;
+    return this;
+  }
+
+  withCategory(categoryId) {
+    if (!this.jobData.multiRefJobsCustomValues) {
+      this.jobData.multiRefJobsCustomValues = [];
+    }
+    this.jobData.multiRefJobsCustomValues.push(categoryId);
+    return this;
+  }
+
+  withDepartment(department) {
+    this.jobData.department = department;
+    return this;
+  }
+
+  withJobDescription(companyDesc, jobDesc, qualifications, additionalInfo = null) {
+    this.jobData.jobDescription = {
+      companyDescription: { text: companyDesc },
+      jobDescription: { text: jobDesc },
+      qualifications: { text: qualifications }
+    };
+    if (additionalInfo) {
+      this.jobData.jobDescription.additionalInformation = { text: additionalInfo };
+    }
+    return this;
+  }
+
+  withApplyLink(link) {
+    this.jobData.applyLink = link;
+    return this;
+  }
+
+  withLinkJobsTitle(link) {
+    this.jobData['link-jobs-title'] = link;
+    return this;
+  }
+
+  forPositionPage() {
+    if (!this.jobData._id) {
+      this.jobData._id = this.generateId();
+    }
+    if (!this.jobData.department) {
+      this.jobData.department = 'Technology';
+    }
+    if (!this.jobData.jobDescription) {
+      this.withJobDescription(
+        '<p>Great company to work for</p>',
+        '<p>You will build awesome stuff</p>',
+        '<p>Must know how to code</p>',
+        '<p>Additional info here</p>'
+      );
+    }
+    if (!this.jobData.applyLink) {
+      this.jobData.applyLink = `https://apply.com/${this.jobData.id}`;
+    }
+    return this;
+  }
+
   asRemote() {
     this.jobData.location.remote = true;
     return this;
@@ -176,6 +237,38 @@ class MockJobBuilder {
     }
     return jobs;
   }
+
+  static createJobsWithSameCategory(categoryId, count = 3) {
+    const jobs = [];
+    const titles = [
+      'Frontend Developer', 'Backend Developer', 'Full Stack Engineer',
+      'DevOps Engineer', 'QA Engineer', 'Data Scientist',
+      'Product Manager', 'UX Designer', 'System Architect'
+    ];
+    const cities = [
+      { city: 'Auckland', region: 'Auckland Region' },
+      { city: 'Wellington', region: 'Wellington Region' },
+      { city: 'Christchurch', region: 'Canterbury Region' },
+      { city: 'Hamilton', region: 'Waikato Region' },
+      { city: 'Dunedin', region: 'Otago Region' }
+    ];
+
+    for (let i = 0; i < count; i++) {
+      const randomTitle = titles[Math.floor(Math.random() * titles.length)];
+      const randomCity = cities[Math.floor(Math.random() * cities.length)];
+      
+      jobs.push(
+        new MockJobBuilder()
+          .withTitle(`${randomTitle} ${i + 1}`)
+          .withCity(randomCity.city, randomCity.region)
+          .withCategory(categoryId)
+          .withLinkJobsTitle(`/jobs/${randomTitle.toLowerCase().replace(/\s+/g, '-')}-${i + 1}`)
+          .forPositionPage()
+          .build()
+      );
+    }
+    return jobs;
+  }
 }
 
 module.exports = MockJobBuilder;

package/tests/positionPageTest.spec.js

@@ -0,0 +1,139 @@
+const MockJobBuilder = require('./mockJobBuilder');
+
+// Create mocks before importing
+const mockQueryChain = {
+  eq: jest.fn().mockReturnThis(),
+  find: jest.fn(),
+  include: jest.fn().mockReturnThis(),
+  hasSome: jest.fn().mockReturnThis(),
+  ne: jest.fn().mockReturnThis(),
+  limit: jest.fn().mockReturnThis(),
+  then: jest.fn()
+};
+
+const mockWixData = {
+  query: jest.fn(() => mockQueryChain),
+  queryReferenced: jest.fn()
+};
+
+jest.mock('wix-location-frontend', () => ({
+  query: {}
+}), { virtual: true });
+jest.mock('@wix/data', () => ({
+  items: mockWixData
+}));
+jest.mock('@wix/site-location', () => ({
+  location: {
+    to: jest.fn()
+  }
+}));
+
+// Mock the backend queries module as well
+jest.mock('../backend/queries', () => ({
+  getPositionWithMultiRefField: jest.fn()
+}));
+
+// Mock utils
+jest.mock('../public/utils', () => ({
+  htmlToText: jest.fn((text) => text.replace(/<[^>]*>/g, '')),
+  appendQueryParams: jest.fn((url) => url)
+}));
+
+const { positionPageOnReady } = require('../pages/positionPage');
+const { getPositionWithMultiRefField } = require('../backend/queries');
+
+
+describe('related jobs show jobs with the same category value test', () => {
+  let mockW;
+  let mockRealtedJobsRepeater;
+
+  beforeEach(() => {
+    // Create a proper repeater mock that allows data to be set
+    mockRealtedJobsRepeater = { 
+      data: null,
+      onItemReady: jest.fn()
+    };
+  });
+
+  it('should show related jobs with the same category value', async () => {
+    const CATEGORY_FIELD_ID = `category-field-${Date.now()}`;
+    const TECH_CATEGORY_VALUE_ID = `tech-category-${Math.floor(Math.random() * 10000)}`;
+
+    // Create current job using MockJobBuilder with random data
+    const currentJob = new MockJobBuilder()
+      .withTitle('Senior Developer')
+      .withDepartment('Technology')
+      .withCategory(TECH_CATEGORY_VALUE_ID)
+      .forPositionPage()
+      .build();
+
+    // Create 0-5 related jobs with same category using random data (including case with 0 related jobs)
+    const relatedJobsCount = Math.floor(Math.random() * 6); // 0-5 jobs
+    const relatedJobs = MockJobBuilder.createJobsWithSameCategory(
+      TECH_CATEGORY_VALUE_ID, 
+      relatedJobsCount
+    );
+
+    // Current job's custom values (Tech category)
+    const currentJobCustomValues = [
+      { _id: TECH_CATEGORY_VALUE_ID, customField: CATEGORY_FIELD_ID, title: 'Technology' }
+    ];
+
+    const categoryCustomField = {
+      _id: CATEGORY_FIELD_ID,
+      title: 'Category'
+    };
+
+    // Setup mocks - capture the onReady callback so we can await it
+    let datasetReadyCallback;
+    const mockDataset = {
+      onReady: jest.fn((callback) => {
+        datasetReadyCallback = callback;
+      }),
+      getCurrentItem: jest.fn().mockResolvedValue(currentJob)
+    };
+
+    mockW = jest.fn((selector) => {
+      const mocks = {
+        '#datasetJobsItem': mockDataset,
+        '#relatedJobsRepNoDepartment': mockRealtedJobsRepeater,
+        '#companyDescriptionText': { text: '' },
+        '#responsibilitiesText': { text: '' },
+        '#qualificationsText': { text: '' },
+        '#relatedJobsTitleText': { text: '' },
+        '#additionalInfoText': { text: '' },
+        '#applyButton': { target: '', link: '' }
+      };
+      return mocks[selector] || { text: '', hide: jest.fn() };
+    });
+
+    getPositionWithMultiRefField.mockResolvedValue(currentJobCustomValues);
+    
+    mockQueryChain.find.mockImplementation(() => {
+      const queryArg = mockWixData.query.mock.calls[mockWixData.query.mock.calls.length - 1][0];
+      if (queryArg === 'CustomFields') {
+        return Promise.resolve({ items: [categoryCustomField] });
+      }
+      return Promise.resolve({ items: relatedJobs });
+    });
+
+    // Run the page function (sets up the onReady callback)
+    await positionPageOnReady(mockW);
+
+    // Now execute the dataset onReady callback and wait for it
+    await datasetReadyCallback();
+
+    // Verify the repeater got populated with related jobs
+    expect(mockRealtedJobsRepeater.data).not.toBeNull();
+    expect(mockRealtedJobsRepeater.data).toHaveLength(relatedJobsCount);
+    
+    // Verify all related jobs have the same category as current job
+    const allHaveSameCategory = mockRealtedJobsRepeater.data.every(job => 
+      job.multiRefJobsCustomValues && 
+      job.multiRefJobsCustomValues.includes(TECH_CATEGORY_VALUE_ID)
+    );
+    expect(allHaveSameCategory).toBe(true);
+  });
+
+});
+