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);
}
