Changed default to switched on.

.prettierignore

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

app/controllers/realEstateFilters.js

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

app/crawler/savers/postgres.js

@@ -1,7 +1,6 @@
 const moment = require("moment");
 
 const { bulkUpsertRealEstates } = require("../../helpers/db/realEstate");
-const { bulkUpsertPriceHistory } = require("../../helpers/db/priceHistory");
 
 class PostgresSaver {
   connect() {
@@ -12,21 +11,6 @@ class PostgresSaver {
 
   async save(results) {
     const savedRecords = await bulkUpsertRealEstates(results);
-    //Extruding data for price history table
-    const resultPrices = savedRecords.map(realEstate => {
-      //Null values canot be recognized by ignore duplicates in sequalize
-      //Value price = 0 indicates 'cijena na upit'
-      const priceTmp =
-        realEstate.dataValues.price === null ? 0 : realEstate.dataValues.price;
-
-      return {
-        realEstateId: realEstate.dataValues.id,
-        price: priceTmp,
-        createdAt: realEstate.dataValues.createdAt,
-        updatedAt: realEstate.dataValues.updatedAt
-      };
-    });
-    const savedPrices = await bulkUpsertPriceHistory(resultPrices);
 
     if (Array.isArray(savedRecords)) {
       const newRealEstates = [];

app/helpers/db/priceHistory.js

@@ -1,20 +0,0 @@
-"use strict";
-const db = require("../../models/index");
-const sequelize = require("sequelize");
-
-const bulkUpsertPriceHistory = async priceHistoryData => {
-  try {
-    const order = [["realEstateId", "desc"]];
-
-    return await db.PriceHistory.bulkCreate(priceHistoryData, {
-      order,
-      ignoreDuplicates: true
-    });
-  } catch (e) {
-    console.log("Error bulk upserting priceHistory : ", e);
-  }
-};
-
-module.exports = {
-  bulkUpsertPriceHistory
-};

app/helpers/db/realEstate.js

@@ -2,6 +2,8 @@
 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 = [
@@ -96,12 +98,16 @@ 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");
 
@@ -134,15 +140,6 @@ 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
@@ -154,15 +151,6 @@ 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]: {
@@ -175,8 +163,49 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     [Op.and]: geoSearchQueryPart
   };
 
-  //Every other attribute is checked separately and included in query only if it is defined
+  //Is user unchecked includeWithoutPrice FALSE then it shouldn't return null values of price
-  if (gardenSizeMax && gardenSizeMin) {
+  //If not then null values are accepted (this is DEFAULT)
+  //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
@@ -192,7 +221,11 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (numberOfRoomsMin && numberOfRoomsMax) {
+  if (
+    realEstateTypeObject.hasNumberOfRoom &&
+    numberOfRoomsMin != null &&
+    numberOfRoomsMax != null
+  ) {
     query.numberOfRooms = {
       [Op.lte]: numberOfRoomsMax,
       [Op.gte]: numberOfRoomsMin
@@ -208,7 +241,11 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (numberOfFloorsMin && numberOfFloorsMax) {
+  if (
+    realEstateTypeObject.hasNumberOfFloors &&
+    numberOfFloorsMin != null &&
+    numberOfFloorsMax != null
+  ) {
     query.numberOfFloors = {
       [Op.lte]: numberOfFloorsMax,
       [Op.gte]: numberOfFloorsMin
@@ -224,7 +261,11 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (floorMin && floorMax) {
+  if (
+    realEstateTypeObject.hasFloorProp &&
+    floorMin != null &&
+    floorMax != null
+  ) {
     query.floor = {
       [Op.lte]: floorMax,
       [Op.gte]: floorMin
@@ -239,8 +280,10 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
       }
     };
   }
-
+  //Logic for balcony, newBuilding and elevator from users side
-  if (balcony) {
+  //If true is checked, then I want characteristic to be true but,
+  //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
     };
@@ -252,7 +295,7 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (newBuilding) {
+  if (realEstateTypeObject.hasNewBuildingProp && newBuilding === true) {
     query.newBuilding = {
       [Op.eq]: newBuilding
     };
@@ -264,7 +307,7 @@ const findRealEstatesForSearchRequest = async (searchRequest, maxResults) => {
     };
   }
 
-  if (elevator) {
+  if (realEstateTypeObject.hasElevatorProp && elevator === true) {
     query.elevator = {
       [Op.eq]: elevator
     };
@@ -275,7 +318,8 @@ 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,128 +49,390 @@ 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
+
+  // ?? Needed to decide on including incomplete RealEstates data
   let checkForIncompleteWanted = false;
 
-  //Attributes are checked separately and included in query only if defined
+  //Attributes are checked separately to make different query parts
-  //Price and area should be defined for every property
 
-  if (price) {
+  //If real estate price is number then it searches for req that have priceMin and priceMax
-    query.priceMin = {
+  //If real estate price is null it searches for req that accept ads without price
-      [Op.lte]: 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
+          }
+        }
+      ]
     };
-    query.priceMax = {
+  } else {
-      [Op.gte]: price
+    priceQuery = {
+      includeWithoutPrice: {
+        [Op.eq]: true
+      }
     };
   }
 
-  if (area) {
+  let areaQuery = {};
-    query.sizeMin = {
+  if (area != null) {
-      [Op.lte]: area
+    areaQuery = {
-    };
+      [Op.and]: [
-    query.sizeMax = {
+        {
-      [Op.gte]: area
+          sizeMin: {
+            [Op.lte]: area
+          }
+        },
+        {
+          sizeMax: {
+            [Op.gte]: area
+          }
+        }
+      ]
     };
   } else {
     checkForIncompleteWanted = true;
   }
+
   //Other attributes can be defined or not depending on RealEstate type
-  if (gardenSize) {
+  //we check what to include in query based on real estate type object
-    query.gardenSizeMin = {
+  let gardenSizeQuery = {};
-      [Op.lte]: gardenSize
+  if (realEstateTypeObject.hasGardenSize) {
-    };
+    if (gardenSize != null) {
-    query.gardenSizeMax = {
+      gardenSizeQuery = {
-      [Op.gte]: gardenSize
+        [Op.and]: [
-    };
+          {
-  } else if (realEstateTypeObject.hasGardenSize) {
+            gardenSizeMin: {
-    checkForIncompleteWanted = true;
+              [Op.lte]: gardenSize
+            }
+          },
+          {
+            gardenSizeMax: {
+              [Op.gte]: gardenSize
+            }
+          }
+        ]
+      };
+    } else {
+      checkForIncompleteWanted = true;
+    }
   }
 
-  if (numberOfRooms) {
+  let numberOfRoomsQuery = {};
-    query.numberOfRoomsMin = {
+  if (realEstateTypeObject.hasNumberOfRoom) {
-      [Op.lte]: numberOfRooms
+    if (numberOfRooms != null) {
-    };
+      //If real estate has defined number of rooms ex. 3 it returns req
-    query.numberOfRoomsMax = {
+      // that accepts 3 rooms or ones that don't have defined number - null
-      [Op.gte]: numberOfRooms
+      //Ex. they didnt choose advanced filters at all
-    };
+      numberOfRoomsQuery = {
-  } else if (realEstateTypeObject.hasNumberOfRoom) {
+        [Op.and]: [
-    checkForIncompleteWanted = true;
+          {
+            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
+            }
+          }
+        ]
+      };
+    }
   }
 
-  if (numberOfFloors) {
+  //Logic for balcony, newBuilding and elevator
-    query.numberOfFloorsMin = {
+  //If user dont check checkbox for ex. elevator  it does not mean he only wants no elevator
-      [Op.lte]: numberOfFloors
+  //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
-    query.numberOfFloorsMax = {
+  //If real estate characteristic = null, dont know if true or false, find req that dont care or want char and want incomplete ads
-      [Op.gte]: numberOfFloors
+  let balconyQuery = {};
-    };
+  if (realEstateTypeObject.hasBalconyProp && balcony !== true) {
-  } else if (realEstateTypeObject.hasNumberOfFloors) {
+    if (balcony === false) {
-    checkForIncompleteWanted = true;
+      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 (floor) {
+  if (realEstateTypeObject.hasNewBuildingProp && newBuilding !== true) {
-    query.floorMin = {
+    if (newBuilding === false) {
-      [Op.lte]: floor
+      newBuildingQuery = {
-    };
+        newBuilding: {
-    query.floorMax = {
+          [Op.ne]: true
-      [Op.gte]: floor
+        }
-    };
+      };
-  } else if (realEstateTypeObject.hasFloorProp) {
+    } else if (newBuilding === null) {
-    checkForIncompleteWanted = true;
+      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]: [
+      geoSearchQueryPart,
+      priceQuery,
+      areaQuery,
+      gardenSizeQuery,
+      numberOfRoomsQuery,
+      numberOfFloorsQuery,
+      floorQuery,
+      balconyQuery,
+      newBuildingQuery,
+      elevatorQuery
+    ]
+  };
 
-  if (accessRoadType) {
+  //AccessRoadType is defined - should exists for each ad and estate type
+  if (accessRoadType != null) {
     query.accessRoadType = {
       [Op.or]: {
-        [Op.eq]: "ANY",
+        [Op.like]: "ANY",
         [Op.eq]: accessRoadType
       }
     };
-  } else if (realEstateTypeObject.hasAccesRoadType) {
+  } else {
-    checkForIncompleteWanted = true;
+    //Null values are returned for user request that wanted ANY acces road type
-  }
+    query.accessRoadType = {
-
+      [Op.eq]: "ANY"
-  if (balcony) {
-    query.balcony = {
-      [Op.eq]: balcony
     };
-  } else if (realEstateTypeObject.hasBalconyProp) {
-    checkForIncompleteWanted = true;
   }
-
+  //Tag to check if incomplete ads are accepted in query
-  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/20200121000524-add-priceHistory-table.js

@@ -1,42 +0,0 @@
-"use strict";
-
-module.exports = {
-  up: (queryInterface, Sequelize) => {
-    const tableFields = {
-      id: {
-        type: Sequelize.BIGINT,
-        autoIncrement: true,
-        allowNull: false,
-        primaryKey: true
-      },
-      realEstateId: {
-        type: Sequelize.BIGINT,
-        allowNull: false,
-        unique: "uniquePriceRealEstate",
-        references: {
-          model: "RealEstates",
-          key: "id"
-        },
-        onUpdate: "CASCADE",
-        onDelete: "SET NULL"
-      },
-      price: {
-        type: Sequelize.REAL,
-        unique: "uniquePriceRealEstate"
-      },
-      createdAt: {
-        type: Sequelize.DATE,
-        defaultValue: Sequelize.literal("NOW()")
-      },
-      updatedAt: {
-        type: Sequelize.DATE,
-        defaultValue: Sequelize.literal("NOW()")
-      }
-    };
-    return queryInterface.createTable("PriceHistory", tableFields);
-  },
-
-  down: queryInterface => {
-    return queryInterface.dropTable("PriceHistory", {});
-  }
-};

app/migrations/20200121094500-add-constraint-priceHistory.js

@@ -1,10 +0,0 @@
-"use strict";
-module.exports = {
-  up: (queryInterface, Sequelize) =>
-    queryInterface.addConstraint("PriceHistory", ["realEstateId", "price"], {
-      type: "unique",
-      name: "uniquePriceRealEstate"
-    }),
-  down: queryInterface =>
-    queryInterface.removeConstraint("PriceHistory", "uniquePriceRealEstate")
-};

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

@@ -0,0 +1,14 @@
+"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/priceHistory.js

@@ -1,44 +0,0 @@
-"use strict";
-
-module.exports = (sequalize, DataTypes) => {
-  const PriceHistory = sequalize.define(
-    "PriceHistory",
-    {
-      id: {
-        type: DataTypes.BIGINT,
-        autoIncrement: true,
-        primaryKey: true,
-        allowNull: false
-      },
-      realEstateId: {
-        type: DataTypes.BIGINT,
-        allowNull: false,
-        unique: "uniquePriceRealEstate",
-        references: {
-          model: "RealEstates",
-          key: "id"
-        },
-        onUpdate: "CASCADE",
-        onDelete: "SET NULL"
-      },
-      price: {
-        type: DataTypes.REAL,
-        unique: "uniquePriceRealEstate"
-      }
-    },
-    {
-      freezeTableName: true
-    }
-  );
-
-  PriceHistory.associate = models => {
-    PriceHistory.hasMany(models.RealEstate, {
-      foreignKey: "id",
-      sourceKey: "realEstateId",
-      targetKey: "id",
-      as: "realEstates"
-    });
-  };
-
-  return PriceHistory;
-};

app/models/searchRequest.js

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

app/seeders/20200121150443-initial-price-history.js

@@ -1,34 +0,0 @@
-"use strict";
-
-const { RealEstate } = require("../models");
-
-module.exports = {
-  async up(queryInterface, Sequelize) {
-    //Reading initial data from RealEstate table in db
-    const realEstateInitialData = await RealEstate.findAll();
-    //Extruding data for table PriceHistory
-    const priceHistoryInitialData = realEstateInitialData.map(realEstate => {
-      //Null values canot be recognized by ignore duplicates in sequalize
-      //Value price = 0 indicates 'cijena na upit'
-      const priceTmp =
-        realEstate.dataValues.price === null ? 0 : realEstate.dataValues.price;
-
-      return {
-        realEstateId: realEstate.dataValues.id,
-        price: priceTmp,
-        createdAt: realEstate.dataValues.createdAt,
-        updatedAt: realEstate.dataValues.updatedAt
-      };
-    });
-
-    return queryInterface.bulkInsert(
-      "PriceHistory",
-      priceHistoryInitialData,
-      {}
-    );
-  },
-
-  async down(queryInterface, Sequelize) {
-    return queryInterface.bulkDelete("PriceHistory", null, {});
-  }
-};

app/views/standardFilters.ejs

@@ -18,6 +18,15 @@
   </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">

package.json

@@ -8,7 +8,6 @@
     "start": "node ./index.js",
     "start-mon": "nodemon ./index.js",
     "migrate": "cd app && npx sequelize db:migrate",
-    "seed": "cd app && npx sequelize db:seed:all",
     "setup": "docker build -t marketalerts .  && docker run -e POSTGRES_USER=docker -e POSTGRES_PASSWORD=docker -e POSTGRES_DB=marketalerts --name pg_marketalerts -d -p 5432:5432 marketalerts && sleep 10 && npm run migrate",
     "docker-start": "docker start pg_marketalerts",
     "docker-stop": "docker stop pg_marketalerts",