256 lines
9.0 KiB
JavaScript
256 lines
9.0 KiB
JavaScript
const _ = require('lodash')
|
|
const moment = require("moment")
|
|
const getClimateMinMax = require("./getClimateMinMax.js")
|
|
const score = require('./score')
|
|
const getRegions = require('../models/getRegions.js')
|
|
|
|
const SHOW_ALL_SCOREOBJECTS = false
|
|
const MULTIPLIER = {
|
|
temperature_mean_max: 5,
|
|
precipitation: 3.5,
|
|
rain_days: 3,
|
|
sun_hours: 2.5,
|
|
|
|
accommodation_costs: 5,
|
|
food_costs: 5,
|
|
alcohol_costs: 5,
|
|
water_costs: 5,
|
|
local_transportation_costs: 5,
|
|
entertainment_costs: 5,
|
|
average_per_day_costs: 5
|
|
}
|
|
|
|
module.exports = function (dbConn) {
|
|
return async function (from, to, q) {
|
|
console.log('search')
|
|
if ((_.isNil(to) || _.isNil(from)) && !(_.isEmpty(q.climate) || _.isEmpty(q.costs))) {
|
|
throw new Error('invalid query')
|
|
}
|
|
// PREPARE SEARCH
|
|
// validate dates
|
|
const dates = validateDates(from, to)
|
|
// for calculating average if traveldates are in more than one month
|
|
const travelPeriods = travelPeriodsFromDates(dates)
|
|
|
|
|
|
// FETCH DATA FROM DB
|
|
const boundaryClimate = await getClimateMinMax.getClimateMinMax(dbConn)
|
|
let regions = await getRegions(dbConn)
|
|
regions.forEach(reg => reg.scores = [])
|
|
const boundaryCosts = {
|
|
max: {
|
|
accommodation_costs: 500,
|
|
food_costs: 100,
|
|
alcohol_costs: 100,
|
|
water_costs: 100,
|
|
local_transportation_costs: 100,
|
|
entertainment_costs: 100,
|
|
average_per_day_costs: 1000
|
|
|
|
},
|
|
min: {
|
|
accommodation_costs: 0,
|
|
food_costs: 0,
|
|
alcohol_costs: 0,
|
|
water_costs: 0,
|
|
local_transportation_costs: 0,
|
|
entertainment_costs: 0,
|
|
average_per_day_costs: 0
|
|
}
|
|
}
|
|
|
|
// little tweak to show score object without request
|
|
if (SHOW_ALL_SCOREOBJECTS) {
|
|
if (!q.climate.temperature_mean_max) q.climate.temperature_mean_max = [null, null]
|
|
if (!q.climate.precipitation) q.climate.precipitation = [null, null]
|
|
if (!q.climate.rain_days) q.climate.rain_days = [null, null]
|
|
if (!q.climate.sun_hours) q.climate.sun_hours = [null, null]
|
|
if (!q.climate.accommodation_costs) q.climate.accommodation_costs = [null, null]
|
|
}
|
|
// CALCULATE SCORES FOR CLIMATE PROPS
|
|
regions.forEach(reg => {
|
|
Object.entries(q.climate).forEach(([key, value]) => {
|
|
let finalScoreObj = getScoreAndAverageFromClimate(key, travelPeriods, reg, value[0], value[1], boundaryClimate)
|
|
reg.scores.push(finalScoreObj)
|
|
});
|
|
|
|
// CALCULATE SCORES FOR PRICE PROPS
|
|
Object.entries(q.costs).forEach(([key, value]) => {
|
|
let finalScoreObj = getScoreFromCosts(key, reg, value[0], value[1], boundaryCosts)
|
|
|
|
reg.scores.push(finalScoreObj)
|
|
});
|
|
|
|
reg.price_tendency_relative = getAverageFromTrivago(travelPeriods, reg)
|
|
|
|
// CALCULATE AVERAGE SCORE
|
|
reg.score = calculateAverage(reg.scores)
|
|
})
|
|
return _.orderBy(regions, ({ score }) => score || 0, 'desc') //.filter(el => !_.isNaN(el.score))
|
|
}
|
|
|
|
function calculateAverage(scores) {
|
|
let sum = 0
|
|
let cnt = 0
|
|
scores.forEach(el => {
|
|
if (el.score !== null && el.score !== undefined && !_.isNaN(el.score)) {
|
|
cnt++
|
|
sum += el.score
|
|
}
|
|
})
|
|
return _.round(sum / cnt, 2)
|
|
}
|
|
|
|
function travelPeriodsFromDates(dates) {
|
|
//console.log(dates);
|
|
|
|
let travelPeriods = []
|
|
if (dates.from.month === dates.to.month) {
|
|
let period = {
|
|
month: dates.from.month,
|
|
days: dates.to.day - dates.from.day
|
|
}
|
|
travelPeriods.push(period)
|
|
} else {
|
|
for (let i = dates.from.month; i <= dates.to.month; i++) {
|
|
let period = {}
|
|
if (i === dates.from.month) {
|
|
period = {
|
|
month: i,
|
|
days: 32 - dates.from.day
|
|
}
|
|
} else if (i === dates.to.month) {
|
|
period = {
|
|
month: i,
|
|
days: dates.to.day
|
|
}
|
|
} else {
|
|
period = {
|
|
month: i,
|
|
days: 30
|
|
}
|
|
}
|
|
travelPeriods.push(period)
|
|
}
|
|
}
|
|
return travelPeriods
|
|
}
|
|
|
|
function validateDates(from, to) {
|
|
let fromAndTo = {
|
|
from: {},
|
|
to: {}
|
|
}
|
|
if (_.isNumber(from) && _.isNumber(to)) {
|
|
let dateFrom = new Date(from)
|
|
fromAndTo.from.day = dateFrom.getDate()
|
|
fromAndTo.from.month = dateFrom.getMonth() + 1
|
|
let dateTo = new Date(to)
|
|
fromAndTo.to.day = dateTo.getDate()
|
|
fromAndTo.to.month = dateTo.getMonth() + 1
|
|
if (moment(dateFrom).add(23, 'hours').isAfter(moment(dateTo))) throw new Error("ERR: 'to' must be at least one day after 'from'.")
|
|
} else {
|
|
// this block to still support old query syntax, validating from and to parameter
|
|
let re = /([12]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]))/i;
|
|
fromAndTo.from.month = Number(from.split("-")[1])
|
|
fromAndTo.to.month = Number(to.split("-")[1])
|
|
fromAndTo.from.day = Number(from.split("-")[2])
|
|
fromAndTo.to.day = Number(to.split("-")[2])
|
|
if (!from.match(re) || !to.match(re)) throw new Error("ERR: invalid parameter:", from, to)
|
|
if (moment(from, 'YYYY-MM-DD').add(23, 'hours').isAfter(moment(to, 'YYYY-MM-DD'))) throw new Error("ERR: 'to' must be at least one day after 'from'.")
|
|
}
|
|
|
|
return fromAndTo
|
|
}
|
|
|
|
function getScoreAndAverageFromClimate(type, travelPeriods, region, searchLowParam, searchMaxParam, minMax) {
|
|
console.log('getScoreAndAverageFromClimate for', region.name, type)
|
|
|
|
const singleScores = travelPeriods.map(period => {
|
|
const sc = _.round(score.calculateScoreRange(minMax.min[type], minMax.max[type], MULTIPLIER[type], region[type][period.month - 1], searchLowParam, searchMaxParam), 2)
|
|
let res = {
|
|
//region_id: x.region_id,
|
|
type: type,
|
|
value: region[type][period.month - 1],
|
|
score: (region[type][period.month - 1] === null || searchLowParam === null) ? null : sc,
|
|
days: period.days
|
|
}
|
|
|
|
return res
|
|
})
|
|
|
|
let averagedScore = {
|
|
type: type,
|
|
value: 0,
|
|
score: 0,
|
|
days: 0
|
|
}
|
|
singleScores.forEach(el => {
|
|
if (el.value !== null) {
|
|
averagedScore.value += (el.value * el.days)
|
|
averagedScore.score += (el.score * el.days)
|
|
averagedScore.days += (el.days)
|
|
} else {
|
|
console.log('skip averaging')
|
|
console.log(el)
|
|
|
|
}
|
|
})
|
|
averagedScore.value = _.round(averagedScore.value / averagedScore.days, 1)
|
|
averagedScore.score = _.round(averagedScore.score / averagedScore.days, 1)
|
|
if (searchLowParam === null) averagedScore.score = null
|
|
delete averagedScore.days
|
|
|
|
return averagedScore
|
|
}
|
|
|
|
function getScoreFromCosts(type, region, searchLowParam, searchMaxParam, minMax) {
|
|
console.log('getScoreFromCosts for', region.name, type)
|
|
const sc = _.round(score.calculateScoreRange(minMax.min[type], minMax.max[type], MULTIPLIER[type], region[type], searchLowParam, searchMaxParam), 2)
|
|
|
|
let finScore = {
|
|
type: type,
|
|
value: region[type],
|
|
score: sc,
|
|
}
|
|
finScore.value = _.round(finScore.value, 1)
|
|
finScore.score = _.round(finScore.score, 1)
|
|
if (searchLowParam === null) finScore.score = null
|
|
|
|
return finScore
|
|
}
|
|
|
|
function getAverageFromTrivago(travelPeriods, region) {
|
|
console.log('getAverageFromTrivago for', region.name)
|
|
|
|
const singleScores = travelPeriods.map(period => {
|
|
let res = {
|
|
//region_id: x.region_id,
|
|
value: region.avg_price_relative[period.month - 1],
|
|
days: period.days
|
|
}
|
|
|
|
return res
|
|
})
|
|
|
|
let averagedScore = {
|
|
value: 0,
|
|
days: 0
|
|
}
|
|
singleScores.forEach(el => {
|
|
if (el.value !== null) {
|
|
averagedScore.value += (el.value * el.days)
|
|
averagedScore.days += (el.days)
|
|
} else {
|
|
console.log('skip averaging')
|
|
console.log(el)
|
|
|
|
}
|
|
})
|
|
averagedScore.value = _.round(averagedScore.value / averagedScore.days, 1)
|
|
|
|
return averagedScore.value
|
|
}
|
|
|
|
//end
|
|
} |