ns2-front-module-common/dist/bundles/common.umd.js

NS2 common module

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/http'), require('rxjs/Observable'), require('@angular/core'), require('angular2-uuid'), require('ngx-cookie-service'), require('rxjs/operator/map'), require('rxmq'), require('@angular/common/http'), require('ts-md5/dist/md5'), require('rxjs')) :
	typeof define === 'function' && define.amd ? define(['exports', '@angular/http', 'rxjs/Observable', '@angular/core', 'angular2-uuid', 'ngx-cookie-service', 'rxjs/operator/map', 'rxmq', '@angular/common/http', 'ts-md5/dist/md5', 'rxjs'], factory) :
	(factory((global.ng = global.ng || {}, global.ng.common = global.ng.common || {}),global.ng.http,global.Rx,global.ng.core,global.angular2Uuid,global.ngxCookieService,null,global.Rxmq,global._angular_common_http,global.tsMd5_dist_md5,global.rxjs));
}(this, (function (exports,_angular_http,rxjs_Observable,_angular_core,angular2Uuid,ngxCookieService,rxjs_operator_map,Rxmq,_angular_common_http,tsMd5_dist_md5,rxjs) { 'use strict';

Rxmq = 'default' in Rxmq ? Rxmq['default'] : Rxmq;

var AbstractRefModel = (function () {
    function AbstractRefModel() {
    }
    return AbstractRefModel;
}());

// Сервис конфигурации
// @dynamic
var CommonConfigService = (function () {
    function CommonConfigService() {
    }
    Object.defineProperty(CommonConfigService, "gw", {
        get: function () {
            return CommonConfigService._gw;
        },
        set: function (value) {
            CommonConfigService._gw = value;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(CommonConfigService, "storage", {
        get: function () {
            return CommonConfigService._storage;
        },
        set: function (value) {
            CommonConfigService._storage = value;
        },
        enumerable: true,
        configurable: true
    });
    return CommonConfigService;
}());
CommonConfigService._gw = '';
CommonConfigService._storage = '';

// Базовый класс для URL
// @dynamic
var BasicUrls = (function () {
    function BasicUrls() {
    }
    Object.defineProperty(BasicUrls, "endPoint", {
        // Endpoint
        get: function () {
            return CommonConfigService.gw;
        },
        enumerable: true,
        configurable: true
    });
    return BasicUrls;
}());

var __extends$1 = (true && true.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
// URL's для работы с текущим пользователем
// URl's для текущего пользователя
// @dynamic
var CurrentUserUrls = (function (_super) {
    __extends$1(CurrentUserUrls, _super);
    function CurrentUserUrls() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Object.defineProperty(CurrentUserUrls, "self", {
        // Данные пользователя
        get: function () {
            return CurrentUserUrls.endPoint + "/self";
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(CurrentUserUrls, "moderation", {
        // Модерация
        get: function () {
            return CurrentUserUrls.self + "/moderate";
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(CurrentUserUrls, "logout", {
        // Выход из приложения
        get: function () {
            return CurrentUserUrls.endPoint + "/self/logout";
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(CurrentUserUrls, "geoSessionCity", {
        // Город сессии пользователя
        get: function () {
            return CurrentUserUrls.endPoint + "/self/geo";
        },
        enumerable: true,
        configurable: true
    });
    return CurrentUserUrls;
}(BasicUrls));

// Services
// Urls
// RxMq
// Имя ключа в хранилище (localStorage или sessionStorage)
var STORAGE_TOKEN_KEY = 'token';
var CurrentUserService = (function () {
    function CurrentUserService(injector, persistStorage, tempStorage, cookiesService) {
        this.injector = injector;
        this.persistStorage = persistStorage;
        this.tempStorage = tempStorage;
        this.cookiesService = cookiesService;
        this.token = '';
        this.usersEndPoint = '';
        this.temporaryDeviceUUID = '';
        this.ESBChannel = Rxmq.channel(CurrentUserService.ESB_CHANNEL_NAME);
    }
    // Получение соц сетей
    CurrentUserService.prototype.getSocials = function () {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'self/socials';
            _this.injector.get(HttpService).get(url)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (data) {
                resolve(data);
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Предзагрузка
     *
     * @returns {Promise<string[]>}
     */
    CurrentUserService.prototype.load = function () {
        var _this = this;
        return new Promise(function (resolve, reject) {
            _this.restoreToken()
                .then(function (token) {
                var tokenResolve = function () {
                    resolve(token);
                };
                _this.loadInfoRemote().then(tokenResolve)
                    .catch(function (err) {
                    (err.statusCode == 401) ? tokenResolve() : reject(err);
                });
            })
                .catch(resolve);
        });
    };
    /**
     * Установка URL до сервиса users
     *
     * @param usersEndPoint
     */
    CurrentUserService.prototype.setUsersEndPoint = function (usersEndPoint) {
        this.usersEndPoint = usersEndPoint;
    };
    /**
     * Проверка текущей сессии пользователя
     *
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.isAuth = function () {
        return !!this.getToken();
    };
    /**
     * Авторизация в системе
     *
     * @param email
     * @param password
     * @param rememberMe
     */
    CurrentUserService.prototype.login = function (email, password, rememberMe) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'users/login';
            var body = { email: email, password: password };
            _this.injector.get(HttpService).post(url, body)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (token) {
                _this.storeToken(token, rememberMe)
                    .then(function (token) {
                    _this.token = token;
                    _this.loadInfoRemote()
                        .then(function () {
                        resolve();
                    })
                        .catch(function (err) {
                        reject(err);
                    });
                })
                    .catch(function () {
                    _this.token = '';
                    reject();
                });
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Регистрация нового пользователя
     *
     * @param email
     * @param password
     * @param password_repeat
     * @param firstname
     * @param lastname
     * @param geo_guid
     * @param phone
     */
    CurrentUserService.prototype.register = function (email, password, password_repeat, firstname, lastname, geo_guid, phone) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'users/register';
            var body = { email: email, password: password, password_repeat: password_repeat, firstname: firstname, lastname: lastname, geo_guid: geo_guid, phone: phone };
            _this.injector.get(HttpService).post(url, body)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (data) {
                resolve(data);
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Проверка email адреса на первом этапе регистрации
     *
     * @param email
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.registerCheckEmail = function (email) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'users/register-check-email';
            var params = new _angular_http.URLSearchParams();
            params.set('email', email);
            _this.injector.get(HttpService).get(url, {
                search: params
            })
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (correctEmail) {
                resolve(correctEmail);
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Замена номера телефона при переходе с третьего шага на второй
     *
     * @param user_guid
     * @param phone
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.registerChangePhone = function (user_guid, phone) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'users/register-change-phone';
            var body = { user_guid: user_guid, phone: phone };
            _this.injector.get(HttpService).put(url, body)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (newPhone) {
                resolve(newPhone);
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Проверка кода подтверждения из СМС
     *
     * @param user_guid
     * @param code
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.confirm = function (user_guid, code) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'users/confirm';
            var body = { user_guid: user_guid, code: code };
            _this.injector.get(HttpService).post(url, body)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (data) {
                resolve(data);
            }, function (err) {
                reject(err);
            });
        });
    };
    // Загрузка информации о текущем пользователе
    CurrentUserService.prototype.loadInfoRemote = function () {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = CurrentUserUrls.self;
            _this.injector.get(HttpService).get(url)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (info) {
                _this.info = info;
                _this.ESBChannel.subject(CurrentUserService.ESB_USER_LOGIN).next(info);
                resolve(info);
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Запрос ссылки сброса пароля на почту
     *
     * @param email
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.reminderPassword = function (email) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'users/reminder-password';
            var body = { email: email };
            _this.injector.get(HttpService).post(url, body)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (result) {
                resolve(result);
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Проверка токена восстановления пароля. Используется при открытии страницы восстановления, токен передается
     * в параметре урла
     *
     * @param token
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.restorePasswordCheck = function (token) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'users/restore-password-check';
            var params = new _angular_http.URLSearchParams();
            params.set('token', token);
            _this.injector.get(HttpService).get(url, { search: params })
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (result) {
                resolve(result);
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Восстановление пароля
     *
     * @param token
     * @param password
     * @param password_repeat
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.restorePassword = function (token, password, password_repeat) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'users/restore-password';
            var body = { token: token, password: password, password_repeat: password_repeat };
            _this.injector.get(HttpService).put(url, body)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (result) {
                resolve(result);
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Установка города
     *
     * @param geo_guid
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.setGeo = function (geo_guid) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'self/geo';
            var body = { geo_guid: geo_guid };
            _this.injector.get(HttpService).put(url, body)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (result) {
                _this.info.session.geo_guid = result.geo_guid;
                _this.ESBChannel.subject(CurrentUserService.ESB_SESSION_CHANGE_CITY).next({
                    oldGeoGuid: _this.info.session.geo_guid,
                    newGeoGuid: result.geo_guid
                });
                resolve(result);
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Добавляет подписчика на смену текущего города
     * @param {Function} then Функция-подписчик
     * @returns {Subscription}
     */
    CurrentUserService.prototype.onGeoChange = function (then) {
        return this.ESBChannel.observe(CurrentUserService.ESB_SESSION_CHANGE_CITY).subscribe(then);
    };
    /**
     * Добавляет подписчика на авторизацию пользователя
     * @param {Function} then Функция-подписчик
     * @returns {Subscription}
     */
    CurrentUserService.prototype.onLogin = function (then) {
        return this.ESBChannel.observe(CurrentUserService.ESB_USER_LOGIN).subscribe(then);
    };
    /**
     * Добавляет подписчика на выход пользователя из системы
     * @param {Function} then Функция-подписчик
     * @returns {Subscription}
     */
    CurrentUserService.prototype.onLogout = function (then) {
        return this.ESBChannel.observe(CurrentUserService.ESB_USER_LOGOUT).subscribe(then);
    };
    /**
     * Выход из аккаунта
     *
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.logout = function () {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'self/logout';
            var handler = function () {
                _this.ESBChannel.subject(CurrentUserService.ESB_USER_LOGOUT).next();
                _this.localLogout().then(resolve).catch(reject);
            };
            _this.injector.get(HttpService).delete(url).subscribe(handler, handler);
        });
    };
    CurrentUserService.prototype.localLogout = function () {
        this.token = '';
        this.cookiesService.delete(CurrentUserService.USER_TOKEN_NAME);
        return Promise.race([
            this.persistStorage.remove(STORAGE_TOKEN_KEY),
            this.persistStorage.removeByTag(STORAGE_TOKEN_KEY),
            this.tempStorage.remove(STORAGE_TOKEN_KEY),
            this.tempStorage.removeByTag(STORAGE_TOKEN_KEY)
        ]);
    };
    /**
     * Обновить профиль текущего пользователя
     * @param newUserData Новые данные пользователя
     */
    CurrentUserService.prototype.saveProfile = function (newUserData) {
        var _this = this;
        return new rxjs_Observable.Observable(function (observer) {
            _this.injector.get(HttpService)
                .post(CurrentUserUrls.self, newUserData)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (response) {
                _this.info = response;
                observer.next(response);
                observer.complete();
            }, function (error) {
                observer.error(error);
                observer.complete();
            });
        });
    };
    /**
     * Отправить данные пользователя на модерацию
     * @param userData Данные пользователя
     */
    CurrentUserService.prototype.sendOnModeration = function (userData) {
        var _this = this;
        return new rxjs_Observable.Observable(function (observer) {
            _this.injector.get(HttpService)
                .post(CurrentUserUrls.moderation, userData)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function (response) {
                _this.info = response;
                observer.next(response);
                observer.complete();
            }, function (error) {
                observer.error(error);
                observer.complete();
            });
        });
    };
    /**
     * Сохранить токен в локал сторадж
     *
     * @param token
     * @param rememberMe
     */
    CurrentUserService.prototype.storeToken = function (token, rememberMe) {
        if (rememberMe) {
            return this.persistStorage.set(STORAGE_TOKEN_KEY, token);
        }
        else {
            return this.tempStorage.set(STORAGE_TOKEN_KEY, token);
        }
    };
    /**
     * Восстанавливает значение токена из хранилища
     */
    CurrentUserService.prototype.restoreToken = function () {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var cookieToken = _this.cookiesService.get(CurrentUserService.USER_TOKEN_NAME);
            if (cookieToken) {
                _this.token = cookieToken;
                _this.storeToken(_this.token, true)
                    .then(function () {
                    resolve(cookieToken);
                    _this.cookiesService.delete(CurrentUserService.USER_TOKEN_NAME);
                });
            }
            else {
                _this.persistStorage.get(STORAGE_TOKEN_KEY)
                    .then(function (token) {
                    _this.token = token;
                    resolve(token);
                })
                    .catch(function () {
                    _this.tempStorage.get(STORAGE_TOKEN_KEY)
                        .then(function (token) {
                        _this.token = token;
                        resolve(token);
                    })
                        .catch(function () {
                        reject();
                    });
                });
            }
        });
    };
    // Установить причину отказа модерации
    CurrentUserService.prototype.setRejectionReason = function (reason) {
        this.info.reject_reason = reason;
    };
    /**
     * Получить токен текущего пользователя
     *
     * @returns {string}
     */
    CurrentUserService.prototype.getToken = function () {
        return this.token;
    };
    /**
     * Установить токен пользователю
     *
     * @param token
     */
    CurrentUserService.prototype.setToken = function (token) {
        this.token = token;
    };
    /**
     * Получить информацию о текущем пользователе
     *
     * @returns {CurrentUserInfoInterface}
     */
    CurrentUserService.prototype.getInfo = function () {
        return this.info;
    };
    /**
     * Метод отправки приглашения пользователю
     * @param {string} email E-mail пользователя которого необходимо пригласить
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.invite = function (email) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'self/invite';
            _this.injector.get(HttpService).post(url, { email: email })
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(function () {
                resolve();
            }, function (err) {
                reject(err);
            });
        });
    };
    /**
     * Получить всех партнеров текущего пользователя
     *
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.getPartners = function () {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'self/partners';
            _this.injector.get(HttpService).get(url)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(resolve, reject);
        });
    };
    /**
     * Добавить избранных партнеров текущему пользователю
     *
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.addPartners = function (partnersGuid) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'self/partners';
            _this.injector.get(HttpService).put(url, partnersGuid)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(resolve, reject);
        });
    };
    /**
     * Установить избранных партнеров текущему пользователю
     *
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.setPartners = function (partnersGuid) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'self/partners';
            _this.injector.get(HttpService).post(url, partnersGuid)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(resolve, reject);
        });
    };
    /**
     * Удалить избранного пользователя
     *
     * @returns {Promise<T>}
     */
    CurrentUserService.prototype.deletePartner = function (partnerGuid) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.usersEndPoint + 'self/partner/' + partnerGuid;
            _this.injector.get(HttpService).delete(url)
                .map(function (response) { return response.json(); })
                .map(function (response) { return response.data; })
                .subscribe(resolve, reject);
        });
    };
    /**
     * Возвращает временный уникальный идентификатор устройства
     * @returns {string}
     */
    CurrentUserService.prototype.getTemporaryDeviceUUID = function () {
        if (!this.temporaryDeviceUUID) {
            this.temporaryDeviceUUID = angular2Uuid.UUID.UUID();
        }
        return this.temporaryDeviceUUID;
    };
    Object.defineProperty(CurrentUserService.prototype, "isCandidate", {
        // Пользователь является кандидатом
        get: function () {
            return this.info.rank === 'candidate';
        },
        enumerable: true,
        configurable: true
    });
    return CurrentUserService;
}());
CurrentUserService.ESB_CHANNEL_NAME = 'current-user';
CurrentUserService.ESB_SESSION_CHANGE_CITY = 'session.change-city';
CurrentUserService.ESB_INFO_UPDATE = 'info.update';
CurrentUserService.ESB_USER_LOGIN = 'user.login';
CurrentUserService.ESB_USER_LOGOUT = 'user.logout';
CurrentUserService.USER_TOKEN_NAME = 'X-User-Token';
CurrentUserService.decorators = [
    { type: _angular_core.Injectable },
];
/** @nocollapse */
CurrentUserService.ctorParameters = function () { return [
    { type: _angular_core.Injector, },
    { type: undefined, decorators: [{ type: _angular_core.Inject, args: ['StorageInterface',] },] },
    { type: undefined, decorators: [{ type: _angular_core.Inject, args: ['StorageInterface',] },] },
    { type: ngxCookieService.CookieService, },
]; };

var HttpErrorService = (function () {
    function HttpErrorService() {
        this._handler = new _angular_core.EventEmitter();
    }
    Object.defineProperty(HttpErrorService.prototype, "handler", {
        get: function () {
            return this._handler;
        },
        enumerable: true,
        configurable: true
    });
    return HttpErrorService;
}());
HttpErrorService.decorators = [
    { type: _angular_core.Injectable },
];
/** @nocollapse */
HttpErrorService.ctorParameters = function () { return []; };

var __extends = (true && true.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
function httpFactory(injector, backend, defaultOptions) {
    return new HttpService(injector, backend, defaultOptions);
}
var HttpService = (function (_super) {
    __extends(HttpService, _super);
    function HttpService(injector, backend, defaultOptions) {
        var _this = _super.call(this, backend, defaultOptions) || this;
        _this.injector = injector;
        return _this;
    }
    /**
     * Возвращает стандартный HTTP-клиент
     * @returns {HttpClient}
     */
    HttpService.prototype.getDefaultHttpClient = function () {
        if (!this.defaultHttpClient) {
            var injector = _angular_core.ReflectiveInjector.resolveAndCreate([
                _angular_common_http.HttpClient,
                { provide: _angular_common_http.HttpHandler, useClass: _angular_common_http.HttpXhrBackend },
                { provide: _angular_common_http.XhrFactory, useClass: _angular_http.BrowserXhr }
            ]);
            this.defaultHttpClient = injector.get(_angular_common_http.HttpClient);
        }
        return this.defaultHttpClient;
    };
    /**
     * Переопределяем стандартный метод request(). Добавляем заголовок с токеном
     *
     * @param url
     * @param options
     * @returns {Observable<Response>}
     */
    HttpService.prototype.request = function (url, options) {
        var _this = this;
        var userService = this.injector.get(CurrentUserService), token = userService.getToken();
        if (typeof url === 'string') {
            var headers = new _angular_http.Headers();
            headers.append(CurrentUserService.USER_TOKEN_NAME, token);
            if (!(options instanceof _angular_http.RequestOptions)) {
                options = new _angular_http.RequestOptions();
            }
            options.headers = headers;
        }
        else if (url instanceof _angular_http.Request) {
            if (typeof url.headers === 'undefined') {
                url.headers = new _angular_http.Headers();
            }
            url.headers.append(CurrentUserService.USER_TOKEN_NAME, token);
        }
        return rxjs_Observable.Observable.fromPromise(new Promise(function (resolve, reject) {
            _super.prototype.request.call(_this, url, options)
                .subscribe(function (response) { return resolve(response); }, function (err) {
                reject(_this.handleHttpError(err));
            });
        }));
    };
    HttpService.prototype.handleHttpError = function (err) {
        var message;
        var errNo;
        try {
            var json = err.json();
            message = json.hasOwnProperty('error') ? json.error : err.statusText;
            errNo = json.hasOwnProperty('errno') ? json.errno : 0;
        }
        catch (error) {
            message = err.statusText;
            errNo = 0;
        }
        var error = {
            message: message,
            statusCode: err.status,
            errNo: errNo,
            errorResponse: err
        };
        this.injector.get(HttpErrorService).handler.emit(error);
        return error;
    };
    return HttpService;
}(_angular_http.Http));
HttpService.decorators = [
    { type: _angular_core.Injectable },
];
/** @nocollapse */
HttpService.ctorParameters = function () { return [
    { type: _angular_core.Injector, },
    { type: _angular_http.ConnectionBackend, },
    { type: _angular_http.RequestOptions, },
]; };

var AbstractRefsService = (function () {
    function AbstractRefsService(httpService, cache) {
        this.httpService = httpService;
        this.cache = cache;
    }
    AbstractRefsService.prototype.setRefsEndPoint = function (_refsEndPoint) {
        this.refsEndPoint = _refsEndPoint;
    };
    /**
     * Получить информацию об одной записе
     *
     * @param guid
     * @returns {Promise<T>}
     */
    AbstractRefsService.prototype.getOne = function (guid) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var cacheKey = _this.cache.getCacheKey(_this.refName, guid);
            _this.cache.get(cacheKey).then(resolve).catch(function () {
                var url = _this.refsEndPoint + 'data/' + _this.refName + '/' + guid;
                _this.httpService.get(url)
                    .map(function (response) { return response.json(); })
                    .map(function (response) { return response.data; })
                    .subscribe(function (data) {
                    var doResolve = function () {
                        resolve(data);
                    };
                    _this.cache.set(cacheKey, data, 0, [data.guid, _this.refName])
                        .then(doResolve)
                        .catch(doResolve);
                }, function (err) {
                    reject(err);
                });
            });
        });
    };
    AbstractRefsService.prototype.treeUp = function (guid, params) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var cacheKey = _this.cache.getCacheKey('tree', _this.refName, guid, JSON.stringify(params));
            _this.cache.get(cacheKey)
                .then(resolve)
                .catch(function () {
                var url = _this.refsEndPoint + 'tree/' + _this.refName + '/up/' + guid;
                var search = params || {};
                _this.httpService.get(url, { search: search })
                    .map(function (response) { return response.json(); })
                    .map(function (response) { return response.data; })
                    .subscribe(function (data) {
                    var doResolve = function () {
                        resolve(data);
                    };
                    _this.cache.set(cacheKey, data, 0, [data.guid, _this.refName])
                        .then(doResolve)
                        .catch(doResolve);
                }, function (err) {
                    reject(err);
                });
            });
        });
    };
    AbstractRefsService.prototype.treeDown = function (guid, params) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var cacheKey = _this.cache.getCacheKey('tree', _this.refName, guid, JSON.stringify(params));
            _this.cache.get(cacheKey)
                .then(resolve)
                .catch(function () {
                var url = _this.refsEndPoint + 'tree/' + _this.refName + '/down/' + guid;
                var search = params || {};
                _this.httpService.get(url, { search: search })
                    .map(function (response) { return response.json(); })
                    .map(function (response) { return response.data; })
                    .subscribe(function (data) {
                    var doResolve = function () {
                        resolve(data);
                    };
                    _this.cache.set(cacheKey, data, 0, [data.guid, _this.refName])
                        .then(doResolve)
                        .catch(doResolve);
                }, function (err) {
                    reject(err);
                });
            });
        });
    };
    AbstractRefsService.prototype.getList = function (params) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            var url = _this.refsEndPoint + 'data/' + _this.refName;
            var keys = Object.keys(params);
            var _filter = new _angular_http.URLSearchParams();
            for (var i = 0; i < keys.length; i++) {
                var key = keys[i];
                _filter.set(key, params[key]);
            }
            var cacheKey = _this.cache.getCacheKey(_this.refName, _filter.toString());
            _this.cache.get(cacheKey)
                .then(resolve)
                .catch(function () {
                _this.httpService
                    .get(url, {
                    search: _filter
                })
                    .map(function (response) { return response.json(); })
                    .map(function (response) { return response.data; })
                    .subscribe(function (data) {
                    var doResolve = function () {
                        resolve(data);
                    };
                    var tags = [_this.refName];
                    var items = data ? data.items || [] : [];
                    items.map(function (v) {
                        if (v && v.guid) {
                            tags.push(v.guid);
                        }
                    });
                    _this.cache.set(cacheKey, data, 0, tags)
                        .then(doResolve)
                        .catch(doResolve);
                }, function (err) {
                    reject(err);
                });
            });
        });
    };
    /**
     * Загружает весь справочник
     * @param params
     * @param sort
     * @returns {Promise<T>}
     */
    AbstractRefsService.prototype.getListAll = function (params, sort) {
        var _this = this;
        if (sort === void 0) { sort = ''; }
        return new Promise(function (resolve, reject) {
            var url = _this.refsEndPoint + 'data/' + _this.refName + '/full';
            var keys = Object.keys(params);
            var _filter = new _angular_http.URLSearchParams();
            for (var i = 0; i < keys.length; i++) {
                var key = keys[i];
                _filter.set(key, params[key]);
            }
            if (sort != '') {
                _filter.set(AbstractRefsService.SORT_FIELD, sort);
            }
            var cacheKey = _this.cache.getCacheKey(_this.refName, _filter.toString());
            _this.cache.get(cacheKey)
                .then(resolve)
                .catch(function () {
                _this.httpService
                    .get(url, {
                    search: _filter
                })
                    .map(function (response) { return response.json(); })
                    .map(function (response) { return response.data; })
                    .subscribe(function (data) {
                    var doResolve = function () {
                        resolve(data);
                    };
                    var tags = [_this.refName];
                    data.map(function (v) {
                        if (v && v.guid) {
                            tags.push(v.guid);
                        }
                    });
                    _this.cache.set(cacheKey, data, 0, tags)
                        .then(doResolve)
                        .catch(doResolve);
                }, function (err) {
                    reject(err);
                });
            });
        });
    };
    return AbstractRefsService;
}());
AbstractRefsService.MAX_ITEMS = 1000;
AbstractRefsService.PER_PAGE_FIELD = 'per-page';
AbstractRefsService.PAGE_FIELD = 'page';
AbstractRefsService.SORT_FIELD = 'sort';
AbstractRefsService.decorators = [
    { type: _angular_core.Injectable },
];
/** @nocollapse */
AbstractRefsService.ctorParameters = function () { return [
    { type: HttpService, },
    { type: undefined, decorators: [{ type: _angular_core.Inject, args: ['StorageInterface',] },] },
]; };

/**
 * Сервис для работы с WebScoket-ами
 */
var WebsocketService = (function () {
    function WebsocketService() {
        // Объект канала в который отправляются сообщения из сокета
        this.channel = Rxmq.channel(WebsocketService.CHANNEL_NAME);
        // Время между попытками восстановления соединения
        this.reconnectTimeout = 1000;
        // Признак, установлено ли соединения или нет
        this.isConnected = false;
    }
    /**
     * Устанавливает точку обмена с сервером
     * @param {string} endPoint
     */
    WebsocketService.prototype.setEndPoint = function (endPoint) {
        this.endPoint = endPoint;
    };
    /**
     * Устанавливает время между попытками восстановления соединения
     * @param {number} connectTimeout
     */
    WebsocketService.prototype.setReconnectTimeout = function (connectTimeout) {
        this.reconnectTimeout = connectTimeout;
    };
    /**
     * Отправляет данные в сокет
     * @param {any} data Данные
     */
    WebsocketService.prototype.send = function (data) {
        this.ws.send(JSON.stringify(data));
    };
    /**
     * Подписка на установление соединения
     * @param {Function} then Функция-подписчик
     * @returns {Subscription}
     */
    WebsocketService.prototype.onOpen = function (then) {
        return this.channel.observe(WebsocketService.SOCKET_OPEN_TOPIC_NAME).subscribe(then);
    };
    /**
     * Подписка на получение сообщения
     * @param {Function} then Функция-подписчик
     * @returns {Subscription}
     */
    WebsocketService.prototype.onMessage = function (then) {
        return this.channel.observe(WebsocketService.SOCKET_MESSAGE_TOPIC_NAME).subscribe(then);
    };
    /**
     * Подписка на закрытие сокета
     * @param {Function} then Функция-подписчик
     * @returns {Subscription}
     */
    WebsocketService.prototype.onClose = function (then) {
        return this.channel.observe(WebsocketService.SOCKET_CLOSE_TOPIC_NAME).subscribe(then);
    };
    /**
     * Подписка на ошибки сокета
     * @param {Function} then Функция-подписчик
     * @returns {Subscription}
     */
    WebsocketService.prototype.onError = function (then) {
        return this.channel.observe(WebsocketService.SOCKET_ERROR_TOPIC_NAME).subscribe(then);
    };
    /**
     * Установить соединение с сервером
     */
    WebsocketService.prototype.connect = function (params) {
        if (!this.isConnected) {
            this.openConnection(params);
            this.isConnected = true;
        }
    };
    /**
     * Закрыть соединение с сервером
     */
    WebsocketService.prototype.disconnect = function () {
        if (this.isConnected) {
            this.ws.close(WebsocketService.SOCKET_CLOSE_NORMAL);
            this.isConnected = false;
        }
    };
    /**
     * Открытие соединения с WebSocket и подписка на события
     */
    WebsocketService.prototype.openConnection = function (params) {
        var _this = this;
        var url = this.endPoint, paramsArray = [];
        for (var pName in params) {
            if (params.hasOwnProperty(pName)) {
                paramsArray.push(pName + '=' + params[pName]);
            }
        }
        if (paramsArray.length > 0) {
            url += '?' + paramsArray.join('&');
        }
        this.ws = new WebSocket(url);
        this.ws.onopen = function (ev) {
            _this.channel.subject(WebsocketService.SOCKET_OPEN_TOPIC_NAME).next(ev);
        };
        this.ws.onmessage = function (response) {
            var data = JSON.parse(response.data) || {};
            _this.channel.subject(WebsocketService.SOCKET_MESSAGE_TOPIC_NAME).next(data);
        };
        this.ws.onerror = function (err) {
            _this.channel.subject(WebsocketService.SOCKET_ERROR_TOPIC_NAME).next(err);
            _this.ws.close(WebsocketService.SOCKET_CLOSE_ABNORMAL);
        };
        this.ws.onclose = function (ev) {
            _this.channel.subject(WebsocketService.SOCKET_CLOSE_TOPIC_NAME).next(ev);
            if (ev.code !== WebsocketService.SOCKET_CLOSE_NORMAL) {
                setTimeout(function () {
                    _this.openConnection(params);
                }, _this.reconnectTimeout);
            }
        };
    };
    return WebsocketService;
}());
// Имя канала
WebsocketService.CHANNEL_NAME = 'ws';
// Сообщения о открытии сокета
WebsocketService.SOCKET_OPEN_TOPIC_NAME = 'socket_open';
// Сообщения о поступлении сообщения в сокет
WebsocketService.SOCKET_MESSAGE_TOPIC_NAME = 'socket_message';
// Сообщения о закрытии сокета
WebsocketService.SOCKET_CLOSE_TOPIC_NAME = 'socket_close';
// Сообщения о ошибке в сокете
WebsocketService.SOCKET_ERROR_TOPIC_NAME = 'socket_error';
// Код нормального закрытия сокета (без дальнейшей попытки переустановки соединения)
WebsocketService.SOCKET_CLOSE_NORMAL = 1000;
// Код ненормального закрытия сокета (после такого закрытия будут предприняты попытки по переустановке соединения)
WebsocketService.SOCKET_CLOSE_ABNORMAL = 3000;
WebsocketService.decorators = [
    { type: _angular_core.Injectable },
];
/** @nocollapse */
WebsocketService.ctorParameters = function () { return []; };

var HelperService = (function () {
    function HelperService(currentUser) {
        this.currentUser = currentUser;
    }
    /**
     * Plural forms
     *
     * Use:
     *
     * declOfNum(count, ['найдена', 'найдено', 'найдены']);
     *
     * @see https://gist.github.com/realmyst/1262561#gistcomment-2032406
     *
     * @param n
     * @param titles
     * @returns {string}
     */
    HelperService.prototype.declOfNum = function (n, titles) {
        var cases = [2, 0, 1, 1, 1, 2];
        return titles[(n % 100 > 4 && n % 100 < 20) ? 2 : cases[(n % 10 < 5) ? n % 10 : 5]];
    };
    /**
     * Возвращает выделенный текст
     *
     * @returns {string}
     */
    HelperService.prototype.getSelectedText = function () {
        var result = "";
        if (window.getSelection) {
            result = window.getSelection().toString();
        }
        return result;
    };
    /**
     * Форматирует телефонный номер
     * @param prefix Префикс
     * @param phone Номер телефона
     * @returns {string}
     */
    HelperService.prototype.maskPhone = function (prefix, phone) {
        return prefix + ' ' +
            phone.substr(0, 3) + ' ' +
            phone.substr(3, 3) + '-' +
            phone.substr(6, 2) + '-' +
            phone.substr(8, 2);
    };
    /**
     * Возвращает количество опубликованных объявлений риелтором в текущем городе
     * @param {RealtorModel} realtorInfo Модель риелтора
     * @returns {Number}
     */
    HelperService.prototype.getPublishedRealty = function (realtorInfo) {
        var realtyInfo = this.getRealtyInfo(realtorInfo);
        return realtyInfo.hasOwnProperty('published') ? Number(realtyInfo['published']) : 0;
    };
    /**
     * Возвращает количество опубликованных эксклюзивных объявлений риелтором в текущем городе
     * @param {RealtorModel} realtorInfo Модель риелтора
     * @returns {Number}
     */
    HelperService.prototype.getExclusiveRealty = function (realtorInfo) {
        var realtyInfo = this.getRealtyInfo(realtorInfo);
        return realtyInfo.hasOwnProperty('exclusive') ? Number(realtyInfo['exclusive']) : 0;
    };
    /**
     * Возвращает информацию о количестве объявлений риелтора в текущем городе
     * @param {RealtorModel} realtorInfo Модель риелтора
     * @returns {{}}
     */
    HelperService.prototype.getRealtyInfo = function (realtorInfo) {
        var userInfo = this.currentUser.getInfo(), sessionInfo = userInfo ? userInfo.session : null, geoGuid = sessionInfo ? sessionInfo.geo_guid : '';
        return realtorInfo.realty_count && realtorInfo.realty_count.hasOwnProperty(geoGuid) ? realtorInfo.realty_count[geoGuid] : {};
    };
    return HelperService;
}());
HelperService.decorators = [
    { type: _angular_core.Injectable },
];
/** @nocollapse */
HelperService.ctorParameters = function () { return [
    { type: CurrentUserService, },
]; };

var CommonModule = (function () {
    function CommonModule() {
    }
    return CommonModule;
}());
CommonModule.decorators = [
    { type: _angular_core.NgModule, args: [{
                declarations: [],
                imports: [
                    _angular_http.HttpModule
                ],
                providers: [
                    WebsocketService,
                    HttpErrorService,
                    HelperService,
                    ngxCookieService.CookieService,
                    {
                        provide: HttpService,
                        useFactory: httpFactory,
                        deps: [_angular_core.Injector, _angular_http.XHRBackend, _angular_http.RequestOptions]
                    }
                ]
            },] },
];
/** @nocollapse */
CommonModule.ctorParameters = function () { return []; };

var RealtorModel = (function () {
    function RealtorModel() {
        this.guid = '';
        this.firstname = '';
        this.lastname = '';
        this.email = '';
        this.experience = 0;
        this.avatar_guid = '';
        this.geo_guid = '';
        this.description = '';
        this.is_online = false;
        this.phones = [];
        this.specializations = [];
        this.districts = [];
        this.is_agency = false;
        this.agency_position = '';
        this.agency_title = '';
        this.can_work_other_city = false;
        this.birthday = 0;
        this.site_url = '';
        this.socials = [];
        // Ранг на английском
        this.rank = '';
        // Ранг на русском
        this.rank_title = '';
        // Информация для покупателя
        this.customer_info = '';
        // На модерации
        this.on_moderate = false;
    }
    return RealtorModel;
}());

var __extends$2 = (true && true.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var CurrentUserInfoModel = (function (_super) {
    __extends$2(CurrentUserInfoModel, _super);
    function CurrentUserInfoModel() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    return CurrentUserInfoModel;
}(RealtorModel));

var __extends$3 = (true && true.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
/**
 * Динамический справочник.
 *
 * Используется для простых операций с однотипными справочниками. Получать экземпляр сервиса удобно через
 * сервис DynamicRefsFactoryService:
 *
 * @Component({
 *  providers: [DynamicRefsFactoryService]
 * })
 * export class MyComponent {
 *  constructor(private refsFactory: DynamicRefsFactoryService) {}
 *
 *  onInit() {
 *    this.refsFactory.getInstance('geo').getAll({page: 1}).then((response) => {
 *      // process response
 *    }).catch((err) => {
 *      // process error
 *    });
 *  }
 * }
 *
 * Данный сервис нельзя получить через Injector.
 *
 * @see DynamicRefsBuilderService
 */
var DynamicRefsService = (function (_sup