Added crawler for Saljic nekretnine.

Rental crawler fix

See merge request saburly/marketalarm/web!80

.gitignore

@@ -1,3 +1,5 @@
 node_modules/
 .env
 .idea/
+.eslintrc
+.vscode/

app/common/enums.js

@@ -104,6 +104,13 @@ const AD_CATEGORY = {
     id: "FLAT",
     title: "Stan",
     hasGardenSize: false,
+    hasAccesRoadType: true,
+    hasBalconyProp: true,
+    hasNewBuildingProp: true,
+    hasElevatorProp: true,
+    hasNumberOfRoom: true,
+    hasNumberOfFloors: false,
+    hasFloorProp: true,
     priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
     priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS
@@ -112,6 +119,13 @@ const AD_CATEGORY = {
     id: "HOUSE",
     title: "Kuća",
     hasGardenSize: true,
+    hasAccesRoadType: true,
+    hasBalconyProp: true,
+    hasNewBuildingProp: true,
+    hasElevatorProp: false,
+    hasNumberOfRoom: true,
+    hasNumberOfFloors: true,
+    hasFloorProp: false,
     priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
     priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS,
@@ -121,6 +135,13 @@ const AD_CATEGORY = {
     id: "OFFICE",
     title: "Kancelarija",
     hasGardenSize: false,
+    hasAccesRoadType: true,
+    hasBalconyProp: false,
+    hasNewBuildingProp: true,
+    hasElevatorProp: true,
+    hasNumberOfRoom: true,
+    hasNumberOfFloors: false,
+    hasFloorProp: true,
     priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
     priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS
@@ -129,6 +150,13 @@ const AD_CATEGORY = {
     id: "LAND",
     title: "Zemljište",
     hasGardenSize: false,
+    hasAccesRoadType: true,
+    hasBalconyProp: false,
+    hasNewBuildingProp: false,
+    hasElevatorProp: false,
+    hasNumberOfRoom: false,
+    hasNumberOfFloors: false,
+    hasFloorProp: false,
     priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
     priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: LAND_SIZE_SLIDER_OPTIONS
@@ -137,6 +165,13 @@ const AD_CATEGORY = {
     id: "APARTMENT",
     title: "Apartman",
     hasGardenSize: false,
+    hasAccesRoadType: true,
+    hasBalconyProp: true,
+    hasNewBuildingProp: true,
+    hasElevatorProp: true,
+    hasNumberOfRoom: true,
+    hasNumberOfFloors: false,
+    hasFloorProp: true,
     priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
     priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS
@@ -145,6 +180,13 @@ const AD_CATEGORY = {
     id: "GARAGE",
     title: "Garaža",
     hasGardenSize: false,
+    hasAccesRoadType: true,
+    hasBalconyProp: false,
+    hasNewBuildingProp: false,
+    hasElevatorProp: false,
+    hasNumberOfRoom: false,
+    hasNumberOfFloors: false,
+    hasFloorProp: false,
     priceSliderOptionsSale: GARAGE_PRICE_SLIDER_OPTIONS_SALE,
     priceSliderOptionsRent: GARAGE_PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: GARAGE_SIZE_SLIDER_OPTIONS
@@ -153,6 +195,13 @@ const AD_CATEGORY = {
     id: "COTTAGE",
     title: "Vikendica",
     hasGardenSize: true,
+    hasAccesRoadType: true,
+    hasBalconyProp: true,
+    hasNewBuildingProp: true,
+    hasElevatorProp: false,
+    hasNumberOfRoom: true,
+    hasNumberOfFloors: true,
+    hasFloorProp: false,
     priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
     priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS,
@@ -174,7 +223,8 @@ const AD_AGENCY = {
   OLX: "OLX",
   RENTAL: "RENTAL",
   PROSTOR: "PROSTOR",
-  AKTIDO: "AKTIDO"
+  AKTIDO: "AKTIDO",
+  SALJIC: "SALJIC"
 };
 
 const CRAWLER_AD_TYPE = {
@@ -199,6 +249,10 @@ const EMAIL_FREQUENCY = {
 };
 
 const HEATING_TYPE = {
+  ANY: {
+    id: "ANY",
+    title: "Svi"
+  },
   NO_HEATING: {
     id: "NO_HEATING",
     title: "Nije uvedeno"
@@ -238,6 +292,10 @@ const HEATING_TYPE = {
 };
 
 const ACCESS_ROAD_TYPE = {
+  ANY: {
+    id: "ANY",
+    title: "Svi"
+  },
   ASPHALT: {
     id: "ASPHALT",
     title: "Asfalt"

app/common/filterEnums.js

@@ -0,0 +1,110 @@
+const { AD_CATEGORY, ACCESS_ROAD_TYPE, HEATING_TYPE } = require("./enums");
+
+const ADVANCED_BOOLEAN_FILTERS = [
+  {
+    dbField: "balcony",
+    title: "Balkon",
+    categoriesToShow: [
+      AD_CATEGORY.FLAT,
+      AD_CATEGORY.HOUSE,
+      AD_CATEGORY.APARTMENT,
+      AD_CATEGORY.COTTAGE
+    ]
+  },
+  {
+    dbField: "elevator",
+    title: "Lift",
+    categoriesToShow: [
+      AD_CATEGORY.FLAT,
+      AD_CATEGORY.APARTMENT,
+      AD_CATEGORY.OFFICE
+    ]
+  },
+  {
+    dbField: "newBuilding",
+    title: "Novogradnja",
+    categoriesToShow: [
+      AD_CATEGORY.FLAT,
+      AD_CATEGORY.HOUSE,
+      AD_CATEGORY.APARTMENT,
+      AD_CATEGORY.COTTAGE,
+      AD_CATEGORY.OFFICE
+    ]
+  }
+];
+
+const ADVANCED_SEGMENT_SELECT_FILTERS = [
+  {
+    dbField: "accessRoadType",
+    title: "Pristupni put",
+    values: Object.keys(ACCESS_ROAD_TYPE).map(key => ACCESS_ROAD_TYPE[key]),
+    categoriesToShow: [
+      AD_CATEGORY.FLAT,
+      AD_CATEGORY.HOUSE,
+      AD_CATEGORY.APARTMENT,
+      AD_CATEGORY.COTTAGE,
+      AD_CATEGORY.OFFICE,
+      AD_CATEGORY.LAND,
+      AD_CATEGORY.GARAGE
+    ]
+  }
+  // {
+  //   dbField: "heatingType",
+  //   title: "Vrsta grijanja",
+  //   values: Object.keys(HEATING_TYPE).map(key => HEATING_TYPE[key]),
+  //   categoriesToShow: [
+  //     AD_CATEGORY.FLAT,
+  //     AD_CATEGORY.HOUSE,
+  //     AD_CATEGORY.APARTMENT,
+  //     AD_CATEGORY.COTTAGE,
+  //     AD_CATEGORY.OFFICE
+  //   ]
+  // }
+];
+
+const ADVANCED_RANGE_FILTERS = [
+  {
+    id: "numberOfFloors",
+    title: "Broj spratova",
+    dbFieldMin: "numberOfFloorsMin",
+    dbFieldMax: "numberOfFloorsMax",
+    validValueMin: -1,
+    validValueMax: 50,
+    categoriesToShow: [AD_CATEGORY.HOUSE, AD_CATEGORY.COTTAGE]
+  },
+  {
+    id: "floor",
+    title: "Sprat",
+    dbFieldMin: "floorMin",
+    dbFieldMax: "floorMax",
+    validValueMin: -10,
+    validValueMax: 50,
+    categoriesToShow: [
+      AD_CATEGORY.FLAT,
+      AD_CATEGORY.APARTMENT,
+      AD_CATEGORY.OFFICE
+    ]
+  },
+  {
+    id: "numberOfRooms",
+    title: "Broj soba",
+    dbFieldMin: "numberOfRoomsMin",
+    dbFieldMax: "numberOfRoomsMax",
+    decimalPlaces: 1,
+    validValueMin: 0,
+    validValueMax: 200,
+    categoriesToShow: [
+      AD_CATEGORY.FLAT,
+      AD_CATEGORY.HOUSE,
+      AD_CATEGORY.APARTMENT,
+      AD_CATEGORY.COTTAGE,
+      AD_CATEGORY.OFFICE
+    ]
+  }
+];
+
+module.exports = {
+  ADVANCED_BOOLEAN_FILTERS,
+  ADVANCED_SEGMENT_SELECT_FILTERS,
+  ADVANCED_RANGE_FILTERS
+};

app/config/appConfig.js

@@ -30,6 +30,8 @@ const MAX_REAL_ESTATES_IN_FIRST_EMAIL =
 
 const PRINT_CRAWLER_DEBUG = process.env.PRINT_CRAWLER_DEBUG_INFO || 0;
 
+const API_MAP_KEY = process.env.API_MAP_KEY || "";
+
 module.exports = {
   APP_PORT,
   APP_URL,
@@ -39,5 +41,6 @@ module.exports = {
   AWS_EMAIL_CONFIG,
   MAX_REAL_ESTATES_IN_EMAIL,
   MAX_REAL_ESTATES_IN_FIRST_EMAIL,
-  PRINT_CRAWLER_DEBUG
+  PRINT_CRAWLER_DEBUG,
+  API_MAP_KEY
 };

app/controllers/location.js

@@ -4,9 +4,37 @@ const getLocation = async (req, res) => {
   const title = "Odaberite lokaciju";
   const nextStep = req.query.nextStep || "/";
 
+  //Check if location data already exists (active request)
+  //If it does then  get location is called through edit field query
+  //and map should show already selected location not initial map
+  let selectedLatLngBounds = {};
+  let boundsSelected = false;
+
+  const searchRequest = await currentSearchRequest(req);
+
+  if (!searchRequest || !searchRequest.dataValues) {
+    res.render("notFound", { title: " " });
+    return;
+  }
+  const selectedArea = searchRequest.areaToSearch;
+  const sw = selectedArea.coordinates[0][3];
+  const ne = selectedArea.coordinates[0][1];
+
+  if (sw[0] && ne[0]) {
+    selectedLatLngBounds = {
+      swLat: sw[1],
+      swLng: sw[0],
+      neLat: ne[1],
+      neLng: ne[0]
+    };
+    boundsSelected = true;
+  }
+
   res.render("location", {
     nextStep,
-    title
+    title,
+    boundsSelected,
+    selectedLatLngBounds
   });
 };
 

app/controllers/realEstateFilters.js

@@ -1,5 +1,10 @@
 const { currentSearchRequest } = require("../helpers/url");
-const { AD_CATEGORY, AD_TYPE } = require("../common/enums");
+const { AD_CATEGORY, AD_TYPE, ACCESS_ROAD_TYPE } = require("../common/enums");
+const {
+  ADVANCED_BOOLEAN_FILTERS,
+  ADVANCED_SEGMENT_SELECT_FILTERS,
+  ADVANCED_RANGE_FILTERS
+} = require("../common/filterEnums");
 
 const getFilters = async (req, res) => {
   const searchRequest = await currentSearchRequest(req);
@@ -19,7 +24,18 @@ const getFilters = async (req, res) => {
     sizeMin,
     sizeMax,
     gardenSizeMin,
-    gardenSizeMax
+    gardenSizeMax,
+    numberOfRoomsMin,
+    numberOfRoomsMax,
+    numberOfFloorsMin,
+    numberOfFloorsMax,
+    floorMin,
+    floorMax,
+    includeIncompleteAds,
+    balcony,
+    elevator,
+    newBuilding,
+    accessRoadType
   } = searchRequest;
   const category = AD_CATEGORY[realEstateType] || AD_CATEGORY.FLAT;
 
@@ -41,6 +57,40 @@ const getFilters = async (req, res) => {
     return;
   }
 
+  // TODO: Maybe this is slow, pay attention to this
+  const filterFilters = filterObject => {
+    const filterCategories = filterObject.categoriesToShow;
+    return filterCategories.indexOf(category) !== -1;
+  };
+
+  const advancedBooleanFilterObjects = ADVANCED_BOOLEAN_FILTERS.filter(
+    filterFilters
+  );
+  const advancedSegmentSelectFilterObjects = ADVANCED_SEGMENT_SELECT_FILTERS.filter(
+    filterFilters
+  );
+  const advancedRangeFilterObjects = ADVANCED_RANGE_FILTERS.filter(
+    filterFilters
+  );
+
+  const advancedBooleanFilterValues = {
+    includeIncompleteAds,
+    balcony,
+    elevator,
+    newBuilding
+  };
+  const advancedSegmentSelectFilterValues = {
+    accessRoadType
+  };
+  const advancedRangeFilterValues = {
+    numberOfFloorsMin,
+    numberOfFloorsMax,
+    numberOfRoomsMin,
+    numberOfRoomsMax,
+    floorMin,
+    floorMax
+  };
+
   if (priceMin || priceMax) {
     priceSliderOptions.start = [priceMin, priceMax];
   }
@@ -58,7 +108,14 @@ const getFilters = async (req, res) => {
     hasGardenSize,
     priceSliderOptions: JSON.stringify(priceSliderOptions),
     sizeSliderOptions: JSON.stringify(sizeSliderOptions),
-    gardenSizeSliderOptions: JSON.stringify(gardenSizeSliderOptions)
+    gardenSizeSliderOptions: JSON.stringify(gardenSizeSliderOptions),
+    advancedBooleanFilterObjects,
+    advancedBooleanFilterValues,
+    advancedSegmentSelectFilterObjects,
+    advancedSegmentSelectFilterValues,
+    advancedRangeFilterObjects,
+    advancedRangeFilterValues,
+    includeIncompleteAds
   });
 };
 
@@ -78,13 +135,91 @@ const postFilters = async (req, res) => {
   const sizeMin = parseInt(req.body.sizeMin) || 0;
   const sizeMax = parseInt(req.body.sizeMax) || 0;
 
-  //TODO: Filter validation
+  const advancedRangeFilters = {};
 
+  ADVANCED_RANGE_FILTERS.forEach(filter => {
+    let parsingFunction = parseInt;
+    if (filter.decimalPlaces) {
+      parsingFunction = parseFloat;
+    }
+
+    advancedRangeFilters[filter.dbFieldMin] = parsingFunction(
+      req.body[filter.dbFieldMin]
+    );
+    advancedRangeFilters[filter.dbFieldMax] = parsingFunction(
+      req.body[filter.dbFieldMax]
+    );
+
+    advancedRangeFilters[filter.dbFieldMin] = isNaN(
+      advancedRangeFilters[filter.dbFieldMin]
+    )
+      ? null
+      : advancedRangeFilters[filter.dbFieldMin];
+    advancedRangeFilters[filter.dbFieldMax] = isNaN(
+      advancedRangeFilters[filter.dbFieldMax]
+    )
+      ? null
+      : advancedRangeFilters[filter.dbFieldMax];
+
+    try {
+      if (filter.decimalPlaces) {
+        advancedRangeFilters[filter.dbFieldMin] = advancedRangeFilters[
+          filter.dbFieldMin
+        ].toFixed(filter.decimalPlaces);
+        advancedRangeFilters[filter.dbFieldMax] = advancedRangeFilters[
+          filter.dbFieldMax
+        ].toFixed(filter.decimalPlaces);
+      }
+    } catch (e) {
+      advancedRangeFilters[filter.dbFieldMin] = null;
+      advancedRangeFilters[filter.dbFieldMax] = null;
+    }
+
+    if (
+      advancedRangeFilters[filter.dbFieldMin] < filter.validValueMin ||
+      advancedRangeFilters[filter.dbFieldMin] > filter.validValueMax
+    ) {
+      advancedRangeFilters[filter.dbFieldMin] = filter.validValueMin;
+    }
+
+    if (
+      advancedRangeFilters[filter.dbFieldMax] < filter.validValueMin ||
+      advancedRangeFilters[filter.dbFieldMax] > filter.validValueMax
+    ) {
+      advancedRangeFilters[filter.dbFieldMax] = filter.validValueMax;
+    }
+  });
+
+  const includeIncompleteAds = req.body.includeIncompleteAds === "on";
+
+  const balcony = req.body.balcony === "on";
+  const elevator = req.body.elevator === "on";
+  const newBuilding = req.body.newBuilding === "on";
+
+  const accessRoadType = req.body.accessRoadType;
+  if (!ACCESS_ROAD_TYPE[accessRoadType]) {
+    res.render("notFound", { title: " Greška !" });
+    return;
+  }
+
+  //TODO: Filter validation
   searchRequest.priceMin = priceMin;
   searchRequest.priceMax = priceMax;
   searchRequest.sizeMin = sizeMin;
   searchRequest.sizeMax = sizeMax;
 
+  for (const filter of Object.keys(advancedRangeFilters)) {
+    searchRequest[filter] = advancedRangeFilters[filter];
+  }
+
+  searchRequest.balcony = balcony;
+  searchRequest.elevator = elevator;
+  searchRequest.newBuilding = newBuilding;
+
+  searchRequest.includeIncompleteAds = includeIncompleteAds;
+
+  searchRequest.accessRoadType = accessRoadType;
+
   if (
     req.body.gardenSizeMin !== undefined &&
     req.body.gardenSizeMax !== undefined
@@ -97,7 +232,6 @@ const postFilters = async (req, res) => {
     searchRequest.gardenSizeMin = gardenSizeMin;
     searchRequest.gardenSizeMax = gardenSizeMax;
   }
-
   await searchRequest.save();
 
   res.redirect(nextStepUrl);

app/crawler/crawl.js

@@ -9,12 +9,14 @@ const OlxCrawler = require("./specificCrawlers/olx");
 const RentalCrawler = require("./specificCrawlers/rental");
 const ProstorCrawler = require("./specificCrawlers/prostor");
 const AktidoCrawler = require("./specificCrawlers/aktido");
+const SaljicCrawler = require("./specificCrawlers/saljic");
 
 const {
   OLX_CONFIG,
   RENTAL_CONFIG,
   PROSTOR_CONFIG,
-  AKTIDO_CONFIG
+  AKTIDO_CONFIG,
+  SALJIC_CONFIG
 } = require("./crawlerConfig");
 const PostgresSaver = require("./savers/postgres");
 
@@ -57,6 +59,15 @@ async function crawlAll() {
       AKTIDO_CONFIG.AKTIDO_MAX_RESULTS_PER_PAGE,
       AKTIDO_CONFIG.AKTIDO_IGNORED_USERNAMES,
       AKTIDO_CONFIG.AKTIDO_DELAY_BETWEEN_PAGES
+    ),
+    new SaljicCrawler(
+      [postgresSaver],
+      SALJIC_CONFIG.SALJIC_CRAWLER_AD_TYPE,
+      SALJIC_CONFIG.SALJIC_CRAWLER_AD_CATEGORIES,
+      SALJIC_CONFIG.SALJIC_MAX_PAGES,
+      SALJIC_CONFIG.SALJIC_MAX_RESULTS_PER_PAGE,
+      SALJIC_CONFIG.SALJIC_IGNORED_USERNAMES,
+      SALJIC_CONFIG.SALJIC_DELAY_BETWEEN_PAGES
     )
   ];
 

app/crawler/crawlerConfig.js

@@ -5,10 +5,12 @@ const OLX_CONFIG = require("./specificConfigs/olx");
 const RENTAL_CONFIG = require("./specificConfigs/rental");
 const PROSTOR_CONFIG = require("./specificConfigs/prostor");
 const AKTIDO_CONFIG = require("./specificConfigs/aktido");
+const SALJIC_CONFIG = require("./specificConfigs/saljic");
 
 module.exports = {
   OLX_CONFIG,
   RENTAL_CONFIG,
   PROSTOR_CONFIG,
-  AKTIDO_CONFIG
+  AKTIDO_CONFIG,
+  SALJIC_CONFIG
 };

app/crawler/specificConfigs/saljic.js

@@ -0,0 +1,34 @@
+"use strict";
+const { CRAWLER_AD_TYPE, AD_CATEGORY } = require("../../common/enums");
+
+const saljicCrawlerAdType =
+  process.env.SALJIC_CRAWLER_AD_TYPE !== undefined
+    ? CRAWLER_AD_TYPE[process.env.SALJIC_CRAWLER_AD_TYPE]
+    : null;
+
+const saljicParsedCrawlerAdCategories =
+  process.env.SALJIC_CRAWLER_AD_CATEGORIES !== undefined
+    ? process.env.SALJIC_CRAWLER_AD_CATEGORIES.split(",").map(category =>
+        category.trim()
+      )
+    : ["FLAT", "HOUSE"];
+
+const saljicIgnoredUsernames = [];
+
+const transformedSaljicCrawlerAdCategories = saljicParsedCrawlerAdCategories
+  .map(categoryName =>
+    AD_CATEGORY[categoryName] ? AD_CATEGORY[categoryName].id : undefined
+  )
+  .filter(category => !!category);
+
+module.exports = {
+  SALJIC_MAX_PAGES: parseInt(process.env.SALJIC_MAX_PAGES) || 100,
+  SALJIC_MAX_RESULTS_PER_PAGE:
+    parseInt(process.env.SALJIC_MAX_RESULTS_PER_PAGE) || 5000,
+  SALJIC_CRAWLER_AD_TYPE: saljicCrawlerAdType || CRAWLER_AD_TYPE.NONE,
+  SALJIC_CRAWLER_AD_CATEGORIES: transformedSaljicCrawlerAdCategories,
+  SALJIC_IGNORED_USERNAMES: saljicIgnoredUsernames || [],
+  SALJIC_DELAY_BETWEEN_PAGES:
+    parseInt(process.env.SALJIC_DELAY_BETWEEN_PAGES) || 1000,
+  SALJIC_FORCE_CRAWL: !!parseInt(process.env.SALJIC_FORCE_CRAWL)
+};

app/crawler/specificCrawlers/rental.js

@@ -312,7 +312,7 @@ class RentalCrawler {
 
         let numberOfRooms =
             parseInt(extractedData["re_realEstates_roomsNO"]) +
-              parseInt(extractedData["re_realEstates_bedroomNO"]) || null,
+              parseInt(extractedData["re_realEstates_bedNO"]) || null,
           numberOfFloors =
             parseInt(extractedData["re_realEstates_floorsNO"]) ||
             this.getNumberOfFloorsFromFloorId(extractedData["re_floorNO_id"]),
@@ -352,7 +352,9 @@ class RentalCrawler {
             realEstatePropertiesFromInfrastructure.phoneConnection,
           cableTV = realEstatePropertiesFromInfrastructure.cableTV,
           internet = realEstatePropertiesFromInfrastructure.internet,
-          basementAttic = realEstatePropertiesFromSpaces.basementAttic,
+          basementAttic =
+            realEstatePropertiesFromSpaces.basementAttic ||
+            this.checkBasemAtticFromFloors(extractedData["re_floorNO_id"]),
           storeRoom = realEstatePropertiesFromSpaces.storeRoom,
           videoSurveillance =
             realEstatePropertiesFromDescriptions.videoSurveillance ||
@@ -397,9 +399,7 @@ class RentalCrawler {
         );
         if (!publishedDateMoment.isValid()) {
           throw {
-            message: `Invalid published date : ${
+            message: `Invalid published date : ${extractedData["re_realEstates_inserted"]}`
-              extractedData["re_realEstates_inserted"]
-            }`
           };
         }
 
@@ -410,9 +410,7 @@ class RentalCrawler {
         );
         if (!renewedDateMoment.isValid()) {
           throw {
-            message: `Invalid renewed date : ${
+            message: `Invalid renewed date : ${extractedData["re_realEstates_edited"]}`
-              extractedData["re_realEstates_edited"]
-            }`
           };
         }
 
@@ -782,8 +780,42 @@ class RentalCrawler {
     if (floorIds.length === 0) {
       return null;
     }
+    let noOfFloors = floorIds.length;
+    // Floors of 'suteren', 'podrum', 'tavan' and 'potkrovlje' are not counted
+    floorIds.forEach(id => {
+      if (
+        parseInt(id) === 1 ||
+        parseInt(id) === 2 ||
+        parseInt(id) === 12 ||
+        parseInt(id) === 14
+      ) {
+        noOfFloors--;
+      }
+    });
+    return noOfFloors;
+  }
 
-    return floorIds.length;
+  checkBasemAtticFromFloors(floorsIdText) {
+    // floorIdText can be array of numbers, separated by comma or number
+    const floorIds = floorsIdText.split(",");
+
+    let check = false;
+
+    if (floorIds.length === 0) {
+      check = false;
+    }
+    //If floors 'suteren', 'podrum', 'tavan' and 'potkrovlje' exists then tag for basement-attic is true
+    floorIds.forEach(id => {
+      if (
+        parseInt(id) === 1 ||
+        parseInt(id) === 2 ||
+        parseInt(id) === 12 ||
+        parseInt(id) === 14
+      ) {
+        check = true;
+      }
+    });
+    return check;
   }
 
   async sleep(ms) {

app/crawler/specificCrawlers/saljic.js

@@ -0,0 +1,611 @@
+"use strict";
+
+const fetch = require("node-fetch");
+const cheerio = require("cheerio");
+const moment = require("moment-timezone");
+
+const {
+  AD_TYPE,
+  AD_CATEGORY,
+  AD_AGENCY,
+  AD_STATUS,
+  CRAWLER_AD_TYPE,
+  FURNISHING_TYPE,
+  HEATING_TYPE
+} = require("../../common/enums");
+
+const {
+  PRINT_CRAWLER_DEBUG,
+  DEFAULT_TIMEZONE
+} = require("../../config/appConfig");
+const { SALJIC_FORCE_CRAWL } = require("../specificConfigs/saljic");
+
+const SALJIC_ENUMS = {
+  SALJIC_AD_TYPE: {
+    [CRAWLER_AD_TYPE.ALL]: "&input_vrsta=",
+    [CRAWLER_AD_TYPE.ONLY_SELL]: "&input_vrsta=1",
+    [CRAWLER_AD_TYPE.ONLY_RENT]: "&input_vrsta=2"
+  },
+  SALJIC_AD_CATEGORY: {
+    [AD_CATEGORY.ALL.id]: "&input_kategorija=",
+    [AD_CATEGORY.FLAT.id]: "&input_kategorija=15",
+    [AD_CATEGORY.HOUSE.id]: "&input_kategorija=9",
+    [AD_CATEGORY.LAND.id]: "&input_kategorija=5", //3 and 4 also gradjevinsko
+    [AD_CATEGORY.OFFICE.id]: "&input_kategorija=8",
+    [AD_CATEGORY.APARTMENT.id]: "&input_kategorija=1",
+    [AD_CATEGORY.GARAGE.id]: "&input_kategorija=2"
+    //[AD_CATEGORY.COTTAGE.id]: ""
+  }
+};
+
+class SaljicCrawler {
+  constructor(
+    savers = [],
+    crawlerAdTypes = CRAWLER_AD_TYPE.ALL,
+    crawlerAdCategories = [AD_CATEGORY.FLAT, AD_CATEGORY.HOUSE],
+    maxPages = 5000,
+    maxResultsPerPage = 5000,
+    ignoredUsernames = [],
+    delayBetweenPages = 1000
+  ) {
+    this.savers = savers;
+    this.baseUrl = "https://www.saljicnekretnine.ba/v2/nekretnine_search";
+    this.crawlerAdTypes = crawlerAdTypes;
+    this.crawlerAdCategories = crawlerAdCategories;
+    this.maxResultsPerPage = maxResultsPerPage;
+    this.delayBetweenPages = delayBetweenPages;
+  }
+
+  async crawl() {
+    const crawlAdCategories = this.crawlerAdCategories;
+
+    const newRealEstates = [];
+
+    if (crawlAdCategories) {
+      const indexGenerators = [];
+      for (const adCategory of crawlAdCategories) {
+        indexGenerators.push(this.categoryIndexer(adCategory));
+      }
+      //
+      //console.log(indexGenerators);
+      //
+      let done = false;
+      while (!done) {
+        const categoryIndexerPromises = [];
+        const generatorsToRemove = [];
+        for (const indexGenerator of indexGenerators) {
+          categoryIndexerPromises.push(indexGenerator.next());
+          generatorsToRemove.push(false);
+        }
+
+        const singlePageResults = await Promise.all(categoryIndexerPromises);
+        const entries = singlePageResults.entries();
+
+        for (const [index, { value: singlePageResult }] of entries) {
+          if (singlePageResult) {
+            const saveResults = await this.saveCrawledResults(singlePageResult);
+            const { newRecords } = saveResults;
+
+            newRealEstates.push(...newRecords);
+
+            if (
+              Array.isArray(newRecords) &&
+              newRecords.length === 0 &&
+              !SALJIC_FORCE_CRAWL
+            ) {
+              generatorsToRemove[index] = true;
+            }
+          } else {
+            //Generator returned undefined, remove this generator from array
+            generatorsToRemove[index] = true;
+            // console.log("Generator ", index + 1, "has no more pages");
+          }
+        }
+
+        // console.log("Generators state : ", generatorsToRemove);
+        for (let i = generatorsToRemove.length - 1; i >= 0; i--) {
+          if (generatorsToRemove[i]) {
+            // console.log("\tRemove generator ", i + 1);
+            indexGenerators.splice(i, 1);
+          }
+        }
+        if (indexGenerators.length === 0) {
+          done = true;
+        }
+
+        await this.sleep(this.delayBetweenPages);
+      }
+    }
+    return newRealEstates;
+  }
+
+  async *categoryIndexer(adCategory) {
+    let pageToIndex = 1;
+
+    const urlAdTypePart = SALJIC_ENUMS.SALJIC_AD_TYPE[this.crawlerAdTypes];
+    const urlCategoryPart = SALJIC_ENUMS.SALJIC_AD_CATEGORY[adCategory];
+
+    if (urlAdTypePart !== undefined && urlCategoryPart !== undefined) {
+      while (true) {
+        const urlPagePart = pageToIndex === 1 ? "" : (pageToIndex - 1) * 2 * 11;
+        const urlPageToCrawl = `${this.baseUrl}?order_by=${urlAdTypePart}${urlCategoryPart}&per_page=${urlPagePart}`;
+
+        const singlePageResults = await this.indexSinglePage(
+          urlPageToCrawl,
+          this.maxResultsPerPage
+        );
+
+        if (Array.isArray(singlePageResults) && singlePageResults.length > 0) {
+          yield singlePageResults;
+        } else {
+          return undefined;
+        }
+
+        ++pageToIndex;
+        if (pageToIndex === this.maxPages) {
+          return undefined;
+        }
+      }
+    } else {
+      return undefined;
+    }
+  }
+
+  async indexSinglePage(url, maxResultsPerPage) {
+    if (PRINT_CRAWLER_DEBUG) {
+      console.log("[SALJIC] Index page : ", url);
+    }
+
+    try {
+      const res = await fetch(url);
+      const body = await res.text();
+      const $ = cheerio.load(body);
+      let hrefs = [];
+
+      $("#shop")
+        .find(".product")
+        .each((i, elem) => {
+          const href = $(elem)
+            .find("a")
+            .first()
+            .attr("href");
+          if (href) {
+            hrefs.push(href);
+          }
+        });
+
+      let adTypesTmp = [];
+
+      $("#shop")
+        .find(".product")
+        .each((i, elem) => {
+          const adType = $(elem)
+            .find(".trakica-search-page")
+            .text()
+            .trim();
+          if (adType) {
+            adTypesTmp.push(adType);
+          }
+        });
+
+      //Converting to AD_TYPE
+      const adTypes = adTypesTmp.map(adTypeText => {
+        return this.getAdTypeId(adTypeText);
+      });
+
+      //Converting to absolute URLs
+      const hrefsAbs = hrefs.map(link => {
+        return "https://www.saljicnekretnine.ba" + link;
+      });
+
+      let actualNoOfResults =
+        hrefsAbs.length <= maxResultsPerPage
+          ? hrefsAbs.length
+          : maxResultsPerPage;
+
+      const asyncScraping = [];
+      for (let i = 0; i < actualNoOfResults; i++) {
+        asyncScraping.push(this.scrapeAd(hrefsAbs[i], adTypes[i]));
+      }
+
+      const scrapedData = await Promise.all(asyncScraping);
+      const filteredScrapedData = scrapedData.filter(adData => !!adData);
+      return filteredScrapedData;
+    } catch (e) {
+      console.error("[SALJIC] Exception caught:" + e);
+      return [];
+    }
+  }
+
+  async scrapeAd(url, adType) {
+    console.log("[SALJIC] Scraping : ", url);
+    try {
+      const adPageSource = await fetch(url);
+      const body = await adPageSource.text();
+      const $ = cheerio.load(body);
+
+      // No information for status ex. PRODAN
+      const status = AD_STATUS.STATUS_NORMAL;
+      //Extracting agency ID from url
+      const agencyObjectId = parseInt(url.substring(46, url.length));
+
+      //Extracting main properties
+      const propertySelectors = {
+        title:
+          "div.content-wrap > div.container > div.col-md-8.nobottommargin > div.single-post > div.entry > div.entry-title > h2",
+        price:
+          "div.content-wrap > div.container > div.col-md-8.nobottommargin > div.single-post > div.entry > div.topmargin-sm.single-product > div.product > div.product-price > ins",
+        streetName:
+          "div.content-wrap > div.container > div.col-md-8.nobottommargin > div.single-post > div.entry > div.entry-content.topmargin > p",
+
+        descriptions:
+          "div.content-wrap > div.container > div.col-md-8.nobottommargin > div.single-post > div.entry > div.entry-content.topmargin > div.toggle.toggle-bg > div.togglec >p:nth-child(1)",
+        latAndLong:
+          "div.content-wrap > div.container > div.col-md-8.nobottommargin > div.single-post > div.entry > div.entry-content.topmargin > div.gmap.bottommargin > iframe"
+      };
+      const title = $(propertySelectors.title)
+        .text()
+        .replace(/(\r\n|\n|\r)/gm, "")
+        .replace(/ {1,}/g, " ")
+        .trim();
+
+      const priceText = $(propertySelectors.price)
+        .text()
+        .replace(/(\r\n|\n|\r)/gm, "")
+        .replace(/ {1,}/g, " ")
+        .trim();
+      const price =
+        priceText === "CIJENA NA UPIT"
+          ? null
+          : parseFloat(
+              priceText.substring(8, priceText.length - 3).replace(",", "")
+            );
+
+      const streetName = $(propertySelectors.streetName)
+        .text()
+        .replace(/(\r\n|\n|\r)/gm, "")
+        .trim();
+
+      const descriptions = $(propertySelectors.descriptions)
+        .text()
+        .trim();
+
+      const latAndLongSrc = $(propertySelectors.latAndLong).attr("src");
+      const latText = latAndLongSrc.substring(
+        latAndLongSrc.indexOf("marker=") + 7,
+        latAndLongSrc.indexOf("%2C", latAndLongSrc.indexOf("marker="))
+      );
+      const longText = latAndLongSrc.substring(
+        latAndLongSrc.indexOf("%2C", latAndLongSrc.indexOf("marker=")) + 3,
+        latAndLongSrc.length
+      );
+      const locationLat = parseFloat(latText) || null;
+      const locationLong = parseFloat(longText) || null;
+
+      //====== DETAIL INFORMATION FIELDS ==========
+      let area,
+        gardenSize,
+        numberOfRooms = null,
+        numberOfFloors = null,
+        floor = null,
+        accessRoadType = null,
+        heatingType = null,
+        furnishingType = null,
+        balcony = null,
+        newBuilding = null,
+        elevator = null,
+        water = null,
+        electricity = null,
+        drainageSystem = null,
+        registeredInZkBooks = null,
+        recentlyAdapted = null,
+        parking = null,
+        garage = null,
+        gas = null,
+        antiTheftDoor = null,
+        airCondition = null,
+        phoneConnection = null,
+        cableTV = null,
+        internet = null,
+        basementAttic = null,
+        storeRoom = null,
+        videoSurveillance = null,
+        alarm = null,
+        suitableForStudents = null,
+        includingBills = null,
+        animalsAllowed = null,
+        pool = null,
+        urbanPlanPermit = null,
+        buildingPermit = null,
+        utilityConnection = null,
+        distanceToRiver = null;
+      let publishedDate = null;
+      let renewedDate = null;
+      let realEstateType;
+      let numberOfViewsAgency = null;
+
+      //Extracting data - Glavne karakteristike
+      let mainFieldIndex = 1;
+      do {
+        const mainFieldSelector = `div.content-wrap > div.container > div.col-md-8.nobottommargin > div.single-post > div.entry > div.entry-content.topmargin > div.col-md-12.bottommargin > ul > li.list-group-item:nth-child(${mainFieldIndex})`;
+
+        const mainField = $(mainFieldSelector)
+          .text()
+          .replace(/[\n\r\t]/gm, "")
+          .trim();
+
+        const mainFieldTitle = mainField.substring(0, mainField.indexOf("  "));
+        const mainFieldValue = mainField
+          .substring(mainField.indexOf("  "), mainField.length)
+          .trim();
+
+        switch (mainFieldTitle) {
+          case "Površina":
+            area = parseFloat(
+              mainFieldValue.substring(0, mainFieldValue.indexOf(" "))
+            );
+            break;
+          case "Okućnica":
+            gardenSize = parseFloat(
+              mainFieldValue.substring(0, mainFieldValue.indexOf(" "))
+            );
+            break;
+          case "Broj soba":
+            numberOfRooms = parseInt(mainFieldValue);
+            break;
+          case "Broj spratova":
+            numberOfFloors = parseInt(mainFieldValue);
+            break;
+          case "Sprat":
+            floor = parseInt(mainFieldValue);
+            break;
+          case "Godina renoviranja":
+            recentlyAdapted = true;
+            break;
+          case "Broj parking mjesta":
+            parking = true;
+            break;
+          case "Dostupno od":
+            const day = mainFieldValue.substring(0, 2);
+            const month = mainFieldValue.substring(3, 5);
+            const year = mainFieldValue.substring(6, mainFieldValue.length);
+            publishedDate = new Date(`${month}/${day}/${year}`);
+            break;
+          default:
+            break;
+        }
+
+        if (mainFieldTitle === "") {
+          break;
+        }
+        mainFieldIndex++;
+      } while (true);
+
+      //Extracting data - Sadrzaji
+      let additionalFieldIndex = 1;
+      do {
+        const additionalFieldSelector = `div.content-wrap > div.container > div.col-md-8.nobottommargin > div.single-post > div.entry > div.entry-content.topmargin > div.col-md-12.bottommargin > ul > li.border-color.col-md-5.col-md-offset-1.col-md-pull-1.list-group-item-bottom:nth-child(${additionalFieldIndex})`;
+
+        const additionalField = $(additionalFieldSelector)
+          .text()
+          .trim();
+
+        if (additionalFieldIndex === 1) {
+          //Extracting data of real estate type
+          const categoryTmp = additionalField
+            .replace(/[\n\r\t]/gm, "")
+            .substring(
+              additionalField.indexOf("Kategorija") + 10,
+              additionalField.length
+            )
+            .trim();
+          realEstateType = this.getAdCategoryId(categoryTmp);
+        } else {
+          switch (additionalField) {
+            case "Internet":
+              internet = true;
+              break;
+            case "Garaža":
+              garage = true;
+              break;
+            case "Klima":
+              airCondition = true;
+              break;
+            case "Balkon":
+              balcony = true;
+              break;
+            case "Ostava":
+              storeRoom = true;
+              break;
+            case "Podrum":
+              basementAttic = true;
+              break;
+            case "Blindirana vrata":
+              antiTheftDoor = true;
+              break;
+            case "Voda":
+              water = true;
+              break;
+            case "Kablovska":
+              cableTV = true;
+              break;
+            case "Uknjiženo":
+              registeredInZkBooks = true;
+              break;
+            case "Grijanje - centralno":
+              heatingType = HEATING_TYPE.CENTRAL_CITY.id;
+              break;
+            case "Grijanje - plin":
+              heatingType = HEATING_TYPE.GAS.id;
+              break;
+            case "Grijanje - struja":
+              heatingType = HEATING_TYPE.ELECTRICITY.id;
+              break;
+            case "Grijanje":
+              heatingType = HEATING_TYPE.OTHER.id;
+              break;
+            case "Plin":
+              gas = true;
+              break;
+            case "Namješten":
+              furnishingType = FURNISHING_TYPE.FURNISHED.id;
+              break;
+            case "Alarm":
+              alarm = true;
+              break;
+            case "Video nadzor":
+              videoSurveillance = true;
+              break;
+            case "Lift":
+              elevator = true;
+              break;
+            case "Novogradnja":
+              newBuilding = true;
+              break;
+
+            default:
+              break;
+          }
+        }
+
+        if (additionalField === "") {
+          break;
+        }
+        additionalFieldIndex++;
+      } while (true);
+
+      //If no published date it takes current date of crawling
+      if (publishedDate) {
+        renewedDate = new Date();
+      } else {
+        publishedDate = new Date();
+        renewedDate = new Date();
+      }
+
+      const data = {
+        url,
+        agencyObjectId,
+        originAgencyName: AD_AGENCY.SALJIC,
+        realEstateType,
+        adType,
+        title,
+        price,
+        area,
+        gardenSize,
+        shortDescription: descriptions.substring(0, descriptions.indexOf(".")),
+        longDescription: descriptions,
+        streetNumber: 0,
+        streetName,
+        locality: "",
+        municipality: "",
+        city: "",
+        region: "",
+        entity: "",
+        country: "",
+        locationLat,
+        locationLong,
+        adStatus: status,
+        publishedDate,
+        renewedDate,
+        numberOfRooms,
+        numberOfFloors,
+        floor,
+        accessRoadType,
+        heatingType,
+        furnishingType,
+        balcony,
+        newBuilding,
+        elevator,
+        water,
+        electricity,
+        drainageSystem,
+        registeredInZkBooks,
+        recentlyAdapted,
+        parking,
+        garage,
+        gas,
+        antiTheftDoor,
+        airCondition,
+        phoneConnection,
+        cableTV,
+        internet,
+        basementAttic,
+        storeRoom,
+        videoSurveillance,
+        alarm,
+        suitableForStudents,
+        includingBills,
+        animalsAllowed,
+        pool,
+        urbanPlanPermit,
+        buildingPermit,
+        utilityConnection,
+        distanceToRiver,
+        numberOfViewsAgency
+      };
+      console.log(data);
+      return data;
+    } catch (e) {
+      console.error("Exception caught: " + e.message, "\r\nURL:", url);
+    }
+    return null;
+  }
+
+  //======= HELPER FUNCTIONS =============
+
+  getAdCategoryId(categoryText) {
+    switch (categoryText) {
+      case "Stan":
+        return AD_CATEGORY.FLAT.id;
+      case "Građevinsko zemljiste":
+        return AD_CATEGORY.LAND.id;
+      case "Industrijsko zemljiste":
+        return AD_CATEGORY.LAND.id;
+      case "Poljoprivredno zemljiste":
+        return AD_CATEGORY.LAND.id;
+      case "Kuća":
+        return AD_CATEGORY.HOUSE.id;
+      case "Poslovni prostor":
+        return AD_CATEGORY.OFFICE.id;
+      case "Kancelarije":
+        return AD_CATEGORY.OFFICE.id;
+      case "Apartmani":
+        return AD_CATEGORY.APARTMENT.id;
+      case "Garaža":
+        return AD_CATEGORY.GARAGE.id;
+      case "Vikendica":
+        return AD_CATEGORY.COTTAGE.id;
+      default:
+        return undefined;
+    }
+  }
+
+  getAdTypeId(adTypeText) {
+    switch (adTypeText) {
+      case "PRODAJA":
+        return AD_TYPE.AD_TYPE_SALE.stringId;
+      case "NAJAM":
+        return AD_TYPE.AD_TYPE_RENT.stringId;
+      default:
+        return undefined;
+    }
+  }
+
+  async sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  async saveCrawledResults(results) {
+    const savers = this.savers;
+
+    // for (const saver of savers) {
+    //   await saver.save(results);
+    // }
+
+    //For now, we use only Postgres saver, so ...
+    return savers[0].save(results);
+    //so that we can use some sequelize options and information when data is inserted
+  }
+}
+
+module.exports = SaljicCrawler;

app/helpers/db/realEstate.js

@@ -2,7 +2,6 @@
 const db = require("../../models/index");
 const sequelize = require("sequelize");
 const Op = sequelize.Op;
-
 const bulkUpsertRealEstates = async realEstateData => {
   try {
     const fieldsToUpdateIfDuplicate = [
@@ -87,7 +86,20 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     sizeMax,
     adType,
     realEstateType,
-    areaToSearch
+    areaToSearch,
+    gardenSizeMin,
+    gardenSizeMax,
+    numberOfRoomsMin,
+    numberOfRoomsMax,
+    numberOfFloorsMin,
+    numberOfFloorsMax,
+    floorMin,
+    floorMax,
+    includeIncompleteAds,
+    balcony,
+    elevator,
+    newBuilding,
+    accessRoadType
   } = searchRequest;
 
   const longitudeColumn = sequelize.col("locationLong");
@@ -116,12 +128,20 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
 
   const geoSearchQueryPart = sequelize.where(contains, true);
 
+  //General queries contain only attributes that are defined for every searchreq
+
+  //Query for case of complete ads
   const query = {
     adType,
     realEstateType,
     price: {
-      [Op.lte]: priceMax,
+      [Op.or]: {
-      [Op.gte]: priceMin
+        [Op.and]: {
+          [Op.lte]: priceMax,
+          [Op.gte]: priceMin
+        },
+        [Op.is]: null
+      }
     },
     area: {
       [Op.lte]: sizeMax,
@@ -130,10 +150,148 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     [Op.and]: geoSearchQueryPart
   };
 
+  //Query for case of incomplete ads
+  const queryIncludeIncomplete = {
+    adType,
+    realEstateType,
+    price: {
+      [Op.or]: {
+        [Op.and]: {
+          [Op.lte]: priceMax,
+          [Op.gte]: priceMin
+        },
+        [Op.is]: null
+      }
+    },
+    area: {
+      [Op.or]: {
+        [Op.and]: {
+          [Op.lte]: sizeMax,
+          [Op.gte]: sizeMin
+        },
+        [Op.is]: null
+      }
+    },
+    [Op.and]: geoSearchQueryPart
+  };
+
+  //Every other attribute is checked separately and included in query only if it is defined
+  if (gardenSizeMax && gardenSizeMin) {
+    query.gardenSize = {
+      [Op.lte]: gardenSizeMax,
+      [Op.gte]: gardenSizeMin
+    };
+    queryIncludeIncomplete.gardenSize = {
+      [Op.or]: {
+        [Op.and]: {
+          [Op.lte]: gardenSizeMax,
+          [Op.gte]: gardenSizeMin
+        },
+        [Op.is]: null
+      }
+    };
+  }
+
+  if (numberOfRoomsMin && numberOfRoomsMax) {
+    query.numberOfRooms = {
+      [Op.lte]: numberOfRoomsMax,
+      [Op.gte]: numberOfRoomsMin
+    };
+    queryIncludeIncomplete.numberOfRooms = {
+      [Op.or]: {
+        [Op.and]: {
+          [Op.lte]: numberOfRoomsMax,
+          [Op.gte]: numberOfRoomsMin
+        },
+        [Op.is]: null
+      }
+    };
+  }
+
+  if (numberOfFloorsMin && numberOfFloorsMax) {
+    query.numberOfFloors = {
+      [Op.lte]: numberOfFloorsMax,
+      [Op.gte]: numberOfFloorsMin
+    };
+    queryIncludeIncomplete.numberOfFloors = {
+      [Op.or]: {
+        [Op.and]: {
+          [Op.lte]: numberOfFloorsMax,
+          [Op.gte]: numberOfFloorsMin
+        },
+        [Op.is]: null
+      }
+    };
+  }
+
+  if (floorMin && floorMax) {
+    query.floor = {
+      [Op.lte]: floorMax,
+      [Op.gte]: floorMin
+    };
+    queryIncludeIncomplete.floor = {
+      [Op.or]: {
+        [Op.and]: {
+          [Op.lte]: floorMax,
+          [Op.gte]: floorMin
+        },
+        [Op.is]: null
+      }
+    };
+  }
+
+  if (balcony) {
+    query.balcony = {
+      [Op.eq]: balcony
+    };
+    queryIncludeIncomplete.balcony = {
+      [Op.or]: {
+        [Op.eq]: balcony,
+        [Op.is]: null
+      }
+    };
+  }
+
+  if (newBuilding) {
+    query.newBuilding = {
+      [Op.eq]: newBuilding
+    };
+    queryIncludeIncomplete.newBuilding = {
+      [Op.or]: {
+        [Op.eq]: newBuilding,
+        [Op.is]: null
+      }
+    };
+  }
+
+  if (elevator) {
+    query.elevator = {
+      [Op.eq]: elevator
+    };
+    queryIncludeIncomplete.elevator = {
+      [Op.or]: {
+        [Op.eq]: elevator,
+        [Op.is]: null
+      }
+    };
+  }
+
+  if (accessRoadType !== "ANY") {
+    query.accessRoadType = {
+      [Op.eq]: accessRoadType
+    };
+    queryIncludeIncomplete.accessRoadType = {
+      [Op.or]: {
+        [Op.eq]: accessRoadType,
+        [Op.is]: null
+      }
+    };
+  }
+
   const order = [["updatedAt", "desc"]];
 
-  return await db.RealEstate.findAll({
+  return db.RealEstate.findAll({
-    where: query,
+    where: includeIncompleteAds ? queryIncludeIncomplete : query,
     limit: maxResults,
     order
   });

app/helpers/db/searchRequest.js

@@ -2,11 +2,13 @@
 const db = require("../../models/index");
 const sequelize = require("sequelize");
 const Op = sequelize.Op;
+const { AD_CATEGORY } = require("../../common/enums");
 
 const getSearchRequest = async searchRequestId => {
   try {
     return await db.SearchRequest.findByPk(searchRequestId);
   } catch (error) {
+    console.log("searchrequest.js", error);
     return null;
   }
 };
@@ -22,7 +24,15 @@ const findSearchRequestsForRealEstate = async realEstate => {
     adType,
     realEstateType,
     locationLat,
-    locationLong
+    locationLong,
+    accessRoadType,
+    balcony,
+    newBuilding,
+    elevator,
+    gardenSize,
+    numberOfRooms,
+    numberOfFloors,
+    floor
   } = realEstate;
 
   if (!locationLat || !locationLong) {
@@ -39,12 +49,20 @@ const findSearchRequestsForRealEstate = async realEstate => {
 
   const geoSearchQueryPart = sequelize.where(contains, true);
 
+  //General query contains only attributes that are defined for every RealEstate - not null
   const query = {
     adType,
     realEstateType,
     subscribed: true,
     [Op.and]: geoSearchQueryPart
   };
+  //Needed for defining which attribute should exist or not
+  const realEstateTypeObject = AD_CATEGORY[realEstateType];
+  //Needed to decide on including incomplete RealEstates data
+  let checkForIncompleteWanted = false;
+
+  //Attributes are checked separately and included in query only if defined
+  //Price and area should be defined for every property
 
   if (price) {
     query.priceMin = {
@@ -62,8 +80,96 @@ const findSearchRequestsForRealEstate = async realEstate => {
     query.sizeMax = {
       [Op.gte]: area
     };
+  } else {
+    checkForIncompleteWanted = true;
+  }
+  //Other attributes can be defined or not depending on RealEstate type
+  if (gardenSize) {
+    query.gardenSizeMin = {
+      [Op.lte]: gardenSize
+    };
+    query.gardenSizeMax = {
+      [Op.gte]: gardenSize
+    };
+  } else if (realEstateTypeObject.hasGardenSize) {
+    checkForIncompleteWanted = true;
   }
 
+  if (numberOfRooms) {
+    query.numberOfRoomsMin = {
+      [Op.lte]: numberOfRooms
+    };
+    query.numberOfRoomsMax = {
+      [Op.gte]: numberOfRooms
+    };
+  } else if (realEstateTypeObject.hasNumberOfRoom) {
+    checkForIncompleteWanted = true;
+  }
+
+  if (numberOfFloors) {
+    query.numberOfFloorsMin = {
+      [Op.lte]: numberOfFloors
+    };
+    query.numberOfFloorsMax = {
+      [Op.gte]: numberOfFloors
+    };
+  } else if (realEstateTypeObject.hasNumberOfFloors) {
+    checkForIncompleteWanted = true;
+  }
+
+  if (floor) {
+    query.floorMin = {
+      [Op.lte]: floor
+    };
+    query.floorMax = {
+      [Op.gte]: floor
+    };
+  } else if (realEstateTypeObject.hasFloorProp) {
+    checkForIncompleteWanted = true;
+  }
+
+  if (accessRoadType) {
+    query.accessRoadType = {
+      [Op.or]: {
+        [Op.eq]: "ANY",
+        [Op.eq]: accessRoadType
+      }
+    };
+  } else if (realEstateTypeObject.hasAccesRoadType) {
+    checkForIncompleteWanted = true;
+  }
+
+  if (balcony) {
+    query.balcony = {
+      [Op.eq]: balcony
+    };
+  } else if (realEstateTypeObject.hasBalconyProp) {
+    checkForIncompleteWanted = true;
+  }
+
+  if (newBuilding) {
+    query.newBuilding = {
+      [Op.eq]: newBuilding
+    };
+  } else if (realEstateTypeObject.hasNewBuildingProp) {
+    checkForIncompleteWanted = true;
+  }
+
+  if (elevator) {
+    query.elevator = {
+      [Op.eq]: elevator
+    };
+  } else if (realEstateTypeObject.hasElevatorProp) {
+    checkForIncompleteWanted = true;
+  }
+
+  //If one of the attributes that exists for property type is null
+  //we include in query to check if incomplete real estates are accepted
+  if (checkForIncompleteWanted) {
+    query.includeIncompleteAds = {
+      [Op.eq]: true
+    };
+  }
   return await db.SearchRequest.findAll({ where: query });
 };
 

app/migrations/20191118105541-add-additional-fields-to-searchRequests-table.js

@@ -0,0 +1,64 @@
+"use strict";
+const { ACCESS_ROAD_TYPE, HEATING_TYPE } = require("../common/enums");
+
+module.exports = {
+  up: (queryInterface, Sequelize) => {
+    return Promise.all([
+      queryInterface.addColumn("SearchRequests", "includeIncompleteAds", {
+        type: Sequelize.BOOLEAN
+      }),
+      queryInterface.addColumn("SearchRequests", "balcony", {
+        type: Sequelize.BOOLEAN
+      }),
+      queryInterface.addColumn("SearchRequests", "newBuilding", {
+        type: Sequelize.BOOLEAN
+      }),
+      queryInterface.addColumn("SearchRequests", "elevator", {
+        type: Sequelize.BOOLEAN
+      }),
+      queryInterface.addColumn("SearchRequests", "numberOfRoomsMin", {
+        type: Sequelize.REAL
+      }),
+      queryInterface.addColumn("SearchRequests", "numberOfRoomsMax", {
+        type: Sequelize.REAL
+      }),
+      queryInterface.addColumn("SearchRequests", "numberOfFloorsMin", {
+        type: Sequelize.INTEGER
+      }),
+      queryInterface.addColumn("SearchRequests", "numberOfFloorsMax", {
+        type: Sequelize.INTEGER
+      }),
+      queryInterface.addColumn("SearchRequests", "floorMin", {
+        type: Sequelize.INTEGER
+      }),
+      queryInterface.addColumn("SearchRequests", "floorMax", {
+        type: Sequelize.INTEGER
+      }),
+      queryInterface.addColumn("SearchRequests", "accessRoadType", {
+        type: Sequelize.TEXT,
+        defaultValue: ACCESS_ROAD_TYPE.ANY.id
+      }),
+      queryInterface.addColumn("SearchRequests", "heatingType", {
+        type: Sequelize.TEXT,
+        defaultValue: HEATING_TYPE.ANY.id
+      })
+    ]);
+  },
+
+  down: (queryInterface, Sequelize) => {
+    return Promise.all([
+      queryInterface.removeColumn("SearchRequests", "includeIncompleteAds"),
+      queryInterface.removeColumn("SearchRequests", "balcony"),
+      queryInterface.removeColumn("SearchRequests", "newBuilding"),
+      queryInterface.removeColumn("SearchRequests", "elevator"),
+      queryInterface.removeColumn("SearchRequests", "numberOfRoomsMin"),
+      queryInterface.removeColumn("SearchRequests", "numberOfRoomsMax"),
+      queryInterface.removeColumn("SearchRequests", "numberOfFloorsMin"),
+      queryInterface.removeColumn("SearchRequests", "numberOfFloorsMax"),
+      queryInterface.removeColumn("SearchRequests", "floorMin"),
+      queryInterface.removeColumn("SearchRequests", "floorMax"),
+      queryInterface.removeColumn("SearchRequests", "accessRoadType"),
+      queryInterface.removeColumn("SearchRequests", "heatingType")
+    ]);
+  }
+};

app/models/searchRequest.js

@@ -69,7 +69,19 @@ module.exports = (sequelize, DataTypes) => {
     },
     deletedEmail: {
       type: DataTypes.TEXT
-    }
+    },
+    includeIncompleteAds: DataTypes.BOOLEAN,
+    balcony: DataTypes.BOOLEAN,
+    elevator: DataTypes.BOOLEAN,
+    newBuilding: DataTypes.BOOLEAN,
+    numberOfRoomsMin: DataTypes.REAL,
+    numberOfRoomsMax: DataTypes.REAL,
+    numberOfFloorsMin: DataTypes.INTEGER,
+    numberOfFloorsMax: DataTypes.INTEGER,
+    floorMin: DataTypes.INTEGER,
+    floorMax: DataTypes.INTEGER,
+    accessRoadType: DataTypes.TEXT,
+    heatingType: DataTypes.TEXT
   });
 
   return SearchRequest;

app/public/main.css

@@ -110,3 +110,47 @@ h3 {
 .collection a.collection-item:not(.active):hover {
   background-color: rgba(2, 173, 186, 0.2);
 }
+
+.tabs .tab a {
+  color: #02adba;
+  -webkit-transition: color 0.28s ease, background-color 0.28s ease;
+  transition: color 0.28s ease, background-color 0.28s ease;
+}
+.tabs .tab a:focus,
+.tabs .tab a:focus.active {
+  background-color: rgba(2, 173, 186, 0.2);
+}
+.tabs .tab a:hover,
+.tabs .tab a.active {
+  color: #02adba;
+}
+.tabs .indicator {
+  background-color: #02adba;
+}
+
+[type="checkbox"].filled-in:checked + span:not(.lever):after {
+  border: 2px solid #02adba;
+  background-color: #02adba;
+}
+[type="checkbox"].filled-in:not(:checked) + span:not(.lever):after {
+  background-color: transparent;
+  border: 2px solid #02adba;
+}
+
+.distinguished {
+  border: 2px solid #02adba;
+  border-radius: 4px;
+  padding: 5px 5px 3px 5px;
+  margin-left: -5px;
+}
+
+.checkbox-label {
+  color: black;
+  font-size: 14px;
+}
+
+.column-label {
+  position: relative;
+  margin-top: 2rem;
+  margin-bottom: 1rem;
+}

app/public/segment.css

@@ -25,6 +25,12 @@
   border-right: 1px solid #02adba;
 }
 
+.segmented.small [type="radio"]:not(:checked) + span,
+.segmented.small [type="radio"]:checked + span {
+  padding-left: 7px;
+  padding-right: 7px;
+}
+
 .segmented :last-child .label {
   border-right: none;
 }

app/views/advancedFilters.ejs

@@ -0,0 +1,69 @@
+<br>
+
+<% for (const filter of advancedBooleanFilterObjects){ %>
+  <p>
+    <label class="checkbox-label">
+      <input type="checkbox" class="filled-in" name="<%= filter.dbField %>"
+        <% if (advancedBooleanFilterValues[filter.dbField]) { %>
+          checked
+        <% } %>>
+      <span><%= filter.title %></span>
+    </label>
+  </p>
+<% } %>
+
+<br>
+<% for (const filter of advancedRangeFilterObjects){ %>
+    <div class="row">
+        <p class="column-label col s5 m3 l2">
+            <%= filter.title %>
+        </p>
+        <div class="input-field col s3 m4 l5">
+            <input
+                    id="<%= filter.dbFieldMin %>"
+                    name="<%= filter.dbFieldMin %>"
+                    type="number"
+                    value="<%= advancedRangeFilterValues[filter.dbFieldMin] !== undefined ? advancedRangeFilterValues[filter.dbFieldMin] : ""%>"
+            >
+            <label for="<%= filter.dbFieldMin %>">Od</label>
+        </div>
+        <div class="input-field col s3 m4 l5">
+            <input
+                    id="<%= filter.dbFieldMax %>"
+                    name="<%= filter.dbFieldMax %>"
+                    type="number"
+                    value="<%= advancedRangeFilterValues[filter.dbFieldMax] !== undefined ? advancedRangeFilterValues[filter.dbFieldMax] : ""%>"
+            >
+            <label for="<%= filter.dbFieldMax %>">Do</label>
+        </div>
+    </div>
+<% } %>
+
+<br>
+<% for (const filter of advancedSegmentSelectFilterObjects){ %>
+  <div>
+    <label class="checkbox-label"><%= filter.title %>: </label><br><br>
+    <span class="segmented small">
+      <% for (const segmentObject of filter.values) { %>
+        <label>
+            <input type="radio" name="<%= filter.dbField %>" value="<%= segmentObject.id %>"
+            <% if (advancedSegmentSelectFilterValues[filter.dbField] === segmentObject.id) { %>
+               checked
+            <% } %>>
+            <span class="label"><%= segmentObject.title %></span>
+        </label>
+      <% } %>
+    </span>
+  </div>
+<% } %>
+
+<br>
+<p class="distinguished">
+  <label class="checkbox-label">
+    <input type="checkbox" class="filled-in" name="includeIncompleteAds"
+      <% if (includeIncompleteAds) { %>
+           checked
+      <% } %>>
+    <span>Uključi i oglase bez potpunih informacija</span>
+  </label>
+</p>

app/views/location.ejs

@@ -1,13 +1,17 @@
 <div class="row center-align">
   <h3>
-  Područje na mapi će biti uključeno u pretragu. Namjestite mapu na ulice
+    Područje na mapi će biti uključeno u pretragu. Namjestite mapu na ulice koje
-  koje želite da budu vidljive.
+    želite da budu vidljive.
   </h3>
 </div>
 
 <div class="row center-align">
   <div class="col s12 m12 l12 xl12">
-    <input id="autocompleteInput" placeholder="Unesite grad, naselje ili ulicu..." type="text" />
+    <input
+      id="autocompleteInput"
+      placeholder="Unesite grad, naselje ili ulicu..."
+      type="text"
+    />
   </div>
 </div>
 
@@ -17,12 +21,17 @@
   </div>
 </div>
 
-<br>
+<br />
 
 <form method="POST" id="form-map-output">
   <div class="row center-align">
     <div class="col s6 push-s3">
-      <a id="submit" href="#" class="welcome-center-button waves-effect waves-light btn">Dalje</a>
+      <a
+        id="submit"
+        href="#"
+        class="welcome-center-button waves-effect waves-light btn"
+        >Dalje</a
+      >
     </div>
   </div>
   <input type="hidden" name="north" id="north" />
@@ -41,15 +50,15 @@
 
   function locateMe() {
     if (navigator.geolocation) {
-
+      function onLocationSuccess(position) {
-      function onLocationSuccess (position) {
+        const coordinates =
-        const coordinates = position && position.coords ? position.coords : null;
+          position && position.coords ? position.coords : null;
-        if (coordinates){
+        if (coordinates) {
           const longitude = coordinates.longitude || null;
           const latitude = coordinates.latitude || null;
 
-          if (longitude && latitude && map){
+          if (longitude && latitude && map) {
-            map.setCenter({lat: latitude, lng: longitude});
+            map.setCenter({ lat: latitude, lng: longitude });
             map.setZoom(16);
           }
         }
@@ -61,20 +70,20 @@
 
   function initMap() {
     const BOSNIA_BOUNDS = {
-      north: 45.70,
+      north: 45.7,
       south: 41.69,
       west: 15.55,
-      east: 20.77,
+      east: 20.77
     };
     const SARAJEVO_COORDINATES = {
       lat: 43.85,
-      lng: 18.41,
+      lng: 18.41
     };
 
-    const mapElement = document.getElementById('map');
+    const mapElement = document.getElementById("map");
     const restrictMapPanningToBosniaOnly = {
       latLngBounds: BOSNIA_BOUNDS,
-      strictBounds: true,
+      strictBounds: true
     };
     const initialMapParams = {
       center: SARAJEVO_COORDINATES,
@@ -87,38 +96,50 @@
     };
     map = new google.maps.Map(mapElement, initialMapParams);
 
-    const inputElement = document.getElementById('autocompleteInput');
+    const inputElement = document.getElementById("autocompleteInput");
-    const restrictAutocompleteResultsToBosniaOnly = {'country': 'ba'};
+    const restrictAutocompleteResultsToBosniaOnly = { country: "ba" };
     const initialAutocompleteParams = {
-      types: ['geocode'],
+      types: ["geocode"],
       componentRestrictions: restrictAutocompleteResultsToBosniaOnly,
-      fields: ['geometry', 'types', 'address_components']
+      fields: ["geometry", "types", "address_components"]
     };
 
-    autocomplete = new google.maps.places.Autocomplete(inputElement, initialAutocompleteParams);
+    autocomplete = new google.maps.places.Autocomplete(
-    autocomplete.bindTo('bounds', map);
+      inputElement,
-    autocomplete.addListener('place_changed', onPlaceChanged);
+      initialAutocompleteParams
+    );
+    autocomplete.bindTo("bounds", map);
+    autocomplete.addListener("place_changed", onPlaceChanged);
     pacSelectFirst(inputElement);
     addLocateMeButton(map);
+
+    //After map initialization we check if area is already selected
+    //If yes we bound map to show already selected area
+    const boundsSelected = <%- boundsSelected %>;
+    const selectedLatLngBounds = <%- JSON.stringify(selectedLatLngBounds) %>;
+
+    if (boundsSelected) {
+      boundMapToSelected(map, selectedLatLngBounds);
+    }
   }
 
   function addLocateMeButton(map) {
-    var parent = document.createElement('div');
+    var parent = document.createElement("div");
     parent.className = "locate-me-container";
 
-    var a = document.createElement('a');
+    var a = document.createElement("a");
     a.id = "locateMe";
     a.className = "btn-floating";
 
-    var i = document.createElement('i');
+    var i = document.createElement("i");
     i.innerText = "gps_fixed";
     i.className = "material-icons right";
 
-    a.appendChild(i)
+    a.appendChild(i);
     a.addEventListener("click", locateMe);
-    parent.appendChild(a)
+    parent.appendChild(a);
 
-    map.controls[google.maps.ControlPosition.RIGHT_BOTTOM].push(parent)
+    map.controls[google.maps.ControlPosition.RIGHT_BOTTOM].push(parent);
   }
 
   function onPlaceChanged() {
@@ -133,33 +154,49 @@
   function pacSelectFirst(input) {
     // store the original event binding function
     const _addEventListener = input.addEventListener
-            ? input.addEventListener
+      ? input.addEventListener
-            : input.attachEvent
+      : input.attachEvent;
 
-    function addEventListenerWrapper (type, listener) {
+    function addEventListenerWrapper(type, listener) {
       // Simulate a 'down arrow' keypress on hitting 'return' when no pac suggestion is selected,
       // and then trigger the original listener.
-      if (type == 'keydown') {
+      if (type == "keydown") {
-        const originalListener = listener
+        const originalListener = listener;
-        listener = function (event) {
+        listener = function(event) {
-          const suggestionSelected = $('.pac-item-selected').length > 0
+          const suggestionSelected = $(".pac-item-selected").length > 0;
-          if (event.key == 'Enter' && !suggestionSelected) {
+          if (event.key == "Enter" && !suggestionSelected) {
-            const simulatedDownArrow = $.Event('keydown', {
+            const simulatedDownArrow = $.Event("keydown", {
               keyCode: 40,
               which: 40
-            })
+            });
-            originalListener.apply(input, [simulatedDownArrow])
+            originalListener.apply(input, [simulatedDownArrow]);
           }
 
-          originalListener.apply(input, [event])
+          originalListener.apply(input, [event]);
-        }
+        };
       }
 
-      _addEventListener.apply(input, [type, listener])
+      _addEventListener.apply(input, [type, listener]);
     }
 
-    input.addEventListener = addEventListenerWrapper
+    input.addEventListener = addEventListenerWrapper;
-    input.attachEvent = addEventListenerWrapper
+    input.attachEvent = addEventListenerWrapper;
+  }
+  function boundMapToSelected(map, selectedLatLngBounds) {
+
+    const swBound = new google.maps.LatLng(
+      selectedLatLngBounds.swLat,
+      selectedLatLngBounds.swLng
+    );
+    const neBound = new google.maps.LatLng(
+      selectedLatLngBounds.neLat,
+      selectedLatLngBounds.neLng
+    );
+    let bounds = new google.maps.LatLngBounds();
+    bounds.extend(swBound);
+    bounds.extend(neBound);
+
+    map.fitBounds(bounds);
   }
 
   $(document).ready(function() {
@@ -171,11 +208,16 @@
       $("#east").val(mapBounds.getNorthEast().lng());
       $("#west").val(mapBounds.getSouthWest().lng());
 
-      $("#locationInput").val(document.getElementById('autocompleteInput').value);
+      $("#locationInput").val(
+        document.getElementById("autocompleteInput").value
+      );
 
       $("#form-map-output").submit();
     });
   });
 </script>
-<script src="https://maps.googleapis.com/maps/api/js?key=AIzaSyAna8ohfV2HBMcxGk_29vqxU5Z_bDickqg&language=bs&libraries=places&callback=initMap" async
+<script
-  defer></script>
+  src="https://maps.googleapis.com/maps/api/js?key=<%= process.env.API_MAP_KEY %>&language=bs&libraries=places&callback=initMap"
+  async
+  defer
+></script>

app/views/realEstateFilters.ejs

@@ -1,63 +1,20 @@
+<br>
 <form id="filtersForm" method="POST">
-  <br>
-
-  <div class="row center-align">
-    <h5>Cijena</h5>
-    <br><br>
-    <div class="center-align no-ui-slider" id="priceFilter"></div>
-  </div>
-
-  <br>
   <div class="row">
-    <div class="col s5 m3 l3 push-m1 push-l2">
+    <div class="col s12">
-      <input class="sliderInputBox" type="number" id="priceMin" name="priceMin">
+      <ul class="tabs">
-
+        <li class="tab col s6"><a href="#standardFilters">Filteri</a></li>
+        <li class="tab col s6"><a href="#advancedFilters">Napredni filteri</a></li>
+      </ul>
     </div>
-    <div class="col s5 m3 l3 push-s1 push-m4 push-l4">
+    <div id="standardFilters" class="col s12">
-      <input class="sliderInputBox" type="number" id="priceMax" name="priceMax">
+      <%- include("./standardFilters.ejs") %>
+    </div>
+    <div id="advancedFilters" class="col s12">
+      <%- include("./advancedFilters.ejs") %>
     </div>
   </div>
 
-  <br>
-
-  <div class="row center-align">
-    <h5>Površina</h5>
-    <br><br>
-    <div class="center-align no-ui-slider" id="sizeFilter"></div>
-  </div>
-
-  <br>
-  <div class="row">
-    <div class="col s5 m3 l3 push-m1 push-l2">
-      <input class="sliderInputBox" type="number" id="sizeMin" name="sizeMin">
-
-    </div>
-    <div class="col s5 m3 l3 push-s1 push-m4 push-l4">
-      <input class="sliderInputBox" type="number" id="sizeMax" name="sizeMax">
-    </div>
-  </div>
-
-  <br>
-
-  <% if(hasGardenSize) { %>
-    <div class="row center-align">
-      <h5>Površina okućnice</h5>
-      <br><br>
-      <div class="center-align no-ui-slider" id="gardenSizeFilter"></div>
-    </div>
-
-    <br>
-    <div class="row">
-      <div class="col s5 m3 l3 push-m1 push-l2">
-        <input class="sliderInputBox" type="number" id="gardenSizeMin" name="gardenSizeMin">
-
-      </div>
-      <div class="col s5 m3 l3 push-s1 push-m4 push-l4">
-        <input class="sliderInputBox" type="number" id="gardenSizeMax" name="gardenSizeMax">
-      </div>
-    </div>
-  <% } %>
-
   <div class="row">
     <div class="col s6 push-s3">
       <a id="submit" href="#" class="welcome-center-button waves-effect waves-light btn">Dalje</a>
@@ -66,125 +23,7 @@
 </form>
 
 <script>
-  $(document).ready(function() {
+  $(document).ready(function(){
-    const priceSliderOptions = <%- priceSliderOptions %>;
+    $('.tabs').tabs();
-    const sizeSliderOptions = <%- sizeSliderOptions %>;
-    const priceStep = priceSliderOptions.step;
-    const sizeStep = sizeSliderOptions.step;
-    delete priceSliderOptions.step;
-    delete sizeSliderOptions.step;
-
-    function updatePriceInputs(values, handle, unencoded) {
-      $("#priceMin").val(Math.round(unencoded[0]/priceStep)*priceStep);
-      $("#priceMax").val(Math.round(unencoded[1]/priceStep)*priceStep);
-    }
-    function updateSizeInputs(values, handle, unencoded) {
-      $("#sizeMin").val(Math.round(unencoded[0]/sizeStep)*sizeStep);
-      $("#sizeMax").val(Math.round(unencoded[1]/sizeStep)*sizeStep);
-    }
-
-    const priceSlider = document.getElementById("priceFilter");
-    const sizeSlider = document.getElementById("sizeFilter");
-
-    const priceSliderObject = noUiSlider.create(priceSlider, priceSliderOptions);
-    const sizeSliderObject = noUiSlider.create(sizeSlider, sizeSliderOptions);
-
-    priceSliderObject.on('slide', updatePriceInputs);
-    sizeSliderObject.on('slide', updateSizeInputs);
-
-    function priceMinChangeHandler(element) {
-      if (element && element.currentTarget && element.currentTarget.value){
-        const currentValues = priceSliderObject.get();
-        const newValue = element.currentTarget.value;
-        const fixedNewValue = newValue > currentValues[1] ? currentValues[1] : newValue;
-        priceSliderObject.set([fixedNewValue, null]);
-        $("#priceMin").val(Math.round(priceSliderObject.get()[0]));
-      }
-    }
-    function priceMaxChangeHandler(element) {
-      if (element && element.currentTarget && element.currentTarget.value){
-        const newValue = element.currentTarget.value;
-        priceSliderObject.set([null, newValue]);
-        $("#priceMax").val(Math.round(priceSliderObject.get()[1]));
-      }
-    }
-    $("#priceMin").val(priceSliderOptions.start[0]);
-    $("#priceMax").val(priceSliderOptions.start[1]);
-    $("#priceMin").change(priceMinChangeHandler);
-    $("#priceMax").change(priceMaxChangeHandler);
-
-    function sizeMinChangeHandler(element) {
-      if (element && element.currentTarget && element.currentTarget.value){
-        const currentValues = sizeSliderObject.get();
-        const newValue = element.currentTarget.value;
-        const fixedNewValue = newValue > currentValues[1] ? currentValues[1] : newValue;
-        sizeSliderObject.set([fixedNewValue, null]);
-        $("#sizeMin").val(Math.round(sizeSliderObject.get()[0]));
-      }
-    }
-    function sizeMaxChangeHandler(element) {
-      if (element && element.currentTarget && element.currentTarget.value){
-        const newValue = element.currentTarget.value;
-        sizeSliderObject.set([null, newValue]);
-        $("#sizeMax").val(Math.round(sizeSliderObject.get()[1]));
-      }
-    }
-    $("#sizeMin").val(sizeSliderOptions.start[0]);
-    $("#sizeMax").val(sizeSliderOptions.start[1]);
-    $("#sizeMin").change(sizeMinChangeHandler);
-    $("#sizeMax").change(sizeMaxChangeHandler);
-
-    <% if(hasGardenSize) { %>
-    const gardenSizeSliderOptions = <%- gardenSizeSliderOptions %>;
-    const gardenSizeStep = gardenSizeSliderOptions.step;
-    delete gardenSizeSliderOptions.step;
-
-    function updateGardenSizeInputs(values, handle, unencoded) {
-      $("#gardenSizeMin").val(Math.round(unencoded[0]/gardenSizeStep)*gardenSizeStep);
-      $("#gardenSizeMax").val(Math.round(unencoded[1]/gardenSizeStep)*gardenSizeStep);
-    }
-
-    const gardenSizeSlider = document.getElementById("gardenSizeFilter");
-    const gardenSizeSliderObject = noUiSlider.create(gardenSizeSlider, gardenSizeSliderOptions);
-    gardenSizeSliderObject.on('slide', updateGardenSizeInputs);
-    function gardenSizeMinChangeHandler(element) {
-      if (element && element.currentTarget && element.currentTarget.value){
-        const currentValues = gardenSizeSliderObject.get();
-        const newValue = element.currentTarget.value;
-        const fixedNewValue = newValue > currentValues[1] ? currentValues[1] : newValue;
-        gardenSizeSliderObject.set([fixedNewValue, null]);
-        $("#gardenSizeMin").val(Math.round(gardenSizeSliderObject.get()[0]));
-      }
-    }
-    function gardenSizeMaxChangeHandler(element) {
-      if (element && element.currentTarget && element.currentTarget.value){
-        const newValue = element.currentTarget.value;
-        gardenSizeSliderObject.set([null, newValue]);
-        $("#gardenSizeMin").val(Math.round(gardenSizeSliderObject.get()[0]));
-      }
-    }
-    $("#gardenSizeMin").val(gardenSizeSliderOptions.start[0]);
-    $("#gardenSizeMax").val(gardenSizeSliderOptions.start[1]);
-    $("#gardenSizeMin").change("step", gardenSizeMinChangeHandler);
-    $("#gardenSizeMax").change("step", gardenSizeMaxChangeHandler);
-    <% } %>
-
-    $("#submit").click(function() {
-      const priceFilterValues = priceSlider.noUiSlider.get();
-      $("#priceFilterMin").val(priceFilterValues[0]);
-      $("#priceFilterMax").val(priceFilterValues[1]);
-
-      const sizeFilterValues = sizeSlider.noUiSlider.get();
-      $("#sizeFilterMin").val(sizeFilterValues[0]);
-      $("#sizeFilterMax").val(sizeFilterValues[1]);
-
-      <% if (hasGardenSize) { %>
-        const gardenSizeFilterValues = gardenSizeSlider.noUiSlider.get();
-        $("#gardenSizeFilterMin").val(gardenSizeFilterValues[0]);
-        $("#gardenSizeFilterMax").val(gardenSizeFilterValues[1]);
-      <% } %>
-
-      $("#filtersForm").submit();
-    });
   });
 </script>

app/views/standardFilters.ejs

@@ -0,0 +1,195 @@
+<br />
+
+<div class="row center-align">
+  <h5>Cijena (KM)</h5>
+  <br /><br />
+  <div class="col s12">
+    <div class="center-align no-ui-slider" id="priceFilter"></div>
+  </div>
+</div>
+
+<br />
+<div class="row">
+  <div class="col s5 m3 l3 push-m1 push-l2">
+    <input class="sliderInputBox" type="number" id="priceMin" name="priceMin" />
+  </div>
+  <div class="col s5 m3 l3 push-s1 push-m4 push-l4">
+    <input class="sliderInputBox" type="number" id="priceMax" name="priceMax" />
+  </div>
+</div>
+
+<br />
+
+<div class="row center-align">
+  <h5>Površina (m<sup>2</sup>)</h5>
+  <br /><br />
+  <div class="col s12">
+    <div class="center-align no-ui-slider" id="sizeFilter"></div>
+  </div>
+</div>
+
+<br />
+<div class="row">
+  <div class="col s5 m3 l3 push-m1 push-l2">
+    <input class="sliderInputBox" type="number" id="sizeMin" name="sizeMin" />
+  </div>
+  <div class="col s5 m3 l3 push-s1 push-m4 push-l4">
+    <input class="sliderInputBox" type="number" id="sizeMax" name="sizeMax" />
+  </div>
+</div>
+
+<br />
+
+<% if(hasGardenSize) { %>
+<div class="row center-align">
+  <h5>Površina okućnice (m<sup>2</sup>)</h5>
+  <br /><br />
+  <div class="col s12">
+    <div class="center-align no-ui-slider" id="gardenSizeFilter"></div>
+  </div>
+</div>
+
+<br />
+<div class="row">
+  <div class="col s5 m3 l3 push-m1 push-l2">
+    <input
+      class="sliderInputBox"
+      type="number"
+      id="gardenSizeMin"
+      name="gardenSizeMin"
+    />
+  </div>
+  <div class="col s5 m3 l3 push-s1 push-m4 push-l4">
+    <input
+      class="sliderInputBox"
+      type="number"
+      id="gardenSizeMax"
+      name="gardenSizeMax"
+    />
+  </div>
+</div>
+<% } %>
+
+<script>
+  $(document).ready(function() {
+    const priceSliderOptions = <%- priceSliderOptions %>;
+    const sizeSliderOptions = <%- sizeSliderOptions %>;
+    const priceStep = priceSliderOptions.step;
+    const sizeStep = sizeSliderOptions.step;
+    delete priceSliderOptions.step;
+    delete sizeSliderOptions.step;
+
+    function updatePriceInputs(values, handle, unencoded) {
+      $("#priceMin").val(Math.round(unencoded[0]/priceStep)*priceStep);
+      $("#priceMax").val(Math.round(unencoded[1]/priceStep)*priceStep);
+    }
+    function updateSizeInputs(values, handle, unencoded) {
+      $("#sizeMin").val(Math.round(unencoded[0]/sizeStep)*sizeStep);
+      $("#sizeMax").val(Math.round(unencoded[1]/sizeStep)*sizeStep);
+    }
+
+    const priceSlider = document.getElementById("priceFilter");
+    const sizeSlider = document.getElementById("sizeFilter");
+
+    const priceSliderObject = noUiSlider.create(priceSlider, priceSliderOptions);
+    const sizeSliderObject = noUiSlider.create(sizeSlider, sizeSliderOptions);
+
+    priceSliderObject.on('slide', updatePriceInputs);
+    sizeSliderObject.on('slide', updateSizeInputs);
+
+    function priceMinChangeHandler(element) {
+      if (element && element.currentTarget && element.currentTarget.value){
+        const currentValues = priceSliderObject.get();
+        const newValue = element.currentTarget.value;
+        const fixedNewValue = newValue > currentValues[1] ? currentValues[1] : newValue;
+        priceSliderObject.set([fixedNewValue, null]);
+        $("#priceMin").val(Math.round(priceSliderObject.get()[0]));
+      }
+    }
+    function priceMaxChangeHandler(element) {
+      if (element && element.currentTarget && element.currentTarget.value){
+        const newValue = element.currentTarget.value;
+        priceSliderObject.set([null, newValue]);
+        $("#priceMax").val(Math.round(priceSliderObject.get()[1]));
+      }
+    }
+    $("#priceMin").val(priceSliderOptions.start[0]);
+    $("#priceMax").val(priceSliderOptions.start[1]);
+    $("#priceMin").change(priceMinChangeHandler);
+    $("#priceMax").change(priceMaxChangeHandler);
+
+    function sizeMinChangeHandler(element) {
+      if (element && element.currentTarget && element.currentTarget.value){
+        const currentValues = sizeSliderObject.get();
+        const newValue = element.currentTarget.value;
+        const fixedNewValue = newValue > currentValues[1] ? currentValues[1] : newValue;
+        sizeSliderObject.set([fixedNewValue, null]);
+        $("#sizeMin").val(Math.round(sizeSliderObject.get()[0]));
+      }
+    }
+    function sizeMaxChangeHandler(element) {
+      if (element && element.currentTarget && element.currentTarget.value){
+        const newValue = element.currentTarget.value;
+        sizeSliderObject.set([null, newValue]);
+        $("#sizeMax").val(Math.round(sizeSliderObject.get()[1]));
+      }
+    }
+    $("#sizeMin").val(sizeSliderOptions.start[0]);
+    $("#sizeMax").val(sizeSliderOptions.start[1]);
+    $("#sizeMin").change(sizeMinChangeHandler);
+    $("#sizeMax").change(sizeMaxChangeHandler);
+
+    <% if(hasGardenSize) { %>
+    const gardenSizeSliderOptions = <%- gardenSizeSliderOptions %>;
+    const gardenSizeStep = gardenSizeSliderOptions.step;
+    delete gardenSizeSliderOptions.step;
+
+    function updateGardenSizeInputs(values, handle, unencoded) {
+      $("#gardenSizeMin").val(Math.round(unencoded[0]/gardenSizeStep)*gardenSizeStep);
+      $("#gardenSizeMax").val(Math.round(unencoded[1]/gardenSizeStep)*gardenSizeStep);
+    }
+
+    const gardenSizeSlider = document.getElementById("gardenSizeFilter");
+    const gardenSizeSliderObject = noUiSlider.create(gardenSizeSlider, gardenSizeSliderOptions);
+    gardenSizeSliderObject.on('slide', updateGardenSizeInputs);
+    function gardenSizeMinChangeHandler(element) {
+      if (element && element.currentTarget && element.currentTarget.value){
+        const currentValues = gardenSizeSliderObject.get();
+        const newValue = element.currentTarget.value;
+        const fixedNewValue = newValue > currentValues[1] ? currentValues[1] : newValue;
+        gardenSizeSliderObject.set([fixedNewValue, null]);
+        $("#gardenSizeMin").val(Math.round(gardenSizeSliderObject.get()[0]));
+      }
+    }
+    function gardenSizeMaxChangeHandler(element) {
+      if (element && element.currentTarget && element.currentTarget.value){
+        const newValue = element.currentTarget.value;
+        gardenSizeSliderObject.set([null, newValue]);
+        $("#gardenSizeMin").val(Math.round(gardenSizeSliderObject.get()[0]));
+      }
+    }
+    $("#gardenSizeMin").val(gardenSizeSliderOptions.start[0]);
+    $("#gardenSizeMax").val(gardenSizeSliderOptions.start[1]);
+    $("#gardenSizeMin").change("step", gardenSizeMinChangeHandler);
+    $("#gardenSizeMax").change("step", gardenSizeMaxChangeHandler);
+    <% } %>
+
+    $("#submit").click(function() {
+      const priceFilterValues = priceSlider.noUiSlider.get();
+      $("#priceFilterMin").val(priceFilterValues[0]);
+      $("#priceFilterMax").val(priceFilterValues[1]);
+
+      const sizeFilterValues = sizeSlider.noUiSlider.get();
+      $("#sizeFilterMin").val(sizeFilterValues[0]);
+      $("#sizeFilterMax").val(sizeFilterValues[1]);
+
+      <% if (hasGardenSize) { %>
+        const gardenSizeFilterValues = gardenSizeSlider.noUiSlider.get();
+        $("#gardenSizeFilterMin").val(gardenSizeFilterValues[0]);
+        $("#gardenSizeFilterMax").val(gardenSizeFilterValues[1]);
+      <% } %>
+
+      $("#filtersForm").submit();
+    });
+  });
+</script>

development.env

@@ -14,6 +14,9 @@ MAX_REAL_ESTATES_IN_FIRST_EMAIL=Max number of real estates that will be shown in
 #=============== GOOGLE ANALYTICS =============#
 GA_ID=Google Analytics ID
 
+#=============== GOOGLE MAPS =============#
+API_MAP_KEY=(your-key-here)
+
 #=============== AWS SDK EMAIL SETTINGS =======#
 AWS_KEY_ID=(your-key-here)
 AWS_SECRET_ACCESS_KEY=(your-key-here)
@@ -56,3 +59,8 @@ AKTIDO_CRAWLER_AD_CATEGORIES=comma separated list of enum names of categories to
 AKTIDO_IGNORED_USERNAMES=!!! This is not used for aktido crawler !!!
 AKTIDO_DELAY_BETWEEN_PAGES=time in miliseconds to wait before indexing next page
 AKTIDO_FORCE_CRAWL=Non-zero value will force crawler to crawl all pages without stopping when known real estate is found
+#==SALJIC NEKRETNINE==
+SALJIC_MAX_RESULTS_PER_PAGE=For Saljic crawler, this represents how many ads are crawled at once
+SALJIC_CRAWLER_AD_TYPE=enum name of what type of ads should be crawled, check common/enums.js file for valid values
+SALJIC_CRAWLER_AD_CATEGORIES=comma separated list of enum names of categories to be included, check common/enums.js file for valid values
+SALJIC_FORCE_CRAWL=Non-zero value will force crawler to crawl all pages without stopping when known real estate is found

package-lock.json

@@ -1052,6 +1052,14 @@
       "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
       "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ="
     },
+    "eslint-plugin-prettier": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-3.1.2.tgz",
+      "integrity": "sha512-GlolCC9y3XZfv3RQfwGew7NnuFDKsfI4lbvRK+PIIo23SFH+LemGs4cKwzAaRa+Mdb+lQO/STaIayno8T5sJJA==",
+      "requires": {
+        "prettier-linter-helpers": "^1.0.0"
+      }
+    },
     "etag": {
       "version": "1.8.1",
       "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
@@ -1271,6 +1279,11 @@
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz",
       "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk="
     },
+    "fast-diff": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.2.0.tgz",
+      "integrity": "sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w=="
+    },
     "fast-json-stable-stringify": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz",
@@ -3179,6 +3192,19 @@
       "integrity": "sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=",
       "dev": true
     },
+    "prettier": {
+      "version": "1.19.1",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-1.19.1.tgz",
+      "integrity": "sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew=="
+    },
+    "prettier-linter-helpers": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz",
+      "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==",
+      "requires": {
+        "fast-diff": "^1.1.2"
+      }
+    },
     "process-nextick-args": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz",

package.json

@@ -35,6 +35,7 @@
     "compression": "^1.7.4",
     "dotenv": "^7.0.0",
     "ejs": "^2.6.1",
+    "eslint-plugin-prettier": "^3.1.2",
     "express": "^4.16.4",
     "express-ejs-layouts": "^2.5.0",
     "express-layout": "^0.1.0",
@@ -44,6 +45,7 @@
     "node-fetch": "^2.3.0",
     "node-schedule": "^1.3.2",
     "pg": "^7.10.0",
+    "prettier": "^1.19.1",
     "react-step-wizard": "^5.1.0",
     "sequelize": "^5.18.4",
     "sequelize-cli": "^5.5.0"

test/rentalScrapeTest.js

@@ -13,5 +13,5 @@ if (urlToScrape) {
   })();
 } else {
   console.log("No URL to scrape. Use like this : ");
-  console.log("npm run test-olx-scraper -- URL_TO_SCRAPE");
+  console.log("npm run test-rental-scraper -- URL_TO_SCRAPE");
 }