Changed sliders for different realestate types.

.prettierignore

@@ -1 +0,0 @@
-*.ejs

app/common/enums.js

@@ -7,7 +7,42 @@ const PRICE_SLIDER_OPTIONS_SALE = {
   step: 1000,
   connect: true
 };
-
+const FLAT_PRICE_SLIDER_OPTIONS_SALE = {
+  start: [50000, 150000],
+  range: {
+    min: [0],
+    max: [800000]
+  },
+  step: 5000,
+  connect: true
+};
+const HOUSE_PRICE_SLIDER_OPTIONS_SALE = {
+  start: [50000, 150000],
+  range: {
+    min: [0],
+    max: [1500000]
+  },
+  step: 10000,
+  connect: true
+};
+const OFFICE_PRICE_SLIDER_OPTIONS_SALE = {
+  start: [15000, 50000],
+  range: {
+    min: [0],
+    max: [2000000]
+  },
+  step: 2000,
+  connect: true
+};
+const LAND_PRICE_SLIDER_OPTIONS_SALE = {
+  start: [40000, 80000],
+  range: {
+    min: [0],
+    max: [2000000]
+  },
+  step: 10000,
+  connect: true
+};
 const PRICE_SLIDER_OPTIONS_RENT = {
   start: [300, 500],
   range: {
@@ -17,18 +52,62 @@ const PRICE_SLIDER_OPTIONS_RENT = {
   step: 50,
   connect: true
 };
-
+const FLAT_PRICE_SLIDER_OPTIONS_RENT = {
+  start: [300, 600],
+  range: {
+    min: [0],
+    max: [4000]
+  },
+  step: 100,
+  connect: true
+};
+const HOUSE_PRICE_SLIDER_OPTIONS_RENT = {
+  start: [500, 1000],
+  range: {
+    min: [0],
+    max: [10000]
+  },
+  step: 100,
+  connect: true
+};
+const OFFICE_PRICE_SLIDER_OPTIONS_RENT = {
+  start: [200, 1000],
+  range: {
+    min: [0],
+    max: [20000]
+  },
+  step: 100,
+  connect: true
+};
+const LAND_PRICE_SLIDER_OPTIONS_RENT = {
+  start: [500, 1000],
+  range: {
+    min: [0],
+    max: [20000]
+  },
+  step: 100,
+  connect: true
+};
 //This will be used for Flats, Apartments, Houses
 const HOME_SIZE_SLIDER_OPTIONS = {
   start: [30, 75],
   range: {
     min: [0],
-    max: [400]
+    max: [500]
   },
   step: 5,
   connect: true
 };
 
+const OFFICE_SIZE_SLIDER_OPTIONS = {
+  start: [30, 150],
+  range: {
+    min: [0],
+    max: [1200]
+  },
+  step: 10,
+  connect: true
+};
 const GARDEN_SIZE_SLIDER_OPTIONS = {
   start: [100, 1000],
   range: {
@@ -111,8 +190,8 @@ const AD_CATEGORY = {
     hasNumberOfRoom: true,
     hasNumberOfFloors: false,
     hasFloorProp: true,
-    priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
+    priceSliderOptionsSale: FLAT_PRICE_SLIDER_OPTIONS_SALE,
-    priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
+    priceSliderOptionsRent: FLAT_PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS
   },
   HOUSE: {
@@ -126,8 +205,8 @@ const AD_CATEGORY = {
     hasNumberOfRoom: true,
     hasNumberOfFloors: true,
     hasFloorProp: false,
-    priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
+    priceSliderOptionsSale: HOUSE_PRICE_SLIDER_OPTIONS_SALE,
-    priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
+    priceSliderOptionsRent: HOUSE_PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS,
     gardenSizeSliderOptions: GARDEN_SIZE_SLIDER_OPTIONS
   },
@@ -142,9 +221,9 @@ const AD_CATEGORY = {
     hasNumberOfRoom: true,
     hasNumberOfFloors: false,
     hasFloorProp: true,
-    priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
+    priceSliderOptionsSale: OFFICE_PRICE_SLIDER_OPTIONS_SALE,
-    priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
+    priceSliderOptionsRent: OFFICE_PRICE_SLIDER_OPTIONS_RENT,
-    sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS
+    sizeSliderOptions: OFFICE_SIZE_SLIDER_OPTIONS
   },
   LAND: {
     id: "LAND",
@@ -157,8 +236,8 @@ const AD_CATEGORY = {
     hasNumberOfRoom: false,
     hasNumberOfFloors: false,
     hasFloorProp: false,
-    priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
+    priceSliderOptionsSale: LAND_PRICE_SLIDER_OPTIONS_SALE,
-    priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
+    priceSliderOptionsRent: LAND_PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: LAND_SIZE_SLIDER_OPTIONS
   },
   APARTMENT: {
@@ -172,8 +251,8 @@ const AD_CATEGORY = {
     hasNumberOfRoom: true,
     hasNumberOfFloors: false,
     hasFloorProp: true,
-    priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
+    priceSliderOptionsSale: FLAT_PRICE_SLIDER_OPTIONS_SALE,
-    priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
+    priceSliderOptionsRent: FLAT_PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS
   },
   GARAGE: {
@@ -202,8 +281,8 @@ const AD_CATEGORY = {
     hasNumberOfRoom: true,
     hasNumberOfFloors: true,
     hasFloorProp: false,
-    priceSliderOptionsSale: PRICE_SLIDER_OPTIONS_SALE,
+    priceSliderOptionsSale: HOUSE_PRICE_SLIDER_OPTIONS_SALE,
-    priceSliderOptionsRent: PRICE_SLIDER_OPTIONS_RENT,
+    priceSliderOptionsRent: HOUSE_PRICE_SLIDER_OPTIONS_RENT,
     sizeSliderOptions: HOME_SIZE_SLIDER_OPTIONS,
     gardenSizeSliderOptions: GARDEN_SIZE_SLIDER_OPTIONS
   }

app/controllers/realEstateFilters.js

@@ -35,8 +35,7 @@ const getFilters = async (req, res) => {
     balcony,
     elevator,
     newBuilding,
-    accessRoadType,
+    accessRoadType
-    includeWithoutPrice
   } = searchRequest;
   const category = AD_CATEGORY[realEstateType] || AD_CATEGORY.FLAT;
 
@@ -116,8 +115,7 @@ const getFilters = async (req, res) => {
     advancedSegmentSelectFilterValues,
     advancedRangeFilterObjects,
     advancedRangeFilterValues,
-    includeIncompleteAds,
+    includeIncompleteAds
-    includeWithoutPrice
   });
 };
 
@@ -193,7 +191,6 @@ const postFilters = async (req, res) => {
   });
 
   const includeIncompleteAds = req.body.includeIncompleteAds === "on";
-  const includeWithoutPrice = req.body.includeWithoutPrice === "on";
 
   const balcony = req.body.balcony === "on";
   const elevator = req.body.elevator === "on";
@@ -220,7 +217,6 @@ const postFilters = async (req, res) => {
   searchRequest.newBuilding = newBuilding;
 
   searchRequest.includeIncompleteAds = includeIncompleteAds;
-  searchRequest.includeWithoutPrice = includeWithoutPrice;
 
   searchRequest.accessRoadType = accessRoadType;
 

app/helpers/db/realEstate.js

@@ -2,8 +2,6 @@
 const db = require("../../models/index");
 const sequelize = require("sequelize");
 const Op = sequelize.Op;
-const { AD_CATEGORY } = require("../../common/enums");
-
 const bulkUpsertRealEstates = async realEstateData => {
   try {
     const fieldsToUpdateIfDuplicate = [
@@ -98,16 +96,12 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     floorMin,
     floorMax,
     includeIncompleteAds,
-    includeWithoutPrice,
     balcony,
     elevator,
     newBuilding,
     accessRoadType
   } = searchRequest;
 
-  //Needed for defining which attribute should exist or not
-  const realEstateTypeObject = AD_CATEGORY[realEstateType];
-
   const longitudeColumn = sequelize.col("locationLong");
   const latitudeColumn = sequelize.col("locationLat");
 
@@ -140,6 +134,15 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
   const query = {
     adType,
     realEstateType,
+    price: {
+      [Op.or]: {
+        [Op.and]: {
+          [Op.lte]: priceMax,
+          [Op.gte]: priceMin
+        },
+        [Op.is]: null
+      }
+    },
     area: {
       [Op.lte]: sizeMax,
       [Op.gte]: sizeMin
@@ -151,6 +154,15 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
   const queryIncludeIncomplete = {
     adType,
     realEstateType,
+    price: {
+      [Op.or]: {
+        [Op.and]: {
+          [Op.lte]: priceMax,
+          [Op.gte]: priceMin
+        },
+        [Op.is]: null
+      }
+    },
     area: {
       [Op.or]: {
         [Op.and]: {
@@ -163,49 +175,8 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     [Op.and]: geoSearchQueryPart
   };
 
-  //Is user unchecked includeWithoutPrice FALSE then it shouldn't return null values of price
+  //Every other attribute is checked separately and included in query only if it is defined
-  //If not then null values are accepted (this is DEFAULT)
+  if (gardenSizeMax && gardenSizeMin) {
-  //includeIncpompleteAds does not have effect on price query
-  if (includeWithoutPrice) {
-    query.price = {
-      [Op.or]: {
-        [Op.and]: {
-          [Op.lte]: priceMax,
-          [Op.gte]: priceMin
-        },
-        [Op.is]: null
-      }
-    };
-    queryIncludeIncomplete.price = {
-      [Op.or]: {
-        [Op.and]: {
-          [Op.lte]: priceMax,
-          [Op.gte]: priceMin
-        },
-        [Op.is]: null
-      }
-    };
-  } else {
-    query.price = {
-      [Op.and]: {
-        [Op.lte]: priceMax,
-        [Op.gte]: priceMin
-      }
-    };
-    queryIncludeIncomplete.price = {
-      [Op.and]: {
-        [Op.lte]: priceMax,
-        [Op.gte]: priceMin
-      }
-    };
-  }
-  //Every other attribute is checked separately and included in query only if it is defined for real estate type
-
-  if (
-    realEstateTypeObject.hasGardenSize &&
-    gardenSizeMax != null &&
-    gardenSizeMin != null
-  ) {
     query.gardenSize = {
       [Op.lte]: gardenSizeMax,
       [Op.gte]: gardenSizeMin
@@ -221,11 +192,7 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (
+  if (numberOfRoomsMin && numberOfRoomsMax) {
-    realEstateTypeObject.hasNumberOfRoom &&
-    numberOfRoomsMin != null &&
-    numberOfRoomsMax != null
-  ) {
     query.numberOfRooms = {
       [Op.lte]: numberOfRoomsMax,
       [Op.gte]: numberOfRoomsMin
@@ -241,11 +208,7 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (
+  if (numberOfFloorsMin && numberOfFloorsMax) {
-    realEstateTypeObject.hasNumberOfFloors &&
-    numberOfFloorsMin != null &&
-    numberOfFloorsMax != null
-  ) {
     query.numberOfFloors = {
       [Op.lte]: numberOfFloorsMax,
       [Op.gte]: numberOfFloorsMin
@@ -261,11 +224,7 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (
+  if (floorMin && floorMax) {
-    realEstateTypeObject.hasFloorProp &&
-    floorMin != null &&
-    floorMax != null
-  ) {
     query.floor = {
       [Op.lte]: floorMax,
       [Op.gte]: floorMin
@@ -280,10 +239,8 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
       }
     };
   }
-  //Logic for balcony, newBuilding and elevator from users side
+
-  //If true is checked, then I want characteristic to be true but,
+  if (balcony) {
-  //if it is not checked, then I dont care - it can be null or false or true
-  if (realEstateTypeObject.hasBalconyProp && balcony === true) {
     query.balcony = {
       [Op.eq]: balcony
     };
@@ -295,7 +252,7 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (realEstateTypeObject.hasNewBuildingProp && newBuilding === true) {
+  if (newBuilding) {
     query.newBuilding = {
       [Op.eq]: newBuilding
     };
@@ -307,7 +264,7 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (realEstateTypeObject.hasElevatorProp && elevator === true) {
+  if (elevator) {
     query.elevator = {
       [Op.eq]: elevator
     };
@@ -318,8 +275,7 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
       }
     };
   }
-  //If user wants 'ANY' road type acces then it is not included in query -
+
-  //returns every road type and null values
   if (accessRoadType !== "ANY") {
     query.accessRoadType = {
       [Op.eq]: accessRoadType

app/helpers/db/searchRequest.js

@@ -49,390 +49,128 @@ const findSearchRequestsForRealEstate = async realEstate => {
 
   const geoSearchQueryPart = sequelize.where(contains, true);
 
-  //Needed for defining which attribute should exist or not
+  //General query contains only attributes that are defined for every RealEstate - not null
-  const realEstateTypeObject = AD_CATEGORY[realEstateType];
-
-  // ?? Needed to decide on including incomplete RealEstates data
-  let checkForIncompleteWanted = false;
-
-  //Attributes are checked separately to make different query parts
-
-  //If real estate price is number then it searches for req that have priceMin and priceMax
-  //If real estate price is null it searches for req that accept ads without price
-  //User always defines price and area (sliders) - not null in search req
-  let priceQuery = {};
-  if (price != null) {
-    priceQuery = {
-      [Op.and]: [
-        {
-          priceMin: {
-            [Op.lte]: price
-          }
-        },
-        {
-          priceMax: {
-            [Op.gte]: price
-          }
-        }
-      ]
-    };
-  } else {
-    priceQuery = {
-      includeWithoutPrice: {
-        [Op.eq]: true
-      }
-    };
-  }
-
-  let areaQuery = {};
-  if (area != null) {
-    areaQuery = {
-      [Op.and]: [
-        {
-          sizeMin: {
-            [Op.lte]: area
-          }
-        },
-        {
-          sizeMax: {
-            [Op.gte]: area
-          }
-        }
-      ]
-    };
-  } else {
-    checkForIncompleteWanted = true;
-  }
-
-  //Other attributes can be defined or not depending on RealEstate type
-  //we check what to include in query based on real estate type object
-  let gardenSizeQuery = {};
-  if (realEstateTypeObject.hasGardenSize) {
-    if (gardenSize != null) {
-      gardenSizeQuery = {
-        [Op.and]: [
-          {
-            gardenSizeMin: {
-              [Op.lte]: gardenSize
-            }
-          },
-          {
-            gardenSizeMax: {
-              [Op.gte]: gardenSize
-            }
-          }
-        ]
-      };
-    } else {
-      checkForIncompleteWanted = true;
-    }
-  }
-
-  let numberOfRoomsQuery = {};
-  if (realEstateTypeObject.hasNumberOfRoom) {
-    if (numberOfRooms != null) {
-      //If real estate has defined number of rooms ex. 3 it returns req
-      // that accepts 3 rooms or ones that don't have defined number - null
-      //Ex. they didnt choose advanced filters at all
-      numberOfRoomsQuery = {
-        [Op.and]: [
-          {
-            numberOfRoomsMin: {
-              [Op.or]: {
-                [Op.lte]: numberOfRooms,
-                [Op.is]: null
-              }
-            }
-          },
-          {
-            numberOfRoomsMax: {
-              [Op.or]: {
-                [Op.gte]: numberOfRooms,
-                [Op.is]: null
-              }
-            }
-          }
-        ]
-      };
-    } else {
-      // If real estate dont have defined number of rooms ex. null
-      //It returns requests that didn't choose number of rooms - also null
-      //Or ones that picked some values but also picked to includeIncomplete ads
-      numberOfRoomsQuery = {
-        [Op.or]: [
-          {
-            [Op.and]: [
-              {
-                numberOfRoomsMin: {
-                  [Op.is]: null
-                }
-              },
-              {
-                numberOfRoomsMax: {
-                  [Op.is]: null
-                }
-              }
-            ]
-          },
-          {
-            includeIncompleteAds: {
-              [Op.eq]: true
-            }
-          }
-        ]
-      };
-    }
-  }
-  //Same logic for number of Floors and floors
-  let numberOfFloorsQuery = {};
-  if (realEstateTypeObject.hasNumberOfFloors) {
-    if (numberOfFloors != null) {
-      numberOfFloorsQuery = {
-        [Op.and]: [
-          {
-            numberOfFloorsMin: {
-              [Op.or]: {
-                [Op.lte]: numberOfFloors,
-                [Op.is]: null
-              }
-            }
-          },
-          {
-            numberOfFloorsMax: {
-              [Op.or]: {
-                [Op.gte]: numberOfFloors,
-                [Op.is]: null
-              }
-            }
-          }
-        ]
-      };
-    } else {
-      numberOfFloorsQuery = {
-        [Op.or]: [
-          {
-            [Op.and]: [
-              {
-                numberOfFloorsMin: {
-                  [Op.is]: null
-                }
-              },
-              {
-                numberOfFloorsMax: {
-                  [Op.is]: null
-                }
-              }
-            ]
-          },
-          {
-            includeIncompleteAds: {
-              [Op.eq]: true
-            }
-          }
-        ]
-      };
-    }
-  }
-  let floorQuery = {};
-  if (realEstateTypeObject.hasFloorProp) {
-    if (floor != null) {
-      floorQuery = {
-        [Op.and]: [
-          {
-            floorMin: {
-              [Op.or]: {
-                [Op.lte]: floor,
-                [Op.is]: null
-              }
-            }
-          },
-          {
-            floorMax: {
-              [Op.or]: {
-                [Op.gte]: floor,
-                [Op.is]: null
-              }
-            }
-          }
-        ]
-      };
-    } else {
-      floorQuery = {
-        [Op.or]: [
-          {
-            [Op.and]: [
-              {
-                floorMin: {
-                  [Op.is]: null
-                }
-              },
-              {
-                floorMax: {
-                  [Op.is]: null
-                }
-              }
-            ]
-          },
-          {
-            includeIncompleteAds: {
-              [Op.eq]: true
-            }
-          }
-        ]
-      };
-    }
-  }
-
-  //Logic for balcony, newBuilding and elevator
-  //If user dont check checkbox for ex. elevator  it does not mean he only wants no elevator
-  //If real estate characteristic =true find all req, one that wants charachertistic or dont care - dont need query
-  //If real estate characteristic = false, find all req exept for ones that wants characteristic to be true
-  //If real estate characteristic = null, dont know if true or false, find req that dont care or want char and want incomplete ads
-  let balconyQuery = {};
-  if (realEstateTypeObject.hasBalconyProp && balcony !== true) {
-    if (balcony === false) {
-      balconyQuery = {
-        balcony: {
-          [Op.ne]: true
-        }
-      };
-    } else if (balcony === null) {
-      balconyQuery = {
-        [Op.or]: [
-          {
-            balcony: {
-              [Op.ne]: true
-            }
-          },
-          {
-            [Op.and]: [
-              {
-                balcony: {
-                  [Op.eq]: true
-                }
-              },
-              {
-                includeIncompleteAds: {
-                  [Op.eq]: true
-                }
-              }
-            ]
-          }
-        ]
-      };
-    }
-  }
-  let newBuildingQuery = {};
-  if (realEstateTypeObject.hasNewBuildingProp && newBuilding !== true) {
-    if (newBuilding === false) {
-      newBuildingQuery = {
-        newBuilding: {
-          [Op.ne]: true
-        }
-      };
-    } else if (newBuilding === null) {
-      newBuildingQuery = {
-        [Op.or]: [
-          {
-            newBuilding: {
-              [Op.ne]: true
-            }
-          },
-          {
-            [Op.and]: [
-              {
-                newBuilding: {
-                  [Op.eq]: true
-                }
-              },
-              {
-                includeIncompleteAds: {
-                  [Op.eq]: true
-                }
-              }
-            ]
-          }
-        ]
-      };
-    }
-  }
-  let elevatorQuery = {};
-  if (realEstateTypeObject.hasElevatorProp && elevator !== true) {
-    if (elevator === false) {
-      elevatorQuery = {
-        elevator: {
-          [Op.ne]: true
-        }
-      };
-    } else if (elevator === null) {
-      elevatorQuery = {
-        [Op.or]: [
-          {
-            elevator: {
-              [Op.ne]: true
-            }
-          },
-          {
-            [Op.and]: [
-              {
-                elevator: {
-                  [Op.eq]: true
-                }
-              },
-              {
-                includeIncompleteAds: {
-                  [Op.eq]: true
-                }
-              }
-            ]
-          }
-        ]
-      };
-    }
-  }
-  //General query consists of each individual query
   const query = {
     adType,
     realEstateType,
     subscribed: true,
-    [Op.and]: [
+    [Op.and]: geoSearchQueryPart
-      geoSearchQueryPart,
-      priceQuery,
-      areaQuery,
-      gardenSizeQuery,
-      numberOfRoomsQuery,
-      numberOfFloorsQuery,
-      floorQuery,
-      balconyQuery,
-      newBuildingQuery,
-      elevatorQuery
-    ]
   };
+  //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;
 
-  //AccessRoadType is defined - should exists for each ad and estate type
+  //Attributes are checked separately and included in query only if defined
-  if (accessRoadType != null) {
+  //Price and area should be defined for every property
+
+  if (price) {
+    query.priceMin = {
+      [Op.lte]: price
+    };
+    query.priceMax = {
+      [Op.gte]: price
+    };
+  }
+
+  if (area) {
+    query.sizeMin = {
+      [Op.lte]: area
+    };
+    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.like]: "ANY",
+        [Op.eq]: "ANY",
         [Op.eq]: accessRoadType
       }
     };
-  } else {
+  } else if (realEstateTypeObject.hasAccesRoadType) {
-    //Null values are returned for user request that wanted ANY acces road type
+    checkForIncompleteWanted = true;
-    query.accessRoadType = {
-      [Op.eq]: "ANY"
-    };
   }
-  //Tag to check if incomplete ads are accepted in query
+
+  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 });
-  return await db.SearchRequest.findAll({
-    where: query
-  });
 };
 
 module.exports = {

app/migrations/20200123085754-add-column-includeWithoutPrice-to-searchRequests-table.js

@@ -1,14 +0,0 @@
-"use strict";
-
-module.exports = {
-  up: (queryInterface, Sequelize) => {
-    return queryInterface.addColumn("SearchRequests", "includeWithoutPrice", {
-      type: Sequelize.BOOLEAN,
-      defaultValue: true
-    });
-  },
-
-  down: (queryInterface, Sequelize) => {
-    return queryInterface.removeColumn("SearchRequests", "includeWithoutPrice");
-  }
-};

app/models/searchRequest.js

@@ -15,15 +15,7 @@ module.exports = (sequelize, DataTypes) => {
       allowNull: false,
       defaultValue: {
         type: "Polygon",
-        coordinates: [
+        coordinates: [[[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]]],
-          [
-            [0, 0],
-            [0, 0],
-            [0, 0],
-            [0, 0],
-            [0, 0]
-          ]
-        ],
         crs: { type: "name", properties: { name: "EPSG:4326" } }
       }
     },
@@ -79,7 +71,6 @@ module.exports = (sequelize, DataTypes) => {
       type: DataTypes.TEXT
     },
     includeIncompleteAds: DataTypes.BOOLEAN,
-    includeWithoutPrice: DataTypes.BOOLEAN,
     balcony: DataTypes.BOOLEAN,
     elevator: DataTypes.BOOLEAN,
     newBuilding: DataTypes.BOOLEAN,

app/views/standardFilters.ejs

@@ -18,15 +18,6 @@
   </div>
 </div>
 
-<br />
-<p class="distinguished">
-  <label class="checkbox-label">
-    <input type="checkbox" class="filled-in" name="includeWithoutPrice"
-      checked
-      >
-    <span>Uključi i oglase bez cijene</span>
-  </label>
-</p>
 <br />
 
 <div class="row center-align">