window.TMBilling = (function () {
var consts = {
terminalWeightMultiplier: 30,

periodOneMonth: ‘mtl-1’,
periodOneYear: ‘atl-1’,
periodTwoYears: ‘atl-2’,
periodThreeYears: ‘atl-3’,

entityEndpoint: ‘endpoint’,
entityTerminal: ‘terminal’,
};
var instances = {};
var instance = null;

function TMBilling(options) {
this.minUnits = options.minUnits;
this.maxUnits = options.maxUnits;

this.deploymentLadderGroup = options.deploymentLadderGroup;
this.currency = options.currency;
this.prices = options.prices;
this.annualDiscountMultiplier = options.annualDiscountMultiplier;
}

TMBilling.prototype.getCurrency = function TMBillingGetCurrency() {
return this.currency.name;
};

TMBilling.prototype.getCurrencyPrefix = function TMBillingGetCurrencyPrefix() {
return this.currency.prefix;
};

TMBilling.prototype.getCurrencyPostfix = function TMBillingGetCurrencyPostfix() {
return this.currency.postfix;
};

TMBilling.prototype.getPeriodMultiplier = function TMBillingGetPeriodMultiplier(period) {
switch (period) {
case consts.periodThreeYears: return {original: 36, discount: 27};
case consts.periodTwoYears: return {original: 24, discount: 19};
case ‘cloud-monthly’:
case consts.periodOneMonth:
return {original: 1, discount: 1};
default: return {original: 12, discount: this.annualDiscountMultiplier || 10};
}
};

TMBilling.prototype.getCorrectCount = function TMBillingGetCorrectCount(entity, endpoints, terminals) {
var weight = this.calcWeight(endpoints, terminals);
if (weight this.maxUnits) {
return this.getDefault(entity);
}

return entity === consts.entityEndpoint ? endpoints : terminals;
};

TMBilling.prototype.getMax = function TMBillingGetMax(entity) {
if (!entity || entity === consts.entityEndpoint) {
return this.maxUnits;
}

return Math.ceil(this.maxUnits / consts.terminalWeightMultiplier);
};

TMBilling.prototype.getMin = function TMBillingGetMax(entity) {
if (!entity || entity === consts.entityEndpoint) {
return this.minUnits;
}

return Math.ceil(this.minUnits / consts.terminalWeightMultiplier);
};

TMBilling.prototype.getDefault = function TMBillingGetDefault(entity) {
return !entity || entity === consts.entityEndpoint ? this.minUnits : 0;
};

TMBilling.prototype.calcTotalPrice = function TMBillingCalcTotalPrice(solution, endpoints, terminals) {
if (typeof this.prices[solution] === ‘undefined’) {
throw new Error(‘Invalid solution “‘ + solution + ‘” requested’);
}

endpoints = endpoints || 0;
terminals = terminals || 0;

var weight = this.calcWeight(endpoints, terminals),
result = 0, key = 0, unitPrice, count;

for (key in this.prices[solution]) {
count = this.prices[solution][key].count;
unitPrice = this.prices[solution][key].price;
if (count > weight) {
result += weight * unitPrice;
weight = 0;
break;
} else {
result += count * unitPrice;
weight -= count;
}
}
if (weight) {
result += weight * unitPrice;
}

return result;
};

TMBilling.prototype.calc = function TMBillingCalc(solution, period, endpoints, terminals) {
endpoints = endpoints || 0;
terminals = terminals || 0;

var periodMultiplier = this.getPeriodMultiplier(period);
var price = this.calcTotalPrice(solution, endpoints, terminals);
var subtotal = price * periodMultiplier.original;
subtotal -= subtotal % 100;
var discounted = price * periodMultiplier.discount;
discounted -= discounted % 100;

return {
total: discounted,
subtotal: subtotal,
discount: subtotal – discounted,
};
};

TMBilling.prototype.calcWeight = function TMBillingCalcWeight(endpoints, terminals) {
endpoints = parseInt(endpoints || 0, 10);
terminals = parseInt(terminals || 0, 10);

return Math.max(this.minUnits, endpoints + terminals * consts.terminalWeightMultiplier);
};

TMBilling.prototype.validate = function TMBillingValidate(solution, endpoints, terminals) {
var epCount, tsCount, weightedEpCount;
if (isNaN(endpoints)) {
return ‘Invalid endpoints value’;
}
if (isNaN(terminals)) {
return ‘Invalid terminals value’;
}
if (typeof this.prices[solution] === ‘undefined’) {
return ‘Invalid solution selected’;
}

weightedEpCount = this.getCorrectCount(consts.entityEndpoint, endpoints, terminals);
if (weightedEpCount > endpoints) {
epCount = this.getMin(consts.entityEndpoint);
tsCount = this.getDefault(consts.entityTerminal);
return ‘Invalid count: ‘ + epCount + ‘ endpoints or ‘ + tsCount + ‘ terminal is minimum’;
}
if (weightedEpCount < endpoints) {
epCount = this.getMax(deployment, plan, 'endpoint');
tsCount = this.getMax(deployment, plan, 'terminals');
return 'Invalid count: ' + epCount + ' endpoints or ' + tsCount + ' terminals is maximum';
}

return true;
};

TMBilling.prototype.format = function (value) {
var prefix = this.getCurrencyPrefix() || '';
var postfix = this.getCurrencyPostfix() || '';
if (prefix) {
postfix = '';
} else {
postfix = ' ' + postfix;
}

return prefix + TMBillingFormat(value) + postfix;
};

function TMBillingFormat(value) {
value = parseFloat(value / 100);
if (value === 0)
return ' 0';
if (!value || isNaN(value))
return ' –';

return Math.round(value);
}

return {
PERIOD_ONE_YEAR: consts.periodOneYear,
PERIOD_ONE_MONTH: consts.periodOneMonth,

ENTITY_ENDPOINT: consts.entityEndpoint,
ENTITY_TERMINAL: consts.entityTerminal,

init: function (options, cacheKey) {
if (!options) {
throw new Error('TMBilling init called without parameters!');
}

if (!cacheKey) {
return new TMBilling(options);
}

if (!(cacheKey in instances)) {
instances[cacheKey] = new TMBilling(options);
}

return instances[cacheKey];
},
getCachedIds: function () {
return Object.keys(instances);
},
format: TMBillingFormat,
};
})();

var tmBilling = null;
var tmPrices = [“tm_starter”, “uam”, “dlp”];
var agentsSelector = document.querySelector(‘#tm-prices-agents’);
var periodSelector = document.querySelectorAll(‘.tm_price_term input[name=”switch”]’);

agentsSelector.addEventListener(‘change’, tmRenderPrices);
periodSelector.forEach(function (el) { el.addEventListener(‘change’, tmRenderPrices); });

function hideAllPricing() {
document.querySelectorAll(‘.cta_btn’).forEach(function(el) {
el.style.display = ‘none’;
});
document.querySelectorAll(‘.cta_trial_btn’).forEach(function(el) {
el.style.display = ‘none’;
});
document.querySelectorAll(‘.cta_btn.cta_bottom_btn’).forEach(function(el) {
el.style.display = ‘block’;
});
document.querySelectorAll(‘.tm-prices-options-line’).forEach(function(el) {
el.style.visibility = ‘hidden’;
});
document.querySelectorAll(‘.tm-prices-price-wrapper’).forEach(function(el) {
el.style.display = ‘none’;
});
document.querySelectorAll(‘.elementor-price-table__price’).forEach(function(el) {
el.style.display = ‘none’;
});
}

function togglePriceDetails(enable) {
if (enable) {
document.querySelectorAll(‘.cta_btn’).forEach(function(el) {
el.style.display = ‘block’;
});
document.querySelectorAll(‘.cta_btn.cta_bottom_btn’).forEach(function(el) {
el.style.display = ‘none’;
});
document.querySelectorAll(‘.tm-prices-price-wrapper’).forEach(function(el) {
el.style.display = ‘none’;
});
document.querySelectorAll(‘.elementor-price-table__price’).forEach(function(el) {
el.style.display = ‘none’;
});

return;
}

document.querySelectorAll(‘.cta_btn’).forEach(function(el) {
el.style.display = ‘none’;
});
document.querySelectorAll(‘.tm-prices-price-wrapper’).forEach(function(el) {
el.style.display = ‘block’;
});
document.querySelectorAll(‘.elementor-price-table__price’).forEach(function(el) {
el.style.display = ‘flex’;
});
}

function tmRenderPrices() {
if (!tmBilling) {
return;
}
if (!tmBilling.prices) {
hideAllPricing();
return;
}

var realAgents = parseInt(agentsSelector.value, 10);
if (realAgents >= 200) {
togglePriceDetails(true);
return;
}

var agents = tmBilling.getCorrectCount(TMBilling.ENTITY_ENDPOINT, realAgents);
var selectedValue = document.querySelector(‘.tm_price_term input[name=”switch”]:checked’).id;
var period = selectedValue === “yearly”
? TMBilling.PERIOD_ONE_YEAR
: TMBilling.PERIOD_ONE_MONTH;

togglePriceDetails(false);
tmPrices.forEach(function(solution) {
var calculated = tmBilling.calc(solution, period, agents).total;
if (period === TMBilling.PERIOD_ONE_YEAR) {
calculated /= 12;
}

var priceEl = document.querySelector(
‘[data-tm-price-solution=”‘ + solution + ‘”] .elementor-price-table__integer-part’
);
priceEl.textContent = tmBilling.format(calculated / realAgents);

var totalPriceEl = document.querySelector(
‘[data-tm-price-solution=”‘ + solution + ‘”] .tm-prices-block-total’
);
totalPriceEl.textContent = tmBilling.format(calculated);
});

document.querySelectorAll(‘.tm-prices-block-term’).forEach(function(el) {
el.textContent = period === TMBilling.PERIOD_ONE_YEAR ? ‘annually’ : ‘monthly’;
});
}

var tmSearchParams = new URLSearchParams(window.location.search);
fetch(‘/api.php?method=getPrices’ +
(tmSearchParams.get(‘secret’) ? ‘&secret=’ + tmSearchParams.get(‘secret’) : ”) +
(tmSearchParams.get(‘currency’) ? ‘&currency=’ + tmSearchParams.get(‘currency’) : ”) +
(tmSearchParams.get(‘country’) ? ‘&country=’ + tmSearchParams.get(‘country’) : ”)
)
.then(function(response) { return response.json(); })
.then(function(data) {
tmBilling = TMBilling.init(data);
tmRenderPrices();
});