вар ZLib = требуется ( 'Zlib');

вар Redis = требуется ( 'Redis');
вар = требует асинхронных ( «асинхр»);
запрос вар = требуется ( «запрос»);

вар OS = требуется ( 'ОС');

вар Algos = требуется ( 'прослойка бассейн / Библиотека / algoProperties.js');


module.exports = функция (регистратор, portalConfig, poolConfigs) {

    вар _this = это;

    вар logSystem = 'Статистика';

    вар redisClients = [];
    вар redisStats;

    this.statHistory = [];
    this.statPoolHistory = [];

    this.stats = {};
    this.statsString = '';

    setupStatsRedis ();
    gatherStatHistory ();

    вар canDoStats = TRUE;

    Object.keys (poolConfigs) .forEach (функция (монета) {

        если возвращение (canDoStats!);

        вар poolConfig = poolConfigs [монета];

        вар redisConfig = poolConfig.redis;

        для (вар я = 0; я < redisClients.length; я ++) {
            вар клиент = redisClients [I];
            если (client.client.port === redisConfig.port && client.client.host === redisConfig.host) {
                client.coins.push (монеты);
                вернуть;
            }
        }
        redisClients.push ({
            монеты: [монета],
            Клиент: redis.createClient (redisConfig.port, redisConfig.host)
        });
    });


    Функция setupStatsRedis () {
        redisStats = redis.createClient (portalConfig.redis.port, portalConfig.redis.host);
        redisStats.on ( 'ошибка', функция (ERR) {
            logger.error (logSystem, 'Historics', 'Redis для статистики была ошибка' + JSON.stringify (ERR));
        });
    }

    функционировать gatherStatHistory () {

        вар retentionTime = (((Date.now () / 1000) - portalConfig.website.stats.historicalRetention) | 0) .ToString ();

        redisStats.zrangebyscore ([ 'statHistory', retentionTime, '+ инф'], функция (ERR, ответы) {
            если (ERR) {
                logger.error (logSystem, 'Historics', 'Ошибка при попытке захватить накопленную статистику' + JSON.stringify (ERR));
                вернуть;
            }
            для (вар я = 0; я < replies.length; я ++) {
                _this.statHistory.push (JSON.parse (ответы [я]));
            }
            _this.statHistory = _this.statHistory.sort (функция (а, б) {
                вернуться a.time - b.time;
            });
            _this.statHistory.forEach (функция () {статистика
                addStatPoolHistory (статистика);
            });
        });
    }

    функционировать addStatPoolHistory (статистика) {
        данные вар = {
            Время: stats.time,
            бассейны: {}
        };
        для (вар бассейна в stats.pools) {
            data.pools [бассейн] = {
                hashrate: stats.pools [бассейн] .hashrate,
                workerCount: stats.pools [бассейн] .workerCount,
                блоки: stats.pools [бассейн] .blocks
            }
        }
        _this.statPoolHistory.push (данные);
    }


this.getCoins = функция (CBack) {
        _this.stats.coins = redisClients [0] .coins;
        CBack ();
    };

    this.getPayout = функция (адрес, CBack) {

        async.waterfall ([

            Функция (обратный вызов) {

                _this.getBalanceByAddress (адрес, функция () {

                    Обратный вызов (нуль, 'тест');
                });

            },

            Функция (MSG, обратный вызов) {

                вар totaltargetcoin = 0;

                async.each (_this.stats.balances, функция (баланс, CB) {

                    _this.getCoinTotals (balance.coin, balance.balance, функция (targetcoin) {

                        если (TypeOf (targetcoin)! = "не определено") {
                            totaltargetcoin + = targetcoin;
                        }

                        CB ();
                    });

                }, Функция (ERR) {
                    обратный вызов (нуль, totaltargetcoin);
                });
            }

        ], Функция (ERR, всего) {

            CBack (total.toFixed ());

        });
    };


    this.getBalanceByAddress = функция (адрес, CBack) {

        вар клиент = redisClients [0] .client,
            монеты = redisClients [0] .coins,
            Остатки = [];
          выплаты = [];



                    client.hgetall ( 'Выплаты:' + адрес, функция (ошибка, txns) {
                                                                         //logger.error(logSystem, 'ТЕМП', 'txnid переменная:' + txnid);

                                                                        если (ошибка) {
                                                                                Обратный вызов ( «Там не было выплат найдено»);
                                                                                вернуть;
                                                                        }
                                                                        если (txns === NULL) {
                                                                               Индекс вар = [];
                                                                               } Еще {
                                                                               выплаты = txns;

                                                                               }

                                                                        });


        async.each (монеты, функция (монета, CB) {

            client.hget (монета + ': остатки', адрес функция (ошибка, результат) {
                если (ошибка) {
                    Обратный вызов ( «Была ошибка получения противовесов»);
                    вернуть;
                }

                если (результат === NULL) {
                    Результат = 0;
                } Еще {
                    результат = результат;
                }

                balances.push ({
                    монета: монета,
                    Баланс: результат
                });

                CB ();
            });

        }, Функция (ERR) {
            _this.stats.balances = остатки;
            _this.stats.address = адрес;

 
            CBack ();
        });
    };

this.getCoinTotals = функция (монета, баланс, CBack) {
        вар клиент = redisClients [0] .client,
        coinData = poolConfigs [монета] .coin;
       logger.error (logSystem, 'ТЕМП', 'переменная является' + JSON.stringify (poolConfigs [монета] .coin));
         //logger.error(logSystem, 'ТЕМП', 'переменная является coinData.ID:' + coinData.ID);

        async.waterfall ([

  // Получить все остатки от Redis, если нет баланса не был представлен уже
            Функция (обратный вызов) {

                если (баланс) {
                    Обратный вызов (нуль, баланс);
                    вернуть;
                }

                client.hgetall (монета + ': весы', функция (ошибка, результаты) {
                    если (ошибка) {
                        Обратный вызов ( «Была ошибка получения противовесов»);
                        вернуть;
                    }

                    обратный вызов (NULL, результаты);
                });
            },

           // сделать вызов Mintpal получить targetcoin обменный курс
            Функция (balances_results, вызов) {
                Варианты вар = {
                  // URL: 'https: //api.mintpal.com/market/stats/<СТРОКА СИМВОЛ ТВОЕЙ TARGET МОНЕТЫ ЗДЕСЬ>/ BTC»,
                URL: "HTTP: //pubapi.cryptsy.com/api.php метод = singlemarketdata&marketid =»,
                JSON: правда
                }

                запрос (опции, функция (ошибка, ответ, тело) {
                  если (ошибка! && response.statusCode == 200) {
                   // переменная targetcoin_price = parseFloat (корпус [0] .last_price);
                        вар targetcoin_price = тело [ 'возвращение']. рынки [»<ВАШ POS TARGET МОНЕТКА БИЛЕТ SYMBOL ЗДЕСЬ>«] .lasttradeprice;
                    обратный вызов (NULL, targetcoin_price, balances_results);

                  } Еще {
                    Обратный вызов ( «Был ошибка получения mintpal курса targetcoin»);
                  }
                });
            },

            // сделать вызов, чтобы получить курс монеты
            Функция (targetcoin_price, balances_results, обратный вызов) {


               // logger.error (logSystem, 'ТЕМП', '# 1 ---- coinData.ID переменная:' + coinData.ID);

                если (coinData.ID === 'mintpal') {

                        вар optionsB = {
                   URL: 'https: //api.mintpal.com/market/stats/' + coinData.symbol + '/ BTC',
                JSON: правда
                }

                Запрос (optionsB, функция (ошибка, responseB, bodyB) {
            
                  если (ошибка! && responseB.statusCode == 200) {
                   вар coinB_price = parseFloat (bodyB [0] .last_price);
                        logger.error (logSystem, 'ТЕМП', 'переменная является coinB_price:' + coinB_price);

                    обратный вызов (NULL, targetcoin_price, coinB_price, balances_results);

                  } Еще {
                    Обратный вызов ( «Был ошибка получения mintpal курса»);
                  }
                });

                } Иначе, если (coinData.ID) {

                    Варианты вар = {
                        URL: "HTTP: //pubapi.cryptsy.com/api.php метод = singlemarketdata&marketid =»+ coinData.ID,
                        JSON: правда
                    }

                    запрос (опции, функция (ошибка, ответ, тело) {
                      если (ошибка! && response.statusCode == 200) {
                        вар coin_price = тело [ 'возвращение'] рынки [coinData.symbol] .lasttradeprice.

                        / *
                        если (coin_price.toString () IndexOf (. '-') === -1) {
                            // Хорошо это не прочерк .. нет необходимости, чтобы преобразовать его в фиксированное число
                        }
                        еще {
                            вар decimal_places = coin_price.toString () дробление ( '-') [1].
                            coin_price = coin_price.toFixed (ParseInt (decimal_places));
                        }
                        * /

                        обратный вызов (NULL, targetcoin_price, coin_price, balances_results);

                      } Еще {
                        Обратный вызов ( «Был ошибка получения mintpal курса targetcoin»);
                      }
                    });
                }
                еще {
                    обратный вызов (NULL, targetcoin_price, coinData.rate, balances_results);
                }
            },

            // Вычислить сумму targetcoin, полученную от баланса работника
            Функция (targetcoin_price, coin_price, balances_results, обратный вызов) {

                если (TypeOf balances_results! == 'объект') {
                    вар total_coins = balances_results
                    вар Bitcoins = parseFloat (total_coins) * coin_price;
                    вар баланс = (Bitcoins / targetcoin_price);

                    Обратный вызов (нуль, баланс);
                    вернуть;
                }

                Остатки вар = [];

                для (вар работника в balances_results) {
                    вар total_coins = parseFloat (balances_results [рабочий]) / 1;
                    вар Bitcoins = total_coins.toFixed () * coin_price;
                    вар баланс = (Bitcoins / targetcoin_price);
                    balances.push ({работник: работник, баланс: balance.toFixed (8)});
                }

                обратный вызов (NULL, весы);
            }

        ], функция (ERR, остатки) {

            если (баланс) {
                CBack (остатки);
                вернуть;
            }

            _this.stats.balances = остатки;
         _this.stats.payout = выплаты;
        //logger.error(logSystem, 'ТЕМП', '_this.stats прямо перед переменной ЦБ:' + JSON.stringify (_this.stats));

    CBack ();
        });

    };





    this.getGlobalStats = функция (обратный вызов) {

        вар statGatherTime = Date.now () / 1000 | 0;

        вар allCoinStats = {};

        async.each (redisClients, функция (клиент, обратный вызов) {
            вар windowTime = (((Date.now () / 1000) - portalConfig.website.stats.hashrateWindow) | 0) .ToString ();
            вар redisCommands = [];


            вар redisCommandTemplates = [
                [ 'Zremrangebyscore', ': hashrate', '-inf', '(' + windowTime],
                [ 'Zrangebyscore', ': hashrate', windowTime, '+ инф'],
                [ 'Hgetall', ': статистика'],
                [ 'SCard', ': blocksPending'],
                [ 'SCard', ': blocksConfirmed'],
                [ 'SCard', ': blocksOrphaned']
            ];

            вар commandsPerCoin = redisCommandTemplates.length;

            client.coins.map (функция (монета) {
                redisCommandTemplates.map (функция (т) {
                    вар clonedTemplates = t.slice (0);
                    clonedTemplates [1] = монета + clonedTemplates [1];
                    redisCommands.push (clonedTemplates);
                });
            });


            client.client.multi (redisCommands) .exec (функция (ERR, ответов) {
                если (ERR) {
                    logger.error (logSystem, 'Global', 'ошибка с получением глобальной статистикой' + JSON.stringify (ERR));
                    обратный вызов (ERR);
                }
                еще {
                    для (вар я = 0; я < replies.length; I + = commandsPerCoin) {
                        вар coinName = client.coins [я / commandsPerCoin | 0];
                        вар coinStats = {
                            имя: coinName,
                            символ: poolConfigs [coinName] .coin.symbol.toUpperCase (),
                            Алгоритм: poolConfigs [coinName] .coin.algorithm,
                            hashrates: ответы [I + 1],
                            poolStats: 0): 0,
                                invalidShares: ответы [я + 2]? (Ответов [я + 2] .invalidShares,
                            блоки: {
                                в ожидании: ответы [я + 3],
                                подтвердил: ответы [я + 4],
                                осиротел: ответы [я + 5]
                            }
                        };
                        allCoinStats [coinStats.name] = (coinStats);
                    }
                    Перезвони();
                }
            });
        }, Функция (ERR) {
            если (ERR) {
                logger.error (logSystem, 'Global', 'Ошибка при получении всех' Статистика + JSON.stringify (ERR));
                Перезвони();
                вернуть;
            }

            вар portalStats = {
                Время: statGatherTime,
                Глобальный:{
                    работников: 0,
                    hashrate: 0
                },
                Algos: {},
                бассейны: allCoinStats
            };

            Object.keys (allCoinStats) .forEach (функция (монета) {
                вар coinStats = allCoinStats [монета];
                coinStats.workers = {};
                coinStats.shares = 0;
                coinStats.hashrates.forEach (функциональные модули () {
                    вар части = ins.split ( ':');
                    вар workerShares = parseFloat (части [0]);
                    вар работник = детали [1];
                    если (workerShares > 0) {
                        coinStats.shares + = workerShares;
                        если (рабочий в coinStats.workers)
                            coinStats.workers [рабочий] .shares + = workerShares;
                        еще
                            coinStats.workers [рабочий] = {
                                акции: workerShares,
                                invalidshares: 0,
                                hashrateString: нулевой
                            };
                    }
                    еще {
                        если (рабочий в coinStats.workers)
                            coinStats.workers [рабочий] .invalidshares - = workerShares; // workerShares отрицательное число!
                        еще
                            coinStats.workers [рабочий] = {
                                акций: 0,
                                invalidshares: -workerShares,
                                hashrateString: нулевой
                            };
                    }
                });

                вар shareMultiplier = Math.pow (2, 32) / Algos [coinStats.algorithm] .multiplier;
                coinStats.hashrate = shareMultiplier * coinStats.shares / portalConfig.website.stats.hashrateWindow;

                coinStats.workerCount = Object.keys (coinStats.workers) .length;
                portalStats.global.workers + = coinStats.workerCount;

                / * Алгоритм конкретных глобальная статистика * /
                вар алго = coinStats.algorithm;
                если (! portalStats.algos.hasOwnProperty (алго)) {
                    portalStats.algos [алго] = {
                        работников: 0,
                        hashrate: 0,
                        hashrateString: нулевой
                    };
                }
                portalStats.algos [алго] .hashrate + = coinStats.hashrate;
                portalStats.algos [алго] .workers + = Object.keys (coinStats.workers) .length;

                для (вар работника в coinStats.workers) {
                    coinStats.workers [рабочий] .hashrateString = _this.getReadableHashRateString (shareMultiplier * coinStats.workers [рабочий] .shares / portalConfig.website.stats.hashrateWindow);
                }

                удалить coinStats.hashrates;
                удалить coinStats.shares;
                coinStats.hashrateString = _this.getReadableHashRateString (coinStats.hashrate);
            });

            Object.keys (portalStats.algos) .forEach (функция (алго) {
                вар algoStats = portalStats.algos [алго];
                algoStats.hashrateString = _this.getReadableHashRateString (algoStats.hashrate);
            });

            _this.stats = portalStats;
            _this.statsString = JSON.stringify (portalStats);



            _this.statHistory.push (portalStats);
            addStatPoolHistory (portalStats);

            вар retentionTime = (((Date.now () / 1000) - portalConfig.website.stats.historicalRetention) | 0);

            для (вар я = 0; я < _this.statHistory.length; я ++) {
                если (retentionTime < _this.statHistory [я] .time) {
                    Если я > 0) {
                        _this.statHistory = _this.statHistory.slice (я);
                        _this.statPoolHistory = _this.statPoolHistory.slice (я);
                    }
                    ломать;
                }
            }

            redisStats.multi ([
                [ 'Zadd', 'statHistory', statGatherTime, _this.statsString],
                [ 'Zremrangebyscore', 'statHistory', '-inf', '(' + retentionTime]
            ]). Exec (функция (ERR, ответы) {
                если (ERR)
                    logger.error (logSystem, 'Historics', 'Ошибка при добавлении к статистике historics' + JSON.stringify (ERR));
            });
            Перезвони();
        });

    };

    this.getReadableHashRateString = функция (hashrate) {
        вар я = -1;
        вар byteUnits = [ 'КН', 'МН', 'ГР', 'TH', 'PH'];
        делать {
            hashrate = hashrate / 1024;
                        я ++;
        } В то время как (hashrate > 1024);
        вернуть hashrate.toFixed (2) + byteUnits [I];
    };

};
[/код

Удалить фондовый website.js файл, а также, сделать новый:
[код]

вар фс = требуется ( «фс»);
вар путь = требуется ( «путь»);

вар = требует асинхронных ( «асинхр»);
вар часы = требуют ( «узла-часы»);
вар Redis = требуется ( 'Redis');

вар точка = требуется ( «точки»);
вар экспресс = требуется ( «экспресс»);
вар bodyParser = требуется ( 'тело-анализатор');
вар = компресс требуется ( «сжатия»);

вар Stratum = требуется ( 'роговой-пул');
вар Util = требуется ( 'прослойка-бассейн / Библиотека / util.js');

вар апи = требуется (»./ api.js');


module.exports = функция (регистратор) {

    dot.templateSettings.strip = ложь;

    вар portalConfig = JSON.parse (process.env.portalConfig);
    вар poolConfigs = JSON.parse (process.env.pools);

    вар websiteConfig = portalConfig.website;

    вар portalApi = новый API (регистратор, portalConfig, poolConfigs);
    вар portalStats = portalApi.stats;

    вар logSystem = 'Сайт';


вар = {файлы подкачки
        'Index.html': 'индекс',
        'Home.html': '',
        'Tbs.html': 'TBS',
        'Workers.html': 'рабочих,
        'Api.html': 'апи',
        'Admin.html': 'админ',
        'Mining_key.html': 'mining_key',
        'Miner.html': 'шахтер',
        'Miner_stats.html': 'miner_stats',
        'User_shares.html': 'user_shares',
        'Getting_started.html': 'Getting_Started'
    };

    вар pageTemplates = {};

    вар pageProcessed = {};
    вар indexesProcessed = {};

    вар keyScriptTemplate = '';
    вар keyScriptProcessed = '';


    вар processTemplates = функция () {

        для (вар Pagename в pageTemplates) {
            если (Pagename === 'индекс') продолжать;
            pageProcessed [Pagename] = pageTemplates [Pagename] ({
                poolsConfigs: poolConfigs,
                Статистика: portalStats.stats,
                portalConfig: portalConfig
            });
            indexesProcessed [Pagename] = pageTemplates.index ({
                страница: pageProcessed [Pagename],
                отмеченный: Pagename,
                Статистика: portalStats.stats,
                poolConfigs: poolConfigs,
                portalConfig: portalConfig
            });
        }

        //logger.debug(logSystem, «Статистика», «Сайт обновлен до последней статистики»);
    };



    вар readPageFiles = функция (файлы) {
        async.each (файлы, функция (Filename, обратный вызов) {
            вар Filepath = 'сайт /' + (имя_файл === 'index.html' '' '? страницы /') + имя_файл;
            fs.readFile (Filepath, 'utf8', функция (ERR, данные) {
                вар pTemp = dot.template (данные);
                pageTemplates [файлы подкачки [имя_файла]] = pTemp
                Перезвони();
            });
        }, Функция (ERR) {
            если (ERR) {
                console.log ( 'ошибка чтения файлов для создания шаблонов точечными:' + JSON.stringify (ERR));
                вернуть;
            }
            processTemplates ();
        });
    };


    // Если HTML файл был изменен перезагрузить его
    смотреть ( 'сайт', функция (имя файла) {
        вар = path.basename базовое имя (имя файла);
        если (в базовых файлах подкачка) {
            console.log (имя файла);
            readPageFiles ([базовый]);
            logger.debug (logSystem, 'Сервер', 'Reloaded файл' + базовое имя);
        }
    });

    portalStats.getGlobalStats (функция () {
        readPageFiles (Object.keys (файлы подкачки));
    });

    вар buildUpdatedWebsite = функция () {
        portalStats.getGlobalStats (функция () {
            processTemplates ();

            вар statData = 'данные:' + JSON.stringify (portalStats.stats) + '\ N \ N';
            для (вар UID в portalApi.liveStatConnections) {
                вар разреш = portalApi.liveStatConnections [UID];
                res.write (statData);
            }

        });
    };

    setInterval (buildUpdatedWebsite, websiteConfig.stats.updateInterval * 1000);


    вар buildKeyScriptPage = функция () {
        async.waterfall ([
            Функция (обратный вызов) {
                вар клиент = redis.createClient (portalConfig.redis.port, portalConfig.redis.host);
                client.hgetall ( 'coinVersionBytes', функция (ERR, coinBytes) {
                    если (ERR) {
                        client.quit ();
                        вернуть обратный вызов ( 'Ошибка захвата версии монеты байт из Redis' + JSON.stringify (ERR));
                    }
                    обратный вызов (нуль, клиент, coinBytes || {});
                });
            },
            Функция (клиент, coinBytes, обратный вызов) {
                вар enabledCoins = Object.keys (poolConfigs) .map (функция (с) {вернуть c.toLowerCase ()});
                вар missingCoins = [];
                enabledCoins.forEach (функция (с) {
                    если (! (с в coinBytes))
                        missingCoins.push (с);
                });
                Обратный вызов (нуль, клиент, coinBytes, missingCoins);
            },
            Функция (клиент, coinBytes, missingCoins, обратный вызов) {
                вар coinsForRedis = {};
                async.each (missingCoins, функция (с, CBack) {
                    вар coinInfo = (функция () {
                        для (вар PNAME в poolConfigs) {
                            если (pName.toLowerCase () === с)
                                вернуть {
                                    демон: poolConfigs [PNAME] .paymentProcessing.daemon,
                                    Адрес: poolConfigs [PNAME] .Address
                                }
                        }
                    }) ();
                    вар демон = новый Stratum.daemon.interface ([coinInfo.daemon], функция (тяжесть, сообщение) {
                        Регистратор [тяжесть] (logSystem, с, сообщение);
                    });
                    daemon.cmd ( 'dumpprivkey', [coinInfo.address], функция (результат) {
                        если (результат [0] .error) {
                            logger.error (logSystem, с, 'Может не dumpprivkey для' + C + '' + JSON.stringify (результат [0] .error));
                            CBack ();
                            вернуть;
                        }

                        вар vBytePub = util.getVersionByte (coinInfo.address) [0];
                        вар vBytePriv = util.getVersionByte (результат [0] .response) [0];

                        coinBytes [с] = vBytePub.toString () + '' + vBytePriv.toString ();
                        coinsForRedis [с] = coinBytes [с];
                        CBack ();
                    });
                }, Функция (ERR) {
                    обратный вызов (NULL, клиент, coinBytes, coinsForRedis);
                });
            },
            Функция (клиент, coinBytes, coinsForRedis, обратный вызов) {
                если (Object.keys (coinsForRedis) .length > 0) {
                    client.hmset ( 'coinVersionBytes', coinsForRedis, функция (ERR) {
                        если (ERR)
                            logger.error (logSystem, 'Init', 'Не удалось вставить монету байт версию в Redis' + JSON.stringify (ERR));
                        client.quit ();
                    });
                }
                еще {
                    client.quit ();
                }
                обратный вызов (нуль, coinBytes);
            }
        ], Функция (ERR, coinBytes) {
            если (ERR) {
                logger.error (logSystem, 'Init', ERR);
                вернуть;
            }
            пытаться{
                keyScriptTemplate = dot.template (fs.readFileSync ( 'веб-сайт / key.html', {кодирование: 'utf8'}));
                keyScriptProcessed = keyScriptTemplate ({монеты: coinBytes});
            }
            поймать (е) {
                logger.error (logSystem 'Init', 'Не удалось прочитать файл key.html');
            }
        });

    };
    buildKeyScriptPage ();

    вар GetPage = функция (PageId) {
        если (PageId в pageProcessed) {
            вар requestedPage = pageProcessed [PageId];
            вернуться requestedPage;
        }
    };




    вар minerpage = функция (REQ, разреш, следующий) {
        вар адрес = req.params.address || ноль;

        если (адрес! = NULL) {
            portalStats.getBalanceByAddress (адрес, функция () {
                processTemplates ();

                res.end (indexesProcessed [ 'miner_stats']);

            });
        }
        еще
            следующий();
    };

    вар выплаты = функция (REQ, разреш, следующий) {
        вар адрес = req.params.address || ноль;

        если (адрес! = NULL) {
            portalStats.getPayout (адрес, функция (данные) {
                res.write (data.toString ());
                Отправить();
            });
        }
        еще
            следующий();
    };


    вар акций = функция (Req, разреш рядом) {
        portalStats.getCoins (функция () {
            processTemplates ();

            res.end (indexesProcessed [ 'user_shares']);

        });
    };

    вар usershares = функция (REQ, разрешение, рядом) {

        вар монета = req.params.coin || ноль;

        если (монета! = NULL) {
            portalStats.getCoinTotals (монета, нуль, функция () {
                processTemplates ();

                res.end (indexesProcessed [ 'user_shares']);

            });
        }
        еще
            следующий();
    };


    вар маршрут = функция (Req, Рез, следующий) {
        вар PageId = req.params.page || '';
        если (PageId в indexesProcessed) {
            res.header ( 'Content-Type', 'текст / html');
            res.end (indexesProcessed [PageId]);
        }
        еще
            следующий();

    };



    вар приложение = экспресс ();


    app.use (bodyParser.json ());

    app.get ( '/ get_page', функция (REQ, разреш, следующий) {
        вар requestedPage = GetPage (req.query.id);
        если (requestedPage) {
            res.end (requestedPage);
            вернуть;
        }
        следующий();
    });

    app.get ( '/ key.html', функция (REQ, разреш, следующий) {
        res.end (keyScriptProcessed);
    });


        app.get ( '/ статистика / акции /: монета', usershares);
    app.get ( '/ статистик / акция', акция);
    app.get ( '/ забойщик /: адрес', minerpage);
    app.get ( '/ выплаты /: адрес', выплаты);



    app.get ( '/: страница', маршрут);
    app.get ( '/', маршрут);

    app.get ( '/ API /: метод', функция (REQ, разреш, следующий) {
        portalApi.handleApiRequest (REQ, разреш, следующий);
    });

    app.post ( '/ API / администратор /: метод', функция (REQ, разреш, следующий) {
        если (portalConfig.website
            && portalConfig.website.adminCenter
            && portalConfig.website.adminCenter.enabled) {
            если (portalConfig.website.adminCenter.password === req.body.password)
                portalApi.handleAdminApiRequest (REQ, разреш, следующий);
            еще
                res.send (401, JSON.stringify ({ошибка: 'Неправильный пароль'}));

        }
        еще
            следующий();

    });

    app.use (сжатие ());
    app.use ( '/ статический', express.static ( 'веб-сайт / статический'));

    app.use (функция (ERR, REQ, разреш, рядом) {
        console.error (err.stack);
        res.send (500, 'Что-то сломалось!');
    });

    пытаться {
        app.listen (portalConfig.website.port, portalConfig.website.host, функция () {
            logger.debug (logSystem, 'Сервер', 'Сайт начал' + portalConfig.website.host + ':' + portalConfig.website.port);
        });
    }
    поймать (е) {
        logger.error (logSystem, 'Сервер', 'Не удалось запустить сайт на' + portalConfig.website.host + ':' + portalConfig.website.port
            +  «- его либо в использовании, или вы не имеете прав»);
    }


};