/// <summary>
/// Gets token and identifier tables from lexical analyzer.
/// </summary>
/// <param name="token">Token table.</param>
/// <param name="ident">Identifiers table.</param>
public SyntaxAnalyzer(TokenTable token, IdentifiersTable ident, LexicalAnalyzer lAnalyzer)
{
this.token = token;
this.ident = ident;
this.lAnalyzer = lAnalyzer;
count = this.token.tokensCount();
}
public TokenTableSet Generate()
{
var tableSet = new TokenTableSet();
var forwardTable = new TokenTable();
var reverseTable = new TokenTable();
var alphabet = string.IsNullOrWhiteSpace(_settings.CharacterString) ?
_settings.CharacterArray :
(_settings.CharacterString + (_settings.IncludeSpaces ? Characters.Space : string.Empty) + (_settings.IncludePunctuation ? Characters.Punctuation : string.Empty) + (_settings.IncludeSpecialCharacters ? Characters.SpecialCharacters : string.Empty)).ToCharArray().ToList();
if (alphabet.Count == 0)
{
throw new ArgumentException("A character set must be supplied.");
}
for (var i = 0; i < _settings.Size; i++)
{
GenerateRandomColumn(_settings.Size, alphabet, forwardTable, reverseTable);
}
tableSet.ForwardTable = forwardTable;
tableSet.ReverseTable = reverseTable;
return(tableSet);
}
public Analyser()
{
TokenTable.InitTable();
ConTable.InitTable();
IdnTable.InitTable();
OutputTokenTable.InitTable();
}
private void AddToIdnTable(ref string token, ref int i)
{
if (OutputTokenTable.Table.Count != 0 && Checker.IsType(OutputTokenTable.Table.Last().Name))
{
if (IdnTable.Contains(token))
{
throw new Exception($"Error on {i + 1} line!\tThe variable '{token}' is already declared.");
}
else
{
IdnTable.Add(token);
}
}
else if (OutputTokenTable.Table.Count != 0 && OutputTokenTable.Table.Last().Name == ",")
{
if (IdnTable.Contains(token))
{
throw new Exception($"Error on {i + 1} line!\tThe variable '{token}' is already declared.");
}
else
{
IdnTable.Add(token);
}
}
else if (!IdnTable.Contains(token) && !TokenTable.Contains(token))
{
throw new Exception($"Error on {i + 1} line!\tThe variable '{token}' wasn't declared.");
}
}
private int SetupColumnIndex(string source, TokenTable table, int seed)
{
int columnIndex = 0;
switch (_settings.Behaviour)
{
case Behaviour.Consistent:
columnIndex = 0;
break;
case Behaviour.LengthBasedInconsistent:
var maximum = table.Count - 1;
columnIndex = source.Length;
while (columnIndex > maximum)
{
columnIndex -= maximum;
}
break;
case Behaviour.RandomSeedInconsistent:
columnIndex = seed;
break;
}
return(columnIndex);
}
public async Task <long> CreateAsync(TokenTable entity)
{
string sql = @"INSERT INTO Token (Guid, CreatedOn, ExpiresOn, AccessToken, IdUser) " +
"VALUES (@Guid, @CreatedOn, @ExpiresOn, @AccessToken, @IdUser) " +
"SELECT CAST(SCOPE_IDENTITY() as bigint)";
return(await DbQuerySingleAsync <long>(sql, entity));
}
TokenTable.Token ExpectedOneOfTokens(string expected, params uint[] tokenCodes)
{
CheckUnexpectedEnd();
if (tokenCodes.All(tokenCode => GetTokenCode() != tokenCode))
{
throw new Exception($"Expected {expected} but found \"{TokenTable.GetLexemeName(GetTokenCode())}\" in line {tokenListNode.Value.Line}.");
}
var token = tokenListNode.Value;
TransitToNextToken();
return(token);
}
TokenTable.Token ExpectedToken(uint tokenCode)
{
CheckUnexpectedEnd();
if (GetTokenCode() != tokenCode)
{
throw new Exception($"Expected \"{TokenTable.GetLexemeName(tokenCode)}\" but found \"{TokenTable.GetLexemeName(GetTokenCode())}\" in line {tokenListNode.Value.Line}.");
}
var token = tokenListNode.Value;
TransitToNextToken();
return(token);
}
private void AddToInternalTable(ref string token, ref int i)
{
if (TokenTable.Contains(token) && Checker.IsType(token))
{
Checker.Type = token;
}
else if (Checker.IsDigit(token))
{
AddToConTable(ref token, ref i);
}
else if (!string.IsNullOrEmpty(token))
{
AddToIdnTable(ref token, ref i);
}
}
private CustomTree DeclarationStatement()
{
CustomTree node = new CustomTree("declaration");
//"int" | "float"
var token = ExpectedOneOfTokens("TypeSpecifier", (uint)TokenTable.Code.Int, 100);
node.AddChild(new CustomTree(TokenTable.GetLexemeName(token.Code)));
// identifier
token = ExpectedToken((uint)TokenTable.Code.Id);
node.AddChild(new CustomTree("identifier", token.ForeignId));
ExpectedToken((uint)TokenTable.Code.Semicolon); // ';'
return(node);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var table = new TokenTable();
var json = JObject.Load(reader);
foreach (JToken jsonColumn in json.SelectToken("columns"))
{
var column = new Dictionary <char, Tuple <char, int> >();
foreach (JToken jsonRow in jsonColumn.SelectToken("rows"))
{
column.Add(Convert.ToChar((int)jsonRow.SelectToken("f")), new Tuple <char, int>(Convert.ToChar((int)jsonRow.SelectToken("t")), (int)jsonRow.SelectToken("n")));
}
table.Add(column);
}
return(table);
}
public void GenerateRandomColumn(int size, List <char> characters, TokenTable forwardTable, TokenTable reverseTable)
{
var forwardColumn = new Dictionary <char, Tuple <char, int> >();
var reverseColumn = new Dictionary <char, Tuple <char, int> >();
var replacements = characters.ToList();
replacements.Shuffle();
for (var i = 0; i < characters.Count; i++)
{
var columnReference = ThreadSafeRandom.ThisThreadsRandom.Next(0, size - 1);
forwardColumn.Add(characters[i], new Tuple <char, int>(replacements[i], columnReference));
reverseColumn.Add(replacements[i], new Tuple <char, int>(characters[i], columnReference));
}
forwardTable.Add(forwardColumn);
reverseTable.Add(reverseColumn);
}
public async Task <AuthenticationToken> GenerateJWToken(string Login, string Password)
{
AuthenticationToken authenticationToken = null;
try
{
var user = await QueryUser(Login);
if (user != null)
{
if (EncryptPassword(Password).Equals(user.Password))
{
var tokenString = JWTTokenGenerator.GenerateToken(user, _appSettings);
TokenTable tokenTable = new TokenTable()
{
CreatedOn = DateTime.Now,
ExpiresOn = DateTime.Now.AddMinutes(30),
Guid = Guid.NewGuid().ToString().Trim(),
IdUser = user.Id,
AccessToken = tokenString
};
var id = await _tokenRepository.CreateAsync(tokenTable);
if (id > 0)
{
authenticationToken = new AuthenticationToken()
{
AccessToken = tokenString,
ExpiresOn = tokenTable.ExpiresOn
};
}
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(authenticationToken);
}
static void PrintSyntaxTree(TokenTable tokensTable, CustomTree node, int level = 0)
{
Console.Write($"{new string('\t', level)} {node.Name}");
if (node.Id != 0)
{
Console.Write(node.Name == "identifier"
? $"\"{tokensTable.IdentifiersTable[node.Id]}\""
: $"\"{tokensTable.LiteralsTable[node.Id]}\"");
Console.Write($" ({node.Id})");
}
Console.WriteLine();
if (node.GetChildren() == null)
{
return;
}
foreach (var child in node.GetChildren())
{
PrintSyntaxTree(tokensTable, child, level + 1);
}
}
static void Main(string[] args)
{
LexicalAnalyzer lexicalAnalyzer = new LexicalAnalyzer();
IdentifiersTable ident;
TokenTable table = lexicalAnalyzer.analyze("Input5.txt", out ident);
lexicalAnalyzer.printResults("Tokens.txt");
SyntaxAnalyzer syntaxAnalyzer = new SyntaxAnalyzer(table, ident, lexicalAnalyzer);
syntaxAnalyzer.analyze();
SyntaxTree tree = syntaxAnalyzer.getTree();
tree.printItselfToTheFile("Tree.txt");
SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(tree);
semanticAnalyzer.analyze();
Generator generator = new Generator();
generator.generateExe(tree);
Console.ReadLine();
}
public POLIZ(TokenTable tokenTable)
{
tokenListNode = tokenTable.TokensList.First;
}
public LexicalAnalyzer(string workPath)
{
tokens = new TokenTable();
words = new Dictionary <string, Token>();
reserve(ReserveWord.True);
reserve(ReserveWord.False);
reserve(ReserveWord.And);
reserve(ReserveWord.Eqv);
reserve(ReserveWord.LargeEq);
reserve(ReserveWord.LessEq);
reserve(ReserveWord.Minus);
reserve(ReserveWord.NEqv);
reserve(ReserveWord.Or);
reserve(new ReserveWord(Tag.DIM, "Dim"));
reserve(new ReserveWord(Tag.IF, "If"));
reserve(new ReserveWord(Tag.ELSE, "Else"));
reserve(new ReserveWord(Tag.ELSEIF, "ElseIf"));
reserve(new ReserveWord(Tag.THEN, "Then"));
reserve(new ReserveWord(Tag.END, "End"));
reserve(new ReserveWord(Tag.AS, "As"));
reserve(new ReserveWord(Tag.DO, "Do"));
reserve(new ReserveWord(Tag.BREAK, "Break"));
reserve(new ReserveWord(Tag.CONTINUE, "Continue"));
reserve(new ReserveWord(Tag.WHILE, "While"));
reserve(new ReserveWord(Tag.WEND, "Wend"));
reserve(new ReserveWord(Tag.FUNCTION, "Function"));
reserve(new ReserveWord(Tag.SUB, "Sub"));
reserve(new ReserveWord(Tag.RETURN, "Return"));
reserve(new ReserveWord(Tag.OPTIONAL, "Optional"));
reserve(new ReserveWord(Tag.CLASS, "Class"));
reserve(new ReserveWord(Tag.MODULE, "Module"));
reserve(new ReserveWord(Tag.STATIC, "Static"));
reserve(new ReserveWord(Tag.Split, ","));
reserve(new Operator(Tag.Equal, "=", Operators.Equal));
reserve(new Operator(Tag.Add, "+", Operators.Add));
reserve(new Operator(Tag.Sub, "-", Operators.Sub));
reserve(new Operator(Tag.Multi, "*", Operators.Mul));
reserve(new Operator(Tag.Div, "/", Operators.Div));
reserve(new Operator(Tag.Mod, "%", Operators.Mod));
reserve(new Operator(Tag.Less, "<", Operators.Less));
reserve(new Operator(Tag.Large, ">", Operators.Large));
reserve(ReserveType.Bool8);
reserve(ReserveType.Bool16);
reserve(ReserveType.Bool32);
reserve(ReserveType.Int8);
reserve(ReserveType.Int16);
reserve(ReserveType.Int32);
reserve(ReserveType.Int64);
reserve(ReserveType.UInt8);
reserve(ReserveType.UInt16);
reserve(ReserveType.UInt32);
reserve(ReserveType.UInt64);
reserve(ReserveType.Half);
reserve(ReserveType.Single);
reserve(ReserveType.Double);
reserve(ReserveType.IntPtr);
reserve(ReserveType.UIntPtr);
reserve(ReserveType.Char);
reserve(ReserveType.Byte);
reserve(ReserveType.Void);
}
TokenTable.Token ExpectLogicalOp()
{
CheckUnexpectedEnd();
if (!TokenTable.LogicOpCodes.Contains(GetTokenCode()))
{
throw new Exception($"Expected \"{String.Join(", ", TokenTable.LogicOpCodes)}\" but found \"{TokenTable.GetLexemeName(GetTokenCode())}\" in line {tokenListNode.Value.Line}.");
}
var token = tokenListNode.Value;
TransitToNextToken();
return(token);
}
public bool Parse(string[] programCode)
{
try
{
string token = string.Empty;
for (int i = 0; i < programCode.Length; i++)
{
int j = 0;
foreach (char ch in programCode[i])
{
if (ch.Equals('$'))
{
OutputTokenTable.Add(numRow: i, ch.ToString());
j++;
continue;
}
if (Checker.IsConstant(ch) ||
Checker.IsLetter(ch) ||
(Checker.IsSign(ch) && !string.IsNullOrEmpty(token) && Checker.IsExponent(token.Last())))
{
token += ch;
}
else if (Checker.IsSingleCharacterSeparator(ch) || Checker.IsWhiteSeparator(ch) || Checker.IsPossibleDoubleSeparator(ch))
{
AddToInternalTable(ref token, ref i);
if (ConTable.Contains(token) ||
IdnTable.Contains(token) ||
(TokenTable.Contains(token) && !Checker.IsDoubleSeparator(token + ch)))
{
OutputTokenTable.Add(numRow: i + 1, token);
token = string.Empty;
}
if (Checker.IsPossibleDoubleSeparator(ch))
{
if (!Checker.IsDoubleSeparator(token) &&
Checker.IsDoubleSeparator(ch.ToString()
+ ((programCode[i].Length - 1 != j) ? programCode[i][j + 1].ToString() : string.Empty)))
{
token += ch;
j++;
continue;
}
else
{
OutputTokenTable.Add(numRow: i + 1, token + ch);
token = string.Empty;
}
}
else if (Checker.IsSingleCharacterSeparator(ch))
{
OutputTokenTable.Add(numRow: i + 1, token + ch);
}
}
else
{
throw new Exception($"Error on {i + 1} line!\tUndefined exeption.");
}
j++;
}
}
return(true);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Alert", MessageBoxButton.OK);
return(false);
}
}
public Task <bool> UpdateAsync(TokenTable entity)
{
throw new NotImplementedException();
}
public static string OPStrat(JSONObj RECV) //Function that takes a JSONObj, and depending on its Type and Operation variables will preform a specific action with the data in the "JSON" string of the JSONObj.
{
string Result = "NoOp"; //Default return value.
Boolean MissionUpdate = false; //Decides if the preformed actions should update the users stat.
var JSONRECV = new JSONObj("", "", "", -1); //JSON object to used when preparing to call the OPStrat from inside itself.
Console.WriteLine(RECV.JSON);
if (RECV.Operation == "Execute") // If Operation is Execute, the database will execute the contents of JSONstring directly.
{
database.Execute(RECV.JSON);
}
else
{
switch (RECV.Type) //Decides what type of request the App wants to preform. Every Type has a Insert and a Query function for getting the data (Delete exists only for Types that can be removed by a user in the app)
{
case "Handshake": //Checks if the installed apps version matches with the server
Result = JsonConvert.SerializeObject(VersionNumber);
break;
case "User": // Operations related to the User.
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <UserTable>(RECV.JSON);
database.Insert(Statement);
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.UserQuery(RECV.JSON));
break;
}
else if (RECV.Operation == "Register") //Operation that from input data makes a new user for the App.
{
var Statement = JsonConvert.DeserializeObject <UserTable>(RECV.JSON);
Statement.Password = SHA256Hash(Statement.Password); //Password is stored Hashes without salt.
var Recur = JSONRecurs(JSONRECV, "User", "Query", "SELECT * FROM Users WHERE Username = '******'", -1);
Statement.MissionString = "Not Calculated"; // MissionString will be calculated on first login.
List <string> Categories = new List <string>();
List <string> Tags = new List <string>();
List <string> Authors = new List <string>();
List <List <string> > Taglist = new List <List <string> >();
Taglist.Add(Categories);
Taglist.Add(Tags);
Taglist.Add(Authors);
Statement.TaggString = JsonConvert.SerializeObject(Taglist);
if (JsonConvert.DeserializeObject <List <UserTable> >(Recur).Count == 0) // If the username already exists in the data base, return an "Error" otherwise insert the user.
{
JSONRecurs(JSONRECV, "User", "Insert", JsonConvert.SerializeObject(Statement), -1);
Result = "Operation Successful";
}
else
{
Result = "User Already Exists";
}
break;
}
else if (RECV.Operation == "ChangePassword") //Updates a users password.
{
var Password = JsonConvert.DeserializeObject <KeyValuePair <UserTable, string> >(RECV.JSON);
string Statement = "UPDATE Users SET Password = '******' WHERE ID = " + Password.Key.ID;
JSONRecurs(JSONRECV, "User", "Execute", Statement, RECV.UserID);
break;
}
else if (RECV.Operation == "UpdateInfo") // Updates a users personal info.
{
var Update = JsonConvert.DeserializeObject <UserTable>(RECV.JSON);
string Statement = "UPDATE Users SET Name = '" + Update.Name + "', Email = '" + Update.Email + "', City = '" + Update.City + "', Age = " + Update.Age + " WHERE ID = " + Update.ID;
JSONRecurs(JSONRECV, "User", "Execute", Statement, RECV.UserID);
break;
}
else if (RECV.Operation == "UpdateChoices") // Updates a users Taggstring.
{
var Recur = JSONRecurs(JSONRECV, "User", "Query", "SELECT * FROM Users WHERE ID = " + RECV.UserID, RECV.UserID);
var UserQ = JsonConvert.DeserializeObject <List <UserTable> >(Recur);
var Update = JsonConvert.DeserializeObject <UserTable>(RECV.JSON);
if (UserQ.Count == 1)
{
if (UserQ.First().TaggString.Length < Update.TaggString.Length)
{
database.Stats("SubjectAdded", RECV.UserID);
}
else if (UserQ.First().TaggString.Length > Update.TaggString.Length)
{
database.Stats("SubjectRemoved", RECV.UserID);
}
}
string Statement = "UPDATE Users SET TaggString ='" + Update.TaggString + "' WHERE ID = " + Update.ID;
JSONRecurs(JSONRECV, "User", "Execute", Statement, RECV.UserID);
break;
}
else if (RECV.Operation == "UpdateTutorial") //Updates a users tutorial progress
{
var Update = JsonConvert.DeserializeObject <UserTable>(RECV.JSON);
string Statement = "UPDATE Users SET TutorialProgress ='" + Update.TutorialProgress + "' WHERE ID = " + Update.ID;
JSONRecurs(JSONRECV, "User", "Execute", Statement, RECV.UserID);
break;
}
else if (RECV.Operation == "UpdateItems") // Updates a users inventory of shop items or current avatar.
{
var Recur = JSONRecurs(JSONRECV, "User", "Query", "SELECT * FROM Users WHERE ID = " + RECV.UserID, RECV.UserID);
var UserQ = JsonConvert.DeserializeObject <List <UserTable> >(Recur);
var Update = JsonConvert.DeserializeObject <UserTable>(RECV.JSON);
if (UserQ.Count == 1)
{
if (Update.Avatar != UserQ.First().Avatar)
{
database.Stats("AvatarChanged", RECV.UserID);
}
else if (Update.Style != UserQ.First().Style)
{
database.Stats("StylesChanged", RECV.UserID);
}
else if (Update.Inventory != UserQ.First().Inventory)
{
var Inventory = JsonConvert.DeserializeObject <List <int> >(Update.Inventory);
if (20 < Inventory.Last() && Inventory.Last() < 46)
{
database.Stats("BoughtStyles", RECV.UserID);
}
else
{
database.Stats("BoughtItems", RECV.UserID);
}
}
}
string Statement = "UPDATE Users SET Inventory ='" + Update.Inventory + "', Avatar = '" + Update.Avatar + "', Style = '" + Update.Style + "' WHERE ID = " + Update.ID;
JSONRecurs(JSONRECV, "User", "Execute", Statement, RECV.UserID);
break;
}
else if (RECV.Operation == "Plustoken") // Grants or removes Plustokens from a user.
{
var User = JsonConvert.DeserializeObject <KeyValuePair <UserTable, int> >(RECV.JSON);
if (User.Key.Plustokens + User.Value >= 0)
{
string Statement = "UPDATE Users SET Plustokens = " + (User.Key.Plustokens + User.Value) + " WHERE ID = " + User.Key.ID;
JSONRecurs(JSONRECV, "User", "Execute", Statement, RECV.UserID);
if (User.Value > 0)
{
for (int i = 0; i < User.Value; i++)
{
database.Stats("TokensCollected", RECV.UserID);
}
}
else if (User.Value < 0)
{
for (int i = 0; i > User.Value; i--)
{
database.Stats("CoinsSpent", RECV.UserID);
}
}
Result = JsonConvert.SerializeObject(true);
}
else
{
if (User.Key.Plustokens < 0)
{
string Statement = "UPDATE Users SET Plustokens = '0' WHERE ID = " + User.Key.ID;
JSONRecurs(JSONRECV, "User", "Execute", Statement, RECV.UserID);
}
Result = JsonConvert.SerializeObject(false);
}
break;
}
else if (RECV.Operation == "Mission") // Evalutes the Users progress on their missions.
{
database.Mission("Evaluate", RECV.UserID);
MissionUpdate = true;
break;
}
break;
case "Comments": // Operations realated to comments.
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <CommentTable>(RECV.JSON);
database.Insert(Statement);
database.Stats("CommentsPosted", RECV.UserID);
MissionUpdate = true;
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.CommentQuery(RECV.JSON));
break;
}
else if (RECV.Operation == "Point") // Modifies the point value of a comment.
{
var Comment = JsonConvert.DeserializeObject <KeyValuePair <CommentTable, int> >(RECV.JSON);
string Statement = "UPDATE Comments SET Point = " + (Comment.Key.Point + Comment.Value) + " WHERE ID = " + Comment.Key.ID;
JSONRecurs(JSONRECV, "User", "Execute", Statement, RECV.UserID);
Result = JsonConvert.SerializeObject(true);
break;
}
break;
case "Token": // Operations related to logins and UserTokens
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <TokenTable>(RECV.JSON);
database.Insert(Statement);
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.TokenQuery(RECV.JSON));
break;
}
else if (RECV.Operation == "Delete")
{
var Statement = JsonConvert.DeserializeObject <TokenTable>(RECV.JSON);
database.Delete(Statement);
break;
}
else if (RECV.Operation == "Login") // When the user logs in to the app.
{
var Statement = JsonConvert.DeserializeObject <UserTable>(RECV.JSON);
Statement.Password = SHA256Hash(Statement.Password);
var UpperPassword = Statement.Password.ToUpper();
var Recur = JSONRecurs(JSONRECV, "User", "Query", "SELECT * FROM Users WHERE (Username = '******' OR Email = '" + Statement.Email + "') AND (Password = '******' OR Password = '******')", RECV.UserID);
var UserQ = JsonConvert.DeserializeObject <List <UserTable> >(Recur);
if (UserQ.Count == 1) //Compares the inputed password value after it is Hashed, if it matches a Token will be generated.
{
var Tokenstring = Tokengen();
Recur = JSONRecurs(JSONRECV, "Token", "Query", "SELECT * FROM Tokens WHERE User = '******'", RECV.UserID);
if (JsonConvert.DeserializeObject <List <TokenTable> >(Recur).Count > 0) // Removes tokens from the same user if they were already logged in on another device.
{
JSONRecurs(JSONRECV, "Token", "Delete", JsonConvert.SerializeObject(JsonConvert.DeserializeObject <List <TokenTable> >(Recur).First()), RECV.UserID);
}
var Token = new TokenTable();
Token.Token = Tokenstring;
Token.User = UserQ.First().ID;
Token.LastUse = DateTime.Now.ToString();
Console.WriteLine("Tokenstring: " + Token.Token);
JSONRecurs(JSONRECV, "Token", "Insert", JsonConvert.SerializeObject(Token), RECV.UserID);
var Returntoken = JSONRecurs(JSONRECV, "Token", "Query", "SELECT * FROM Tokens WHERE Token = '" + Tokenstring + "'", RECV.UserID);
Result = Returntoken;
if (UserQ.First().MissionString == "Not Calculated") //Calculates Stats and mission string if it is the users first time login in.
{
database.Mission("Reset", UserQ.First().ID);
var Stats = new StatsTable();
Stats.User = UserQ.First().ID;
Stats.Logins = 0;
Stats.UseTime = 0;
Stats.ArticlesRead = 0;
Stats.PlusArticlesUnlocked = 0;
Stats.InsandareSubmitted = 0;
Stats.InsandareRead = 0;
Stats.GameFinished = 0;
Stats.QuestionSubmitted = 0;
Stats.QuestionAnswered = 0;
Stats.VoteQuestionSubmitted = 0;
Stats.VoteSubmitted = 0;
Stats.CommentsPosted = 0;
Stats.TokensCollected = 0;
Stats.StylesChanged = 0;
Stats.AvatarChanged = 0;
Stats.BoughtItems = 0;
Stats.BoughtStyles = 0;
Stats.CoinsSpent = 0;
Stats.ArticlesClicked = 0;
Stats.SubjectClicked = 0;
Stats.SubjectAdded = 0;
Stats.SubjectRemoved = 0;
Stats.GenericStat1 = 0;
Stats.GenericStat2 = 0;
Stats.GenericStat3 = 0;
Stats.GenericStat4 = 0;
Stats.GenericStat5 = 0;
JSONRecurs(JSONRECV, "Stats", "Insert", JsonConvert.SerializeObject(Stats), UserQ.First().ID);
}
database.Stats("Logins", UserQ.First().ID);
if (UserQ.First().DailyLogin == 0) //Updates the Users login streak.
{
int Streak = UserQ.First().LoginStreak + 1;
int Tokens = Streak + UserQ.First().Plustokens;
if (UserQ.First().LoginStreak == 7)
{
Streak = 0;
}
Recur = "UPDATE Users SET DailyLogin = '******', LoginStreak = '" + Streak + "', Plustokens = '" + Tokens + "' WHERE ID = " + UserQ.First().ID;
JSONRecurs(JSONRECV, "User", "Execute", Recur, RECV.UserID);
}
}
else
{
Result = null;
}
break;
}
else if (RECV.Operation == "Logout") // When the User Logs out of the app
{
var Statement = JsonConvert.DeserializeObject <TokenTable>(RECV.JSON);
if (JsonConvert.DeserializeObject <Boolean>(JSONRecurs(JSONRECV, "Token", "TokenCheck", JsonConvert.SerializeObject(Statement), RECV.UserID)))
{
JSONRecurs(JSONRECV, "Token", "Delete", JsonConvert.SerializeObject(Statement), RECV.UserID);
}
break;
}
else if (RECV.Operation == "TokenCheck") //Checks if a sent in token matches on in the database
{
var Statement = JsonConvert.DeserializeObject <TokenTable>(RECV.JSON);
Console.WriteLine("Encrypted sent in token: " + Statement.Token);
var ServerToken = JsonConvert.DeserializeObject <List <TokenTable> >(JSONRecurs(JSONRECV, "Token", "Query", "SELECT * FROM Tokens WHERE User = '******'", RECV.UserID));
Console.WriteLine("Servertoken: " + ServerToken);
Console.WriteLine("Sent in User ID: " + Statement.User);
if (ServerToken.Any())
{
var HashToken = SHA256Hash(ServerToken.First().Token + Statement.User);
Console.WriteLine("Encrypted Servertoken: " + HashToken);
if (HashToken == Statement.Token)
{
JSONRecurs(JSONRECV, "Token", "Execute", "UPDATE Tokens SET LastUse = '" + DateTime.Now.ToString() + "' WHERE Token = '" + ServerToken.First().Token + "'", RECV.UserID);
Result = JsonConvert.SerializeObject(true);
}
else
{
Result = JsonConvert.SerializeObject(false);
}
}
else
{
Result = JsonConvert.SerializeObject(false);
}
JSONRecurs(JSONRECV, "Token", "TokenCleanup", "", RECV.UserID);
break;
}
else if (RECV.Operation == "TokenCleanup") //Removes tokens that are 1 hour old.
{
var ServerToken = JsonConvert.DeserializeObject <List <TokenTable> >(JSONRecurs(JSONRECV, "Token", "Query", "SELECT * FROM Tokens", RECV.UserID));
if (ServerToken.Any())
{
foreach (TokenTable T in ServerToken)
{
if (DateTime.Parse(T.LastUse).Add(new TimeSpan(1, 0, 0)) < DateTime.Now)
{
JSONRecurs(JSONRECV, "Token", "Delete", JsonConvert.SerializeObject(T), RECV.UserID);
}
}
}
}
break;
case "RSS": //Operations to fetch the raw data of an article (A RSSTable)
if (RECV.Operation == "Insert")
{
//Not used
break;
}
else if (RECV.Operation == "Query")
{
database.Stats("ArticlesClicked", RECV.UserID);
Result = JsonConvert.SerializeObject(database.RSSQuery(RECV.JSON));
break;
}
break;
case "Plus": //Operationer related to Plus articles.
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <PlusRSSTable>(RECV.JSON);
database.Insert(Statement);
database.Stats("PlusArticlesUnlocked", RECV.UserID);
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.PlusQuery(RECV.JSON));
break;
}
else if (RECV.Operation == "PlusCheck") // Checks if a user has access to a plus article or not.
{
var Statement = JsonConvert.DeserializeObject <PlusRSSTable>(RECV.JSON);
var Query = JsonConvert.DeserializeObject <List <PlusRSSTable> >(JSONRecurs(JSONRECV, "Plus", "Query", "SELECT * FROM Plus WHERE Article = " + Statement.Article + " AND User = "******"UserRSS": //User submitted article operations
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <UserRSSTable>(RECV.JSON);
database.Insert(Statement);
database.Stats("InsandareSubmitted", RECV.UserID);
MissionUpdate = true;
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.UserRSSQuery(RECV.JSON));
break;
}
break;
case "Sudoku": //Sudoku related Operations.
if (RECV.Operation == "Insert")
{
//Not used
break;
}
else if (RECV.Operation == "Query")
{
var Tid = DateTime.Now.DayOfWeek;
Result = JsonConvert.SerializeObject(database.SudokuQuery(RECV.JSON));
break;
}
break;
case "Stats": //User stat related Operations
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <StatsTable>(RECV.JSON);
database.Insert(Statement);
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.StatsQuery(RECV.JSON));
break;
}
else if (RECV.Operation == "Update")
{
database.Stats(RECV.JSON, RECV.UserID);
MissionUpdate = true;
break;
}
break;
case "Quiz": //Quiz Related Operations
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <QuizTable>(RECV.JSON);
database.Insert(Statement);
database.Stats("QuestionSubmitted", RECV.UserID);
MissionUpdate = true;
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.QuizQuery(RECV.JSON));
break;
}
else if (RECV.Operation == "GetQuestion")
{
break;
}
break;
case "Favorite": //User Favorite Related Operations
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <FavoritesTable>(RECV.JSON);
database.Insert(Statement);
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.FavoriteQuery(RECV.JSON));
break;
}
else if (RECV.Operation == "Delete")
{
var Statement = JsonConvert.DeserializeObject <FavoritesTable>(RECV.JSON);
database.Delete(Statement);
break;
}
break;
case "History": //UserHistory Related Operations
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <HistoryTable>(RECV.JSON);
database.Insert(Statement);
database.Stats("ArticlesRead", RECV.UserID);
MissionUpdate = true;
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.HistoryQuery(RECV.JSON));
break;
}
break;
case "Newsfeed": // Newsfeed Related Operation
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <NewsfeedTable>(RECV.JSON);
database.Insert(Statement);
break;
}
else if (RECV.Operation == "Query")
{
if (RECV.JSON.Contains("Tag LIKE") && RECV.JSON.Contains(" - 20"))
{
database.Stats("SubjectClicked", RECV.UserID);
}
Result = JsonConvert.SerializeObject(database.NewsfeedQuery(RECV.JSON));
break;
}
break;
case "VoteQuestion": // Timed Poll related Operations.
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <VoteQuestionTable>(RECV.JSON);
database.Insert(Statement);
database.Stats("VoteQuestionSubmitted", RECV.UserID);
MissionUpdate = true;
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.VoteQuestionQuery(RECV.JSON));
break;
}
break;
case "Vote": // Timed Poll vote data realted Operations
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <VoteTable>(RECV.JSON);
database.Insert(Statement);
database.Stats("VoteSubmitted", RECV.UserID);
MissionUpdate = true;
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.VoteQuery(RECV.JSON));
break;
}
else if (RECV.Operation == "Purge")
{
var Statement = JsonConvert.DeserializeObject <int>(RECV.JSON);
JSONRecurs(JSONRECV, "User", "Execute", "DELETE FROM Votes WHERE Question = " + Statement + "'", RECV.UserID);
break;
}
break;
case "Picross": // Picross related operations
if (RECV.Operation == "Insert")
{
//Not Used
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.PicrossQuery(RECV.JSON));
break;
}
break;
case "Reaction": //Reaction related operations
if (RECV.Operation == "Insert")
{
var Statement = JsonConvert.DeserializeObject <ReactionTable>(RECV.JSON);
database.Insert(Statement);
var Recur = JSONRecurs(JSONRECV, "Newsfeed", "Query", "SELECT * FROM Newsfeed WHERE ID = " + Statement.Article, RECV.UserID);
var NFQ = JsonConvert.DeserializeObject <List <NewsfeedTable> >(Recur).First();
var ReactionList = JsonConvert.DeserializeObject <List <ReactionTable> >(NFQ.ReactionSum);
ReactionList.Add(Statement);
var RLS = JsonConvert.SerializeObject(ReactionList);
string RecState = "UPDATE Newsfeed SET ReactionSum ='" + RLS + "' WHERE ID = " + NFQ.ID;
JSONRecurs(JSONRECV, "User", "Execute", RecState, RECV.UserID);
break;
}
else if (RECV.Operation == "Query")
{
Result = JsonConvert.SerializeObject(database.ReactionQuery(RECV.JSON));
break;
}
else if (RECV.Operation == "Delete")
{
var Statement = JsonConvert.DeserializeObject <ReactionTable>(RECV.JSON);
database.Delete(Statement);
break;
}
break;
}
}
if (MissionUpdate) //If a operation updates the missions string, we return it to the client.
{
Result = database.GetMissionString(RECV.UserID);
}
return(Result);
}
private void cbLangCompare_SelectedIndexChanged(object sender, EventArgs e)
{
this.lvAnalyzeCharsetResult.BeginUpdate();
this.lvAnalyzeCharsetResult.Items.Clear();
this.lvAnalyzeNGramsResult.BeginUpdate();
this.lvAnalyzeNGramsResult.Items.Clear();
this.lvAnalyzeWordResult.BeginUpdate();
this.lvAnalyzeWordResult.Items.Clear();
if (this.cbLangCompare.SelectedIndex != -1)
{
TokenTable testTable = new TokenTable(this.tbSource.Text);
ITokenTable compareTable = this.m_Model[((CultureInfo)cbLangCompare.SelectedItem).TwoLetterISOLanguageName];
List <TokenStats> scores = new List <TokenStats>();
int score = compareTable.Count * testTable.Count;
foreach (ITokenStats test in testTable.Values)
{
TokenStats newScore = new TokenStats(test.Token);
int otherRank = compareTable.RankOf(test.Token);
if (otherRank == -1)
{
newScore.Occurences = compareTable.Count;
score -= compareTable.Count;
}
else
{
int val = System.Math.Abs(test.Rank - otherRank);
newScore.Occurences = val;
// abuse the ran field to store the occurences...
newScore.Rank = test.Occurences;
score -= val;
scores.Add(newScore);
}
}
tbSumTokens.Text = score.ToString();
scores.Sort();
for (int i = scores.Count - 1; i > -1; i--)
{
TokenStats stats = scores[i];
ListViewItem item = new ListViewItem(stats.Token);
item.SubItems.Add(stats.Occurences.ToString());
item.SubItems.Add(stats.Rank.ToString());
lvAnalyzeNGramsResult.Items.Add(item);
}
scores = new List <TokenStats>();
score = compareTable.WordTable.Count * testTable.WordTable.Count;
foreach (ITokenStats test in testTable.WordTable.Values)
{
TokenStats newScore = new TokenStats(test.Token);
int otherRank = compareTable.WordTable.RankOf(test.Token);
if (otherRank == -1)
{
newScore.Occurences = compareTable.Ranks;
}
else
{
int val = System.Math.Abs(test.Rank - otherRank);
newScore.Occurences = val;
newScore.Rank = test.Occurences;
score -= val;
scores.Add(newScore);
}
}
int hits = 0;
Double wsScore = compareTable.WordComparisonScore(testTable, 0, ref hits);
tbSumWords.Text = wsScore.ToString("0.00") + " (" + hits + ")";
scores.Sort();
for (int i = scores.Count - 1; i > -1; i--)
{
TokenStats stats = scores[i];
ListViewItem item = new ListViewItem(stats.Token);
item.SubItems.Add(stats.Occurences.ToString());
item.SubItems.Add(stats.Rank.ToString());
lvAnalyzeWordResult.Items.Add(item);
}
scores = new List <TokenStats>();
score = compareTable.CharsetTable.Count * testTable.CharsetTable.Count;
foreach (ITokenStats test in testTable.CharsetTable.Values)
{
TokenStats newScore = new TokenStats(test.Token);
int otherRank = compareTable.CharsetTable.RankOf(test.Token);
if (otherRank == -1)
{
newScore.Occurences = compareTable.Ranks;
}
else
{
int val = System.Math.Abs(test.Rank - otherRank);
newScore.Occurences = val;
newScore.Rank = test.Occurences;
score -= val;
scores.Add(newScore);
}
}
textBox1.Text = score.ToString();
scores.Sort();
for (int i = scores.Count - 1; i > -1; i--)
{
TokenStats stats = scores[i];
ListViewItem item = new ListViewItem(stats.Token);
item.SubItems.Add(stats.Occurences.ToString());
item.SubItems.Add(stats.Rank.ToString());
lvAnalyzeCharsetResult.Items.Add(item);
}
}
this.lvAnalyzeNGramsResult.EndUpdate();
this.lvAnalyzeWordResult.EndUpdate();
this.lvAnalyzeCharsetResult.EndUpdate();
}
private BasicResult Encode(string source, TokenTable table, int seed)
{
if (string.IsNullOrEmpty(source))
{
return(new BasicResult {
Value = string.Empty, PercentReplaced = -1, AllTextReplaced = false
});
}
var hasMask = SetupMask(source);
var result = new StringBuilder();
var columnIndex = SetupColumnIndex(source, table, seed);
var replacedCount = 0;
for (var i = 0; i < source.Length; i++)
{
if (table[columnIndex].ContainsKey(source[i]))
{
if (hasMask && _settings.Mask.Items[i].MaskType != MaskType.ReplaceAny)
{
var maskItem = _settings.Mask.Items[i];
if (maskItem.MaskType == MaskType.KeepAnyOriginal)
{
result.Append(source[i]);
}
if (maskItem.MaskType == MaskType.MustMatchAndKeep)
{
CheckMaskMatch(source, result, i, maskItem);
}
}
else
{
var newCharacter = table[columnIndex][source[i]];
result.Append(newCharacter.Item1);
columnIndex = newCharacter.Item2;
replacedCount++;
}
}
else
{
if (hasMask && _settings.Mask.Items[i].MaskType == MaskType.MustMatchAndKeep)
{
var maskItem = _settings.Mask.Items[i];
CheckMaskMatch(source, result, i, maskItem);
}
else
{
result.Append(source[i]);
}
}
}
var percentReplaced = ((double)replacedCount / source.Length) * 100;
return(new BasicResult {
Value = result.ToString(), AllTextReplaced = percentReplaced == 100, PercentReplaced = percentReplaced
});
}
