public static TokenItem LogIn(String login, String password, long appId) { // load user and check for user unexistence Actor currActor = ActorTools.Read(login); if (currActor == null) { return(null); // can't login unexistent user } // check for [id,appId] in use already long currActorId = currActor.Id; Guid?currToken = _loadTokenValueByUserIdAndAppId(currActorId, appId); if (currToken != null) // [id,appId] already in use !!! { // we need to log out old working user before login new one // we log out when all values known now !!! _removeTokenValueByUserIdAndAppId(currActorId, appId); _removeTokenItemByToken(currToken); } // create TokenItem for new user Guid newActionToken = Guid.NewGuid(); Guid refToken = Guid.NewGuid(); TokenItem newTokenItem = new TokenItem(currActor.Id, appId, newActionToken, refToken); // save new TokenItem and new token in memory storage _saveTokenValueByUserIdAndAppId(currActor.Id, appId, newActionToken); _saveTokenItemByToken(newActionToken, newTokenItem); return(newTokenItem); }
private static TokenItem _loadTokenItemByToken(Guid?token) { String storageKey = token.ToString(); TokenItem tokenItem = (TokenItem)StoragePerApplication.Get(storageKey); return(tokenItem); }
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.Identifier) Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.ElementName); return Children.Count > 0; }
public async Task LogIn(string username, string password) { try { TokenItem tokenResponse = await _apiHelper.AuthenticateAsync(username, password); if (!String.IsNullOrWhiteSpace(tokenResponse.Token)) { Token = tokenResponse; } else { throw new Exception("Empty token received"); } } catch (Exception ex) { if (ex.Message.Equals("Unauthorized")) { throw new Exception("Bad login or password"); } else { throw new Exception(ex.Message); } } }
public void ItemAfterPositionTest() { CssParser p = new CssParser(); StyleSheet s = p.Parse("@charset \"foo\"; .a { color: red; } moo boo", true); Assert.IsNull(s.ItemAfterPosition(s.AfterEnd)); TokenItem tokenItem = s.ItemAfterPosition(s.AfterEnd - 9) as TokenItem; Assert.IsNotNull(tokenItem); Assert.AreEqual(CssTokenType.CloseCurlyBrace, tokenItem.TokenType); // In the last token tokenItem = s.ItemAfterPosition(s.AfterEnd - 1) as TokenItem; Assert.IsNull(tokenItem); // Before the first token tokenItem = s.ItemAfterPosition(-8) as TokenItem; Assert.IsNotNull(tokenItem); Assert.AreEqual(CssTokenType.At, tokenItem.TokenType); // Between the first two tokens tokenItem = s.ItemAfterPosition(1) as TokenItem; Assert.IsNotNull(tokenItem); Assert.AreEqual(CssTokenType.Identifier, tokenItem.TokenType); Assert.AreEqual("charset", tokenItem.Text); // Before the semicolon in the @charset tokenItem = s.ItemAfterPosition(14) as TokenItem; Assert.IsNotNull(tokenItem); Assert.AreEqual(CssTokenType.Semicolon, tokenItem.TokenType); }
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.Asterisk) Asterisk = Children.AddCurrentAndAdvance(stream); return Children.Count > 0; }
public static void LogOut(TokenItem currItem) { Guid actToken = currItem.ActionToken; _removeTokenValueByUserIdAndAppId(currItem.Id, currItem.ApplicationId); _removeTokenItemByToken(actToken); }
public CallNode(string name, IList <Node> parameters, TokenItem token, string type) { Name = name; Parameters = parameters; Token = token; Type = type; }
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.Ampersand) Ampersand = Children.AddCurrentAndAdvance(stream, SassClassifierType.ParentReference); return Children.Count > 0; }
public EqualExpression(Node left, Node right, TokenItem tokenItem, string name) { Left = left; Right = right; TokenItem = tokenItem; Name = name; }
public (TokenItem, string) CreateNewTokenItem() { ResetAcc(); //this.comboBox1.DataSource = Enum.GetValues( typeof(RegInfo.TYPE) ); this._label1.Text = Resources.Editor_CreateNewTokenItem_Base64Token_; this._label2.Text = Resources.Editor_CreateNewTokenItem_Trusted_ + Resources.Editor_CreateNewTypeHolder___0_or_1_; this._label3.Text = Resources.Editor_CreateNewTokenItem_Remember_ + Resources.Editor_CreateNewTypeHolder___0_or_1_; var ret = ShowDialog(); this.DialogResult = DialogResult.Retry; if (ret == DialogResult.Yes) { var token = new TokenItem(new byte[64], this._textBox2.Text == Resources.Editor_CreateNewTypeHolder__True, this._textBox3.Text == Resources.Editor_CreateNewTypeHolder__True); try { token.Base64Key = this._textBox1.Text; } catch (Exception e) { MessageBox.Show(e.Message); throw new NotSupportedException(); } return(token, this._textBox1.Text); } throw new NotSupportedException(); }
public void ParseItem_AddParseErrorTest() { CharsetDirective cd = new CharsetDirective(); Assert.IsFalse(cd.HasParseErrors); Assert.IsFalse(cd.ContainsParseErrors); Assert.AreEqual(0, cd.ParseErrors.Count); cd.Children.AddParseError(ParseErrorType.AtDirectiveSemicolonMissing); Assert.IsTrue(cd.HasParseErrors); Assert.IsTrue(cd.ContainsParseErrors); Assert.AreEqual(1, cd.ParseErrors.Count); Assert.AreEqual(ParseErrorType.AtDirectiveSemicolonMissing, cd.ParseErrors[0].ErrorType); Assert.AreEqual(ParseErrorLocation.BeforeItem, cd.ParseErrors[0].Location); cd.AddParseError(ParseErrorType.UnexpectedToken, ParseErrorLocation.WholeItem); Assert.AreEqual(2, cd.ParseErrors.Count); Assert.AreEqual(ParseErrorType.UnexpectedToken, cd.ParseErrors[1].ErrorType); Assert.AreEqual(ParseErrorLocation.WholeItem, cd.ParseErrors[1].Location); TokenItem ti = new TokenItem(new CssToken(CssTokenType.At, 0, 0), null); Assert.IsFalse(ti.HasParseErrors); Assert.AreEqual(0, ti.ParseErrors.Count); cd.Children.Add(ti); cd.Children.AddParseError(ParseErrorType.AtDirectiveNameMissing); Assert.AreEqual(2, cd.ParseErrors.Count); Assert.AreEqual(1, ti.ParseErrors.Count); Assert.AreEqual(ParseErrorType.AtDirectiveNameMissing, ti.ParseErrors[0].ErrorType); Assert.AreEqual(ParseErrorLocation.AfterItem, ti.ParseErrors[0].Location); }
public void Declaration_ParseTest2() { string text = "-moz-image: url(image.jpg) -25 bar baz"; ITextProvider tp = new StringTextProvider(text); TokenStream tokens = Helpers.MakeTokenStream(tp); Declaration d = new Declaration(); Assert.IsTrue(d.Parse(new ItemFactory(tp, null), tp, tokens)); Assert.AreEqual(0, d.Start); Assert.AreEqual(text.Length, d.AfterEnd); Assert.AreEqual(6, d.Children.Count); Assert.AreEqual(null, d.Semicolon); Assert.IsInstanceOfType(d.Children[0], typeof(TokenItem)); TokenItem name = (TokenItem)d.Children[0]; Assert.AreEqual(CssTokenType.Identifier, name.Token.TokenType); Assert.AreEqual(typeof(TokenItem), d.Children[1].GetType()); Assert.AreEqual(CssTokenType.Colon, ((TokenItem)d.Children[1]).Token.TokenType); Assert.AreEqual(typeof(UrlItem), d.Children[2].GetType()); Assert.AreEqual(3, ((UrlItem)d.Children[2]).Children.Count); Assert.AreEqual(typeof(NumericalValue), d.Children[3].GetType()); }
internal TokenItem AddCurrentAndAdvance(TokenStream tokens, IClassifierContext context) { TokenItem item = new TokenItem(tokens.AdvanceToken(), context); Add(item); return(item); }
public async Task <IHttpActionResult> PostDeleteToken(TokenItem item) { var notifyService = new GamesNotificationsService(); await notifyService.UnregisterDeviceToken(base.CurrUserId, item.Token); return(Ok()); }
public async Task Test_GetServersList() { TokenItem token = await _apiHelper.AuthenticateAsync(_userName, _password); var servers = await _apiHelper.GetServersList(token.Token); Assert.NotZero(servers.Count, "Error while returning servers"); }
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens) { ParseAtAndKeyword(itemFactory, text, tokens); ParseAfterName(itemFactory, text, tokens); bool foundEnd = false; while (!tokens.CurrentToken.IsBlockTerminator()) { CssTokenType tokenType = tokens.CurrentToken.TokenType; if (tokens.CurrentToken.TokenType == CssTokenType.OpenCurlyBrace) { BlockItem block = NewBlock(); if (block == null) { break; } else if (block.Parse(itemFactory, text, tokens)) { foundEnd = true; Block = block; Children.Add(block); } else { foundEnd = true; Children.AddUnknownAndAdvance(itemFactory, text, tokens); } } else if (!ParseNextChild(itemFactory, text, tokens)) { TokenItem item = Children.AddUnknownAndAdvance(itemFactory, text, tokens) as TokenItem; if (item != null && item.TokenType == CssTokenType.Semicolon) { Debug.Assert(Semicolon == null); Semicolon = item; } } if (tokenType == CssTokenType.Semicolon) { foundEnd = true; break; } else if (tokenType == CssTokenType.OpenCurlyBrace) { break; } } if (!foundEnd && !AllowUnclosed) { Children.AddParseError(ParseErrorType.AtDirectiveSemicolonMissing); } return(Children.Count > 0); }
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.Ampersand) { Ampersand = Children.AddCurrentAndAdvance(stream, SassClassifierType.ParentReference); } return(Children.Count > 0); }
public async Task <IHttpActionResult> PostSaveToken(TokenItem item) { var notifyService = new GamesNotificationsService(); int id = 0; await notifyService.SaveUserDeviceToken(CurrUserId, item.Token, id, item.IsIOS, item.Section); return(Ok()); }
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.Asterisk) { Asterisk = Children.AddCurrentAndAdvance(stream); } return(Children.Count > 0); }
public FunctionDeclarationNode(string functionName, IList <ParameterNode> parameters, BlockNode block, TokenItem token, TypeNode returnType) { Name = functionName; Parameters = parameters; Block = block; Token = token; ReturnType = returnType; MethodType = "Function"; }
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.Identifier) { Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.ElementName); } return(Children.Count > 0); }
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.Colon && stream.Peek(1).Type == TokenType.Identifier) { Prefix = Children.AddCurrentAndAdvance(stream, SassClassifierType.PseudoClass); ClassName = Children.AddCurrentAndAdvance(stream, SassClassifierType.PseudoClass); } return(Children.Count > 0); }
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.DoubleColon && stream.Peek(1).Type == TokenType.Identifier) { Prefix = Children.AddCurrentAndAdvance(stream, SassClassifierType.PseudoElement); Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.PseudoElement); } return Children.Count > 0; }
public IActionResult Create([FromBody] TokenItem item) { if (item == null) { return(BadRequest()); } _context.TokenItems.Add(item); _context.SaveChanges(); return(CreatedAtRoute("GetToken", new { id = item.Id }, item)); }
public void ComplexItem_ItemFromPositionTest() { CssParser p = new CssParser(); StyleSheet s = p.Parse("@charset \"foo\"; .a { color: red; } /* */", true); TokenItem ti = s.ItemFromRange(0, 1) as TokenItem; Assert.AreEqual(CssTokenType.At, ti.TokenType); ti = s.ItemFromRange(s.AfterEnd - 1, 0) as TokenItem; Assert.AreEqual(CssTokenType.CloseCComment, ti.TokenType); ti = s.ItemFromRange(16, 1) as TokenItem; Assert.AreEqual(CssTokenType.Dot, ti.TokenType); }
protected bool CheckSemicolon(TokenStream tokens) { if (tokens.CurrentToken.TokenType == CssTokenType.Semicolon) { Semicolon = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Default); } else { AddParseError(ParseErrorType.AtDirectiveSemicolonMissing, ParseErrorLocation.AfterItem); } return(Semicolon != null); }
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens) { Debug.Assert(tokens.CurrentToken.TokenType == CssTokenType.Number); if (tokens.CurrentToken.TokenType != CssTokenType.Number) { return(false); } Number = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Number); return(Children.Count > 0); }
public bool GetConfirm(TokenItem ti) { ResetAndInfo("Key= " + string.Join(" ,", NetBase.SubArray(ti.TokenBytes, 0, 8)) + "\n" + ti.Base64Key + "\n" + ti.Description); var ret = ShowDialog(); var bret = ret == DialogResult.Yes || ret == DialogResult.OK; if (ChackboxChecked) { ßMainPoint.S.ToakenList.Add(ti.Base64Key, new TokenItem(ti.TokenBytes, bret, true, this._descriptionBox.Text)); } return(bret); }
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens) { if (tokens.CurrentToken.TokenType == CssTokenType.Comma) { Comma = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Default); } if (tokens.CurrentToken.TokenType == CssTokenType.Identifier) { if (TextRange.CompareDecoded(tokens.CurrentToken.Start, tokens.CurrentToken.Length, text, "only", ignoreCase: true) || TextRange.CompareDecoded(tokens.CurrentToken.Start, tokens.CurrentToken.Length, text, "not", ignoreCase: true)) { Operation = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.MediaQueryOperation); } } if (tokens.CurrentToken.TokenType == CssTokenType.Identifier && !IsMediaExpressionStart(text, tokens.CurrentToken)) { MediaType = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.MediaType); } else if (tokens.CurrentToken.TokenType != CssTokenType.OpenFunctionBrace) { Children.AddParseError(ParseErrorType.MediaTypeMissing); } while (!tokens.CurrentToken.IsDirectiveTerminator() && tokens.CurrentToken.TokenType != CssTokenType.Comma) { if (IsMediaExpressionStart(text, tokens.CurrentToken)) { MediaExpression mx = itemFactory.CreateSpecific <MediaExpression>(this); if (mx.Parse(itemFactory, text, tokens)) { Expressions.Add(mx); Children.Add(mx); } else { Children.AddUnknownAndAdvance(itemFactory, text, tokens, ParseErrorType.MediaExpressionExpected); } } else { Children.AddUnknownAndAdvance(itemFactory, text, tokens, ParseErrorType.UnexpectedMediaQueryToken); } } return(Children.Count > 0); }
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens) { if (tokens.CurrentToken.TokenType == CssTokenType.Identifier && TextRange.CompareDecoded(tokens.CurrentToken.Start, tokens.CurrentToken.Length, text, "and", true)) { MediaCombineOperator = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.MediaCombineOperator); } if (tokens.CurrentToken.TokenType == CssTokenType.OpenFunctionBrace) { OpenFunctionBrace = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.FunctionBrace); ParseFeatureName(itemFactory, text, tokens); if (tokens.CurrentToken.TokenType == CssTokenType.Colon) { Colon = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.Punctuation); } while (tokens.CurrentToken.TokenType != CssTokenType.CloseFunctionBrace && tokens.CurrentToken.TokenType != CssTokenType.OpenCurlyBrace && !tokens.CurrentToken.IsScopeBlocker()) { ParseNextValue(itemFactory, text, tokens); } if (tokens.CurrentToken.TokenType == CssTokenType.CloseFunctionBrace) { CloseFunctionBrace = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.FunctionBrace); } else { OpenFunctionBrace.AddParseError(ParseErrorType.CloseFunctionBraceMissing, ParseErrorLocation.AfterItem); } if ((Colon != null && Children[Children.Count - 1] == Colon) || (Colon != null && CloseFunctionBrace != null && Children.IndexOf(Colon) + 1 == Children.IndexOf(CloseFunctionBrace))) { // There was nothing between the colon and close brace Colon.AddParseError(ParseErrorType.PropertyValueMissing, ParseErrorLocation.AfterItem); } } if (MediaCombineOperator != null && OpenFunctionBrace == null) { MediaCombineOperator.AddParseError(ParseErrorType.MediaExpressionExpected, ParseErrorLocation.AfterItem); } return(Children.Count > 0); }
public static TokenItem CheckIsLoggedInAndRefreshIfNeed(TokenItem currItem) { if (currItem.IsRefreshTokenActual() == false) { LogOut(currItem); return(null); } if (currItem.IsActionTokenActual() == false) { currItem = _refreshTokens(currItem); } return(currItem); }
private static TokenItem _refreshTokens(TokenItem currItem) // only for internal use when actor is actually logged in { // remove all current data from storage LogOut(currItem); Guid actToken = Guid.NewGuid(); Guid refToken = Guid.NewGuid(); TokenItem result = new TokenItem(currItem.Id, currItem.ApplicationId, actToken, refToken); // save new TokenItem and new token in memory storage _saveTokenValueByUserIdAndAppId(result.Id, result.ApplicationId, result.ActionToken); _saveTokenItemByToken(result.ActionToken, result); return(result); }
protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.Colon && stream.Peek(1).Type == TokenType.Function) { Prefix = Children.AddCurrentAndAdvance(stream); var function = itemFactory.CreateSpecific<PseduoFunction>(this, text, stream); if (function.Parse(itemFactory, text, stream)) { Function = function; Children.Add(function); } } return Children.Count > 0; }
private void CheckCustomPropertyName(ITextProvider text) { if (CustomPropertyName == null) { CloseBrace.AddParseError(ParseErrorType.FunctionArgumentMissing, ParseErrorLocation.BeforeItem); } else { TokenItem customPropertyToken = CustomPropertyName as TokenItem; if (customPropertyToken == null || !text.GetText(customPropertyToken.Start, customPropertyToken.Length).StartsWith("--", StringComparison.Ordinal)) { CustomPropertyName.AddParseError(ParseErrorType.CustomPropertyNameExpected, ParseErrorLocation.WholeItem); } } }
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream) { if (stream.Current.Type == TokenType.Identifier && IsValidNamedRange(text.GetText(stream.Current.Start, stream.Current.Length))) { AnimationBegin = Children.AddCurrentAndAdvance(stream, SassClassifierType.Keyword); } else if (stream.Current.Type == TokenType.Number && stream.Peek(1).Type == TokenType.PercentSign) { ParseItem begin = itemFactory.Create<PercentageUnit>(this, text, stream); if (begin.Parse(itemFactory, text, stream)) { AnimationBegin = begin; Children.Add(begin); if (stream.Current.Type == TokenType.Comma) Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation); ParseItem end = itemFactory.Create<PercentageUnit>(this, text, stream); if (end.Parse(itemFactory, text, stream)) { AnimationEnd = end; Children.Add(end); } } } if (AnimationBegin != null) { var block = itemFactory.CreateSpecific<RuleBlock>(this, text, stream); if (block.Parse(itemFactory, text, stream)) { Body = block; Children.Add(block); } } return Children.Count > 0; }
// virtual void removedClient(intptr_t) = 0; // virtual void removedConnect(intptr_t) = 0; // virtual void foundMatch(intptr_t client, intptr_t connect) = 0; protected void insertClient(string token, object data) { foreach(TokenItem item in mPendingConnects) { if(item.Token==token) { foundMatch((NetComputer)data, item.Data); mPendingConnects.Remove(item); //mPendingConnects.erase(--it.base()); return; } } DateTime current=DateTime.Now; TokenItem tItem=new TokenItem(token, data, current); mPendingClients.Add(tItem); removeOutdated(current); }