travopti/backend/util/scoreAndSearch.js

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: 5,
    rain_days: 2,
    sun_hours: 1.8,

    accommodation_costs: 17,
    food_costs: 4,
    alcohol_costs: 4,
    water_costs: 4,
    local_transportation_costs: 3,
    entertainment_costs: 3,
    average_per_day_costs: 40,

    avg_price_relative: 3
}

module.exports = function (dbConn) {
    return async function (regions, 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 boundaryStatic = {
            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,
                avg_price_relative: 100

            },
            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,
                avg_price_relative: 0
            }
        }

        // little tweak to show score object without request DEPRECATED
        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 = calculateScoreForPeriod(key, travelPeriods, reg, value[0], value[1], boundaryClimate, 'easeInOut', 2)
                reg.scores.push(finalScoreObj)
            });

            // CALCULATE SCORES FOR PRICE PROPS
            Object.entries(q.costs).forEach(([key, value]) => {
                let finalScoreObj = calculateSimpleScore(key, reg, value[0], value[1], boundaryStatic, 'easeInOut', 2)

                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], boundaryStatic, 'easeOut', 2)
                reg.scores.push(offSeasonScoreObj)
            }

            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, 3)
    }

    function travelPeriodsFromDates(dates) {
        let travelPeriods = []

        if (dates.from.month === dates.to.month && dates.from.year === dates.to.year) {
            let period = {
                month: dates.from.month,
                days: dates.to.day - dates.from.day
            }
            travelPeriods.push(period)
        
        } else {
            for (var m = moment(dates.from).subtract(1, 'months'); m.isSameOrBefore(moment(dates.to).subtract(1, 'months').endOf("month")); m.add(1, 'months')) {
                travelPeriods.push(createPeriod(dates.from, dates.to, m.month() + 1, m.year()))
            }
        }
        return travelPeriods
    }

    function createPeriod(from, to, currentMonth, currentYear) {
            let period = {}
            if (currentMonth === from.month && currentYear === from.year) {
                period = {
                    month: currentMonth,
                    days: 32 - from.day
                }
            } else if (currentMonth === to.month) {
                period = {
                    month: currentMonth,
                    days: to.day
                }
            } else {
                period = {
                    month: currentMonth,
                    days: 30
                }
            }
            return period
    }

    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 = dateFrom.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)
        }

        if (moment(fromAndTo.from).add(23, 'hours').isAfter(moment(fromAndTo.to))) throw new Error("ERR: 'to' must be at least one day after 'from'.")
        return fromAndTo
    }

    function calculateScoreForPeriod(type, travelPeriods, region, searchLowParam, searchMaxParam, minMax, funcType, funcSlope) {
        console.log('getScoreAndAverageFromClimate for', region.name, type)

        const singleScores = travelPeriods.map(period => {
            let res = {
                type: type,
                value: region[type][period.month - 1],
                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 sc = score.calculateScoreRange(minMax.min[type], minMax.max[type], MULTIPLIER[type], averagedScore.value, searchLowParam, searchMaxParam)
        averagedScore.score = _.round(score[funcType](sc, funcSlope), 3)
        console.log('score', averagedScore.score)
        if (searchLowParam === null) averagedScore.score = null

        return averagedScore
    }

    function calculateSimpleScore(type, region, searchLowParam, searchMaxParam, minMax, funcType, funcSlope) {
        console.log('getScoreFromCosts for', region.name, type)
        const sc = _.round(score.calculateScoreRange(minMax.min[type], minMax.max[type], MULTIPLIER[type], region[type], searchLowParam, searchMaxParam), 3)

        let finScore = {
            type: type,
            value: region[type],
            score: score[funcType](sc, funcSlope),
        }
        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) {
                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
    }

    //end
}