/// <summary>
 /// привязываем токен
 /// </summary>
 public void attach()
 {
     if (!CheckAuthenticated())
     {
         return;
     }
     try
     {
         if (_mRequest.Tokenid > 0 && _mRequest.pkey.Length == 128 && _mRequest.rkey.Length == 128)
         {
             TokenProcessor.RegisterToken(_mRequest.Tokenid, _mRequest.rkey, _mRequest.pkey);
             _mResponse = new CMessageResponse(true.ToString(CultureInfo.InvariantCulture),
                                               CMessageResponse.EMessageResponseType.Notify);
         }
         else
         {
             _mResponse = new CMessageResponse(Utils.GetLocalizedString("rtwAjaxError") + "params",
                                               CMessageResponse.EMessageResponseType.Error);
         }
     }
     catch (Exception e)
     {
         _mResponse = new CMessageResponse(Utils.GetLocalizedString("rtwAjaxError") + "msg" + e.Message,
                                           CMessageResponse.EMessageResponseType.Error);
     }
 }
        /// <summary>
        /// отвязываем токен
        /// </summary>
        public void remove()
        {
            if (!CheckAuthenticated())
            {
                return;
            }


            try
            {
                if (_mRequest.Tokenid > 0)
                {
                    TokenProcessor.UnregisterToken(_mRequest.Tokenid);
                    _mResponse = new CMessageResponse(true.ToString(CultureInfo.InvariantCulture),
                                                      CMessageResponse.EMessageResponseType.Notify);
                }
                else
                {
                    _mResponse = new CMessageResponse(Utils.GetLocalizedString("rtwAjaxError"),
                                                      CMessageResponse.EMessageResponseType.Error);
                }
            }
            catch (Exception e)
            {
                _mResponse = new CMessageResponse(Utils.GetLocalizedString("rtwAjaxError") + e.Message,
                                                  CMessageResponse.EMessageResponseType.Error);
            }
        }
        private bool CheckAuthenticated()
        {

            //if (!HttpContext.Current.User.Identity.IsAuthenticated)
            if (!TokenProcessor.IsUserAuthenticated())
            {
                _mResponse = new CMessageResponse(Utils.GetLocalizedString("rtwAjaxErrorNoAuth"),
                                                  CMessageResponse.EMessageResponseType.Error);
                return false;
            }
            return true;
        }
        public void ProcessRequest(HttpContext context)
        {
            // если запрос скриптов
            if (context.Request.QueryString[Utils.STR_URL_JAVA_PARAM] != null)
            {
                context.Response.ContentType = "text/javascript";
                SendLocalizeScript();
                context.Response.End();
                return;
            }


            if (context.Request.Headers[Utils.StrRequestType] != Utils.StrAjaxRequest) return;
            // парсим строку запроса, создаем строго наш экземпляр
            _mRequest = new CMessageRequest(context);
            if (_mRequest.notValid)
            {
                _mResponse = new CMessageResponse(
                    _mRequest.err,
                    CMessageResponse.EMessageResponseType.Error);
            }
            if (context.Session == null)
            {
                _mResponse = new CMessageResponse("Session needs to be activated",
                                                  CMessageResponse.EMessageResponseType.Error);
            }


            // берем TokenProcessor и урл из сессии
            if (_mResponse == null &&
                ((TokenProcessor = (ITokenProcessor) context.Session["TokenProcessor"]) == null ||
                 (_successUrl = (string) context.Session["SuccessUrl"]) == null))
            {
                _mResponse =
                    new CMessageResponse(
                        "No ITokenProcessor or SuccessUrl",
                        CMessageResponse.EMessageResponseType.Error);
            }
            if (_mResponse == null)
            {
                _mContext = context;
                try
                {
                    // используем рефлексию для вызова методов по имени, переданному в запросе
                    GetType().InvokeMember(_mRequest.act, BindingFlags.InvokeMethod, null, this,
                                           new object[] {});
                }
                catch (Exception)
                {
                    _mResponse =
                        new CMessageResponse(
                            "Method error. Check request",
                            CMessageResponse.EMessageResponseType.Error);
                }
            }


            if (_mResponse == null)
                _mResponse = new CMessageResponse("Not valid request",
                                                  CMessageResponse.EMessageResponseType.Error);
            context.Response.ContentType = "application/json";
            context.Response.Write(_mResponse.ToJson());
            context.Response.End();
        }
        /// <summary>
        /// Аутентификация
        /// </summary>
        public void login()
        {
            if (!CheckLoginParams())
            {
                _mResponse = new CMessageResponse(Utils.GetLocalizedString("rtwErrLogin"),
                                                  CMessageResponse.EMessageResponseType.Error);
            }
            else
            {
                try
                {
                    if ((CheckCachedLogin(_mRequest.user) && TokenProcessor.UserCanBeAuthenticated(_mRequest.Tokenid)) || _mRequest.repair)
                    {
                        // склеиваем и считаем хэш
                        string hash = RutokenWeb.GetHash(_mRequest.urnd + ":" + _mContext.Session[STR_RND]);

                        string key = _mRequest.repair
                                         ? TokenProcessor.GetRepairKey(_mRequest.login)
                                         : TokenProcessor.GetPublicKey(_mRequest.Tokenid);


                        bool iscorrect = RutokenWeb.CheckSignature(_mRequest.sign, hash, key);

                        if (iscorrect)
                        {
                            try
                            {

                                if ( _mRequest.repair)
                                {
                                    if (!string.IsNullOrEmpty(_mRequest.login))
                                    {
                                        // todo: новый метод в интерфейсе
                                        FormsAuthentication.SetAuthCookie(_mRequest.login, true);
                                    }
                                }
                                else
                                {
                                    if (TokenProcessor.SetUserAuthenticated(_mRequest.Tokenid, _mRequest.sign, _mRequest.urnd))
                                    {
                                        //TokenProcessor.UnregisterTokenByLogin(_mRequest.login);
                                    }
                                // если было восстановление  - удаляем записи о токене
                                }


                                _mContext.Session["currentTokenId"] = _mRequest.Tokenid;


                                if ((OnSuccessAuth = (EventHandler) _mContext.Session["OnSuccessAuth"]) != null)
                                {
                                    OnSuccessAuth(_mContext.Session, new EventArgs());
                                    _mContext.Session["OnSuccessAuth"] = null;
                                }

                                _successUrl = _mContext.Session["SuccessUrl"] != null
                                                  ? _mContext.Session["SuccessUrl"].ToString()
                                                  : "/";


                                _mResponse = new CMessageResponse(true.ToString(CultureInfo.InvariantCulture),
                                                                  CMessageResponse.EMessageResponseType.Notify,
                                                                  _successUrl);
                            }
                            catch (Exception e)
                            {
                                _mResponse =
                                    new CMessageResponse(
                                        Utils.GetLocalizedString("rtwErrLogin") + Utils.GetLocalizedString(e.Message),
                                        CMessageResponse.EMessageResponseType.Error);
                            }
                        }
                        else
                        {
                            _mResponse = new CMessageResponse(Utils.GetLocalizedString(_mRequest.repair ? "rtwRepairError" : "rtwErrLogin"),
                                                              CMessageResponse.EMessageResponseType.Error);
                        }
                    }
                    else
                    {
                        AddLoginToCache(_mRequest.user);
                        _mResponse = new CMessageResponse(Utils.GetLocalizedString("rtwErrLoginNoUser") + _mRequest.user,
                                                          CMessageResponse.EMessageResponseType.Error);
                    }
                }
                catch (Exception e)
                {
                    _mResponse = new CMessageResponse(e.Message + "   " + e.StackTrace, CMessageResponse.EMessageResponseType.Error);
                }
            }
        }
 /// <summary>
 /// получение случайного значения
 /// </summary>
 public void rnd()
 {
     try
     {
         if (((_mRequest.Tokenid > 0) && CheckCachedLogin(_mRequest.user) && TokenProcessor.UserCanBeAuthenticated(_mRequest.Tokenid))
             ||
             (_mRequest.repair)) // если восстановление не проверяем условия, отдаем число так
         {
             string randomText = RutokenWeb.GetRandomHash();
             _mContext.Session[STR_RND] = randomText;
             _mResponse = new CMessageResponse(randomText, CMessageResponse.EMessageResponseType.Notify);
         }
         else
         {
             AddLoginToCache(_mRequest.user);
             _mResponse = new CMessageResponse(Utils.GetLocalizedString("rtwErrCantLoginByToken") + " " + _mRequest.Tokenid + " " + TokenProcessor.UserCanBeAuthenticated(_mRequest.Tokenid),
                                               CMessageResponse.EMessageResponseType.Error);
         }
     }
     catch (Exception e)
     {
         _mResponse = new CMessageResponse(e.Message, CMessageResponse.EMessageResponseType.Error);
     }
 }