306 lines
10 KiB
JavaScript
306 lines
10 KiB
JavaScript
const _ = require('lodash')
|
|
const moment = require("moment")
|
|
const scorer = require('./score')
|
|
const SETTINGS = require('../settings').scoring
|
|
|
|
module.exports = async function (data, from, to, q) {
|
|
console.log('search')
|
|
console.log(q)
|
|
if ((_.isNil(to) || _.isNil(from)) && !(_.isEmpty(q.climate) || _.isEmpty(q.costs) || _.isEmpty(q.others))) {
|
|
throw new Error('invalid query')
|
|
}
|
|
if (_.isNil(data) || _.isEmpty(data.regions)) {
|
|
throw new Error('database error')
|
|
}
|
|
let regionsArr = data.regions
|
|
// PREPARE SEARCH
|
|
// validate dates
|
|
const dates = validateDates(from, to)
|
|
// for calculating average if traveldates are in more than one month
|
|
const travelPeriods = travelPeriodsFromDates(dates)
|
|
|
|
// CALCULATE PROPERTIES FOR EACH REGION
|
|
regionsArr.forEach(reg => {
|
|
|
|
// CALCULATE SCORES FOR CLIMATE PROPS
|
|
reg.scores = []
|
|
Object.entries(q.climate).forEach(([key, value]) => {
|
|
let finalScoreObj = calculateScoreForPeriod(key, travelPeriods, reg, value[0], value[1])
|
|
reg.scores.push(finalScoreObj)
|
|
});
|
|
|
|
// CALCULATE SCORES FOR PRICE PROPS
|
|
Object.entries(q.costs).forEach(([key, value]) => {
|
|
let finalScoreObj = scoreFromSimpleRegionProperty(key, reg, value[0], value[1])
|
|
|
|
reg.scores.push(finalScoreObj)
|
|
});
|
|
|
|
// CALCULATE SCORE FOR OFFSEASON
|
|
if (_.has(q, 'others.avg_price_relative')) {
|
|
let offSeasonScoreObj = calculateScoreForPeriod('avg_price_relative', travelPeriods, reg, q.others.avg_price_relative[0], q.others.avg_price_relative[1], 'easeOut', 2)
|
|
reg.scores.push(offSeasonScoreObj)
|
|
}
|
|
|
|
// CALCULATE SCORE FOR TAGS
|
|
if (_.has(q, 'others.tags')) {
|
|
reg.scores.push(...scoresFromTags(reg.tags, q.others.tags))
|
|
}
|
|
|
|
// CALCULATE PRICE TENDENCY FOR TIMEFRAME
|
|
reg.price_tendency_relative = getAverageFromTrivago(travelPeriods, reg)
|
|
|
|
// CALCULATE SUM FOR ACCOMODATION FROM AVERAGE PRICES AND APPROX LIFESTYLE COSTS
|
|
reg.total_accommodation_costs = _.round(sumForRangeAvg(dates.from, dates.to, reg.accommodation_costs), 2)
|
|
reg.total_avg_lifestyle = _.round(sumForRangeAvg(dates.from, dates.to, reg.average_per_day_costs - reg.accommodation_costs), 2)
|
|
//reg.name = `${reg.name} ca. ${_.round(sumForRangeAvg(dates.from, dates.to, reg.accommodation_costs), 2)}€`
|
|
|
|
// CALCULATE TOTAL PRICE WITH TRANSPORTATION
|
|
|
|
// CALCULATE TOTAL PRICE WITH TRANSPORTATION AND ESTEEMED LIFE COSTS
|
|
|
|
// CALCULATE AVERAGE SCORE Stage 1
|
|
let scoreSubGroups = []
|
|
if (!_.isEmpty(q.climate)) scoreSubGroups.push(calculateAverage(reg.scores.filter(el => _.some(Object.keys(q.climate), entry => entry === el.type ) )) )
|
|
if (!_.isEmpty(q.costs)) scoreSubGroups.push(calculateAverage(reg.scores.filter(el => _.some(Object.keys(q.costs), entry => entry === el.type ))) )
|
|
if (!_.isEmpty(q.others.avg_price_relative)) scoreSubGroups.push(calculateAverage(reg.scores.filter(el => 'avg_price_relative' === el.type ) ))
|
|
if (!_.isEmpty(q.others.tags)) scoreSubGroups.push(calculateAverage(reg.scores.filter(el => _.some(q.others.tags, entry => entry === el.type ))) )
|
|
|
|
// CALCULATE AVERAGE SCORE Stage 2
|
|
// reg.score = calculateAverage(reg.scores)
|
|
reg.score = _.round(_.sum(scoreSubGroups) / scoreSubGroups.length, 3)
|
|
|
|
})
|
|
return _.orderBy(regionsArr, ({ score }) => score || 0, 'desc') //.filter(el => !_.isNaN(el.score))
|
|
}
|
|
|
|
function sumForRangeAvg(from, to, avg) {
|
|
let duration = moment(to).diff(moment(from), 'days')
|
|
return duration * avg
|
|
}
|
|
|
|
function sumForRangeFromDailyValues(from, to, dailyValues) {
|
|
// NOT NEEDED YET
|
|
// for (var m = moment(from).subtract(1, 'months'); m.isSameOrBefore(moment(to).subtract(1, 'months')); m.add(1, 'day')) {
|
|
// console.log(m);
|
|
// }
|
|
}
|
|
|
|
|
|
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
|
|
}
|
|
if (el.score === null || el.score === undefined || _.isNaN(el.score)) {
|
|
cnt++
|
|
sum += -1
|
|
}
|
|
})
|
|
//if (sum === 0 && cnt === 0) return 0
|
|
return _.round(sum / cnt, 3)
|
|
}
|
|
|
|
function travelPeriodsFromDates(dates) {
|
|
let start = moment(`${dates.from.year}-${dates.from.month}-${dates.from.day}`, 'YYYY-MM-DD')
|
|
let end = moment(`${dates.to.year}-${dates.to.month}-${dates.to.day}`, 'YYYY-MM-DD')
|
|
console.log('start:', moment(start));
|
|
console.log('end:', moment(end));
|
|
// console.log('start:', moment(start).toISOString());
|
|
// console.log('end:', moment(end).toISOString());
|
|
// console.log('start:', moment(dates.from));
|
|
// console.log('end:', moment(dates.to));
|
|
console.log();
|
|
console.log();
|
|
console.log();
|
|
|
|
|
|
let travelPeriods = []
|
|
|
|
if (start.month() === end.month() && start.year() === end.year()) {
|
|
let period = {
|
|
month: start.month()+1,
|
|
days: end.date() - start.date()
|
|
}
|
|
travelPeriods.push(period)
|
|
|
|
} else {
|
|
for (var m = moment(start); m.isSameOrBefore(moment(end).endOf("month")); m.add(1, 'months')) {
|
|
console.log(m);
|
|
|
|
travelPeriods.push(createPeriod(start, end, m.month()+1, m.year()))
|
|
}
|
|
}
|
|
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
|
|
fromAndTo.from.year = dateFrom.getFullYear()
|
|
let dateTo = new Date(to)
|
|
fromAndTo.to.day = dateTo.getDate()
|
|
fromAndTo.to.month = dateTo.getMonth() + 1
|
|
fromAndTo.to.year = dateTo.getFullYear()
|
|
} 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.year = Number(from.split("-")[0])
|
|
fromAndTo.to.year = Number(to.split("-")[0])
|
|
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)
|
|
}
|
|
console.log(moment(`${fromAndTo.from.year}-${fromAndTo.from.month}-${fromAndTo.from.day}`, 'YYYY-MM-DD'))
|
|
console.log(moment(`${fromAndTo.to.year}-${fromAndTo.to.month}-${fromAndTo.to.day}`, 'YYYY-MM-DD'))
|
|
if (moment(`${fromAndTo.from.year}-${fromAndTo.from.month}-${fromAndTo.from.day}`, 'YYYY-MM-DD').add(23, 'hours').isAfter(moment(`${fromAndTo.to.year}-${fromAndTo.to.month}-${fromAndTo.to.day}`, 'YYYY-MM-DD'))) throw new Error("ERR: 'to' must be at least one day after 'from'.")
|
|
return fromAndTo
|
|
}
|
|
|
|
function createPeriod(start, end, currentMonth, currentYear) {
|
|
let period = {}
|
|
console.log(start, end, currentMonth, currentYear);
|
|
|
|
if (currentMonth === start.month() + 1 && currentYear === start.year()) {
|
|
console.log('first month')
|
|
period = {
|
|
month: currentMonth,
|
|
days: 32 - start.date()
|
|
}
|
|
} else if (currentMonth === end.month() + 1) {
|
|
console.log('end month')
|
|
period = {
|
|
month: currentMonth,
|
|
days: end.date()
|
|
}
|
|
} else {
|
|
console.log('middle month')
|
|
period = {
|
|
month: currentMonth,
|
|
days: 30
|
|
}
|
|
}
|
|
return period
|
|
}
|
|
|
|
|
|
function calculateScoreForPeriod(type, travelPeriods, region, searchLowParam, searchMaxParam) {
|
|
// console.log('getScoreAndAverageFromClimate for', region.name, type)
|
|
|
|
const singleScores = travelPeriods. map(period => {
|
|
let res = {
|
|
type: type,
|
|
value: region[type] !== null ? region[type][period.month - 1] : null,
|
|
days: period.days
|
|
}
|
|
|
|
return res
|
|
})
|
|
|
|
let averagedScore = {
|
|
type: type,
|
|
value: 0,
|
|
days: 0
|
|
}
|
|
singleScores.forEach(el => {
|
|
if (el.value !== null && !_.isNaN(el.value)) {
|
|
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, 3)
|
|
delete averagedScore.days
|
|
|
|
let transitionRange = SETTINGS[type][0]
|
|
// special for precipitation
|
|
if (type === 'precipitation') {
|
|
transitionRange = scorer.increaseTransitionForHighValues(SETTINGS[type][0], searchLowParam)
|
|
}
|
|
|
|
let sc = scorer.calculateScoreRange(transitionRange, averagedScore.value, searchLowParam, searchMaxParam)
|
|
averagedScore.score = _.round(scorer[SETTINGS[type][1]](sc, SETTINGS[type][2]), 3)
|
|
// console.log('score', averagedScore.score)
|
|
if (searchLowParam === null) averagedScore.score = null
|
|
|
|
return averagedScore
|
|
}
|
|
|
|
function scoresFromTags(regionTags, tagStringsFromQueries) {
|
|
return tagStringsFromQueries.map(tagQuery => {
|
|
const tag = regionTags.find(tag => tagQuery === tag.name)
|
|
let retVal = {
|
|
type: tagQuery,
|
|
value: null,
|
|
score: null,
|
|
}
|
|
if (_.isNil(tag)) return retVal
|
|
retVal.value = tag.value
|
|
retVal.score = /* tag.value <= 0 ? 0 : */ _.round(scorer.calculateScoreRange(60, tag.value, 100, 100), 3)
|
|
console.log(retVal);
|
|
|
|
return retVal
|
|
})
|
|
}
|
|
|
|
function scoreFromSimpleRegionProperty(type, region, searchLowParam, searchMaxParam, minMax) {
|
|
// console.log('getScoreFromCosts for', region.name, type)
|
|
const sc = _.round(scorer.calculateScoreRange(SETTINGS[type][0], region[type], searchLowParam, searchMaxParam), 3)
|
|
|
|
let finScore = {
|
|
type: type,
|
|
value: region[type],
|
|
score: scorer[SETTINGS[type][1]](sc, SETTINGS[type][2]),
|
|
}
|
|
finScore.value = _.round(finScore.value, 1)
|
|
finScore.score = _.round(finScore.score, 3)
|
|
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 = {
|
|
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 && !_.isNaN(el.value)) {
|
|
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, 2)
|
|
|
|
return averagedScore.value
|
|
} |