protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
        {
            Guid guid = ((ShortGuid)this.ActivationKey).Guid;
            this.Token = DatabaseHelper.GetSingle<Token, Guid>(DatabaseHelper.SubsystemEnum.Token,
                guid, LinqQueries.CompiledQuery_GetTokenByUniqueId);

            if (this.Token != default(Token))
            {
                MembershipUser user = Membership.GetUser(this.Token.UserName);

                if (user != null)
                {
                    user.IsApproved = true;
                    Membership.UpdateUser(user);

                    DatabaseHelper.Delete<Token>(DatabaseHelper.SubsystemEnum.Token, this.Token);
                }
            }

            return ActivityExecutionStatus.Closed;
        }
예제 #2
0
        private Token NextToken()
        {
            string message = null;  // for any error messages.

            TokenID tokenID = TokenID.Unknown;

            char ch = CurrentChar();
            ch = SkipWhitespace(ch);

            if (ch == '\0')
                return new Token(TokenID.EndOfInput, currentPosition, null);

            tokenStartPosition = currentPosition;
            tokenValue = null;

            if (char.IsDigit(ch))
            {
                tokenID = ScanNumber();
            }
            else if (char.IsLetter(ch))
            {
                tokenID = ScanKeywordOrIdentifier();
            }
            else
            {
                switch (ch)
                {
                    case '_':
                        tokenID = ScanKeywordOrIdentifier();
                        break;
                    case '+':
                        tokenID = TokenID.Plus;
                        NextChar();
                        break;
                    case '-':
                        tokenID = TokenID.Minus;
                        NextChar();
                        break;
                    case '*':
                        tokenID = TokenID.Multiply;
                        NextChar();
                        break;
                    case '/':
                        tokenID = TokenID.Divide;
                        NextChar();
                        break;
                    case '%':
                        tokenID = TokenID.Modulus;
                        NextChar();
                        break;
                    case '&':
                        tokenID = TokenID.BitAnd;
                        if (NextChar() == '&')
                        {
                            NextChar();
                            tokenID = TokenID.And;
                        }
                        break;
                    case '|':
                        tokenID = TokenID.BitOr;
                        if (NextChar() == '|')
                        {
                            NextChar();
                            tokenID = TokenID.Or;
                        }
                        break;
                    case '=':
                        tokenID = TokenID.Assign;
                        if (NextChar() == '=')
                        {
                            // It's "==", so the token is Equal
                            NextChar();
                            tokenID = TokenID.Equal;
                        }
                        break;
                    case '!':
                        tokenID = TokenID.Not;
                        if (NextChar() == '=')
                        {
                            NextChar();
                            tokenID = TokenID.NotEqual;
                        }
                        break;
                    case '<':
                        tokenID = TokenID.Less;
                        ch = NextChar();
                        if (ch == '=')
                        {
                            NextChar();
                            tokenID = TokenID.LessEqual;
                        }
                        else if (ch == '>')
                        {
                            NextChar();
                            tokenID = TokenID.NotEqual;
                        }
                        break;
                    case '>':
                        tokenID = TokenID.Greater;
                        if (NextChar() == '=')
                        {
                            NextChar();
                            tokenID = TokenID.GreaterEqual;
                        }
                        break;
                    case '(':
                        tokenID = TokenID.LParen;
                        NextChar();
                        break;
                    case ')':
                        tokenID = TokenID.RParen;
                        NextChar();
                        break;
                    case '.':
                        tokenID = TokenID.Dot;
                        if (char.IsDigit(PeekNextChar()))
                            tokenID = ScanDecimal();
                        else
                            NextChar(); // consume the '.'
                        break;
                    case ',':
                        tokenID = TokenID.Comma;
                        NextChar();
                        break;
                    case ';':
                        tokenID = TokenID.Semicolon;
                        NextChar();
                        break;
                    case '[':
                        tokenID = TokenID.LBracket;
                        NextChar();
                        break;
                    case ']':
                        tokenID = TokenID.RBracket;
                        NextChar();
                        break;
                    case '{':
                        tokenID = TokenID.LCurlyBrace;
                        NextChar();
                        break;
                    case '}':
                        tokenID = TokenID.RCurlyBrace;
                        NextChar();
                        break;
                    case '@':
                        ch = NextChar();
                        if (ch == '"')
                        {
                            tokenID = ScanVerbatimStringLiteral();
                        }
                        else
                        {
                            message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidCharacter, ch);
                            throw new RuleSyntaxException(ErrorNumbers.Error_InvalidCharacter, message, tokenStartPosition);
                        }
                        NextChar();
                        break;
                    case '"':
                        tokenID = ScanStringLiteral();
                        NextChar();
                        break;
                    case '\'':
                        tokenID = ScanCharacterLiteral();
                        NextChar();
                        break;
                    default:
                        NextChar();
                        message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidCharacter, ch);
                        throw new RuleSyntaxException(ErrorNumbers.Error_InvalidCharacter, message, tokenStartPosition);
                }
            }

            Token token = new Token(tokenID, tokenStartPosition, tokenValue);
            currentToken = tokenID;
            return token;
        }
예제 #3
0
 internal void TokenizeForIntellisense(List<Token> tokenList)
 {
     Token token = null;
     do
     {
         try
         {
             token = NextToken();
             tokenList.Add(token);
         }
         catch (RuleSyntaxException)
         {
             // Instead of the invalid token, insert a "placeholder" illegal
             // token.  This will prevent accidentally legal expressions.
             token = new Token(TokenID.Illegal, 0, null);
             tokenList.Add(token);
         }
     } while (token != null && token.TokenID != TokenID.EndOfInput);
 }
 internal void TokenizeForIntellisense(List<Token> tokenList)
 {
     Token item = null;
     do
     {
         try
         {
             item = this.NextToken();
             tokenList.Add(item);
         }
         catch (RuleSyntaxException)
         {
             item = new Token(TokenID.Illegal, 0, null);
             tokenList.Add(item);
         }
     }
     while ((item != null) && (item.TokenID != TokenID.EndOfInput));
 }
        private Token NextToken()
        {
            string message = null;
            Token token;
            TokenID unknown = TokenID.Unknown;
            char ch = this.CurrentChar();
            ch = this.SkipWhitespace(ch);
            if (ch == '\0')
            {
                return new Token(TokenID.EndOfInput, this.currentPosition, null);
            }
            this.tokenStartPosition = this.currentPosition;
            this.tokenValue = null;
            if (char.IsDigit(ch))
            {
                unknown = this.ScanNumber();
            }
            else if (char.IsLetter(ch))
            {
                unknown = this.ScanKeywordOrIdentifier();
            }
            else
            {
                switch (ch)
                {
                    case '!':
                        unknown = TokenID.Not;
                        if (this.NextChar() == '=')
                        {
                            this.NextChar();
                            unknown = TokenID.NotEqual;
                        }
                        goto Label_0397;

                    case '"':
                        unknown = this.ScanStringLiteral();
                        this.NextChar();
                        goto Label_0397;

                    case '%':
                        unknown = TokenID.Modulus;
                        this.NextChar();
                        goto Label_0397;

                    case '&':
                        unknown = TokenID.BitAnd;
                        if (this.NextChar() == '&')
                        {
                            this.NextChar();
                            unknown = TokenID.And;
                        }
                        goto Label_0397;

                    case '\'':
                        unknown = this.ScanCharacterLiteral();
                        this.NextChar();
                        goto Label_0397;

                    case '(':
                        unknown = TokenID.LParen;
                        this.NextChar();
                        goto Label_0397;

                    case ')':
                        unknown = TokenID.RParen;
                        this.NextChar();
                        goto Label_0397;

                    case '*':
                        unknown = TokenID.Multiply;
                        this.NextChar();
                        goto Label_0397;

                    case '+':
                        unknown = TokenID.Plus;
                        this.NextChar();
                        goto Label_0397;

                    case ',':
                        unknown = TokenID.Comma;
                        this.NextChar();
                        goto Label_0397;

                    case '-':
                        unknown = TokenID.Minus;
                        this.NextChar();
                        goto Label_0397;

                    case '.':
                        unknown = TokenID.Dot;
                        if (!char.IsDigit(this.PeekNextChar()))
                        {
                            this.NextChar();
                        }
                        else
                        {
                            unknown = this.ScanDecimal();
                        }
                        goto Label_0397;

                    case '/':
                        unknown = TokenID.Divide;
                        this.NextChar();
                        goto Label_0397;

                    case ';':
                        unknown = TokenID.Semicolon;
                        this.NextChar();
                        goto Label_0397;

                    case '<':
                        unknown = TokenID.Less;
                        switch (this.NextChar())
                        {
                            case '=':
                                this.NextChar();
                                unknown = TokenID.LessEqual;
                                break;

                            case '>':
                                this.NextChar();
                                unknown = TokenID.NotEqual;
                                break;
                        }
                        goto Label_0397;

                    case '=':
                        unknown = TokenID.Assign;
                        if (this.NextChar() == '=')
                        {
                            this.NextChar();
                            unknown = TokenID.Equal;
                        }
                        goto Label_0397;

                    case '>':
                        unknown = TokenID.Greater;
                        if (this.NextChar() == '=')
                        {
                            this.NextChar();
                            unknown = TokenID.GreaterEqual;
                        }
                        goto Label_0397;

                    case '@':
                        ch = this.NextChar();
                        if (ch != '"')
                        {
                            message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidCharacter, new object[] { ch });
                            throw new RuleSyntaxException(0x17b, message, this.tokenStartPosition);
                        }
                        unknown = this.ScanVerbatimStringLiteral();
                        this.NextChar();
                        goto Label_0397;

                    case '[':
                        unknown = TokenID.LBracket;
                        this.NextChar();
                        goto Label_0397;

                    case ']':
                        unknown = TokenID.RBracket;
                        this.NextChar();
                        goto Label_0397;

                    case '_':
                        unknown = this.ScanKeywordOrIdentifier();
                        goto Label_0397;

                    case '{':
                        unknown = TokenID.LCurlyBrace;
                        this.NextChar();
                        goto Label_0397;

                    case '|':
                        unknown = TokenID.BitOr;
                        if (this.NextChar() == '|')
                        {
                            this.NextChar();
                            unknown = TokenID.Or;
                        }
                        goto Label_0397;

                    case '}':
                        unknown = TokenID.RCurlyBrace;
                        this.NextChar();
                        goto Label_0397;
                }
                this.NextChar();
                message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidCharacter, new object[] { ch });
                throw new RuleSyntaxException(0x17b, message, this.tokenStartPosition);
            }
        Label_0397:
            token = new Token(unknown, this.tokenStartPosition, this.tokenValue);
            this.currentToken = unknown;
            return token;
        }