public void Eat(TokenValues type)
{
if (this.currentToken.GetTokenValueType() == type)
{
this.currentToken = tokenizer.NextToken();
}
else
{
throw new InterpreterException($"Token type did not match, {type} expected, got {this.currentToken.GetTokenValueType()}");
}
}
private static string RecurseTokens(TokenValues vft, string?pwd)
{
if ((vft.OptionToken?.SourceToken ?? vft.ValueToken?.SourceToken) == null)
{
return(PrettifyTokens(vft, pwd));
}
return(vft.HasSourceToken
? $"{RecurseTokens(new TokenValues( vft.ValueToken?.SourceToken, vft.OptionToken?.SourceToken), pwd)}" +
$" -> {PrettifyTokens(vft, pwd)}"
: PrettifyTokens(vft, pwd));
}
public void Update(DestinyFactionDefinition?other)
{
if (other is null)
{
return;
}
if (!DisplayProperties.DeepEquals(other.DisplayProperties))
{
DisplayProperties.Update(other.DisplayProperties);
OnPropertyChanged(nameof(DisplayProperties));
}
if (ProgressionHash != other.ProgressionHash)
{
ProgressionHash = other.ProgressionHash;
OnPropertyChanged(nameof(ProgressionHash));
}
if (!TokenValues.DeepEqualsDictionaryNaive(other.TokenValues))
{
TokenValues = other.TokenValues;
OnPropertyChanged(nameof(TokenValues));
}
if (RewardItemHash != other.RewardItemHash)
{
RewardItemHash = other.RewardItemHash;
OnPropertyChanged(nameof(RewardItemHash));
}
if (RewardVendorHash != other.RewardVendorHash)
{
RewardVendorHash = other.RewardVendorHash;
OnPropertyChanged(nameof(RewardVendorHash));
}
if (!Vendors.DeepEqualsList(other.Vendors))
{
Vendors = other.Vendors;
OnPropertyChanged(nameof(Vendors));
}
if (Hash != other.Hash)
{
Hash = other.Hash;
OnPropertyChanged(nameof(Hash));
}
if (Index != other.Index)
{
Index = other.Index;
OnPropertyChanged(nameof(Index));
}
if (Redacted != other.Redacted)
{
Redacted = other.Redacted;
OnPropertyChanged(nameof(Redacted));
}
}
public bool DeepEquals(DestinyFactionDefinition?other)
{
return(other is not null &&
(DisplayProperties is not null ? DisplayProperties.DeepEquals(other.DisplayProperties) : other.DisplayProperties is null) &&
ProgressionHash == other.ProgressionHash &&
TokenValues.DeepEqualsDictionaryNaive(other.TokenValues) &&
RewardItemHash == other.RewardItemHash &&
RewardVendorHash == other.RewardVendorHash &&
Vendors.DeepEqualsList(other.Vendors) &&
Hash == other.Hash &&
Index == other.Index &&
Redacted == other.Redacted);
}
public bool DeepEquals(DestinyFactionDefinition other)
{
return(other != null &&
DisplayProperties.DeepEquals(other.DisplayProperties) &&
Progression.DeepEquals(other.Progression) &&
RewardItem.DeepEquals(other.RewardItem) &&
RewardVendor.DeepEquals(other.RewardVendor) &&
TokenValues.DeepEqualsReadOnlyDictionaryWithDefinitionKeyAndSimpleValue(other.TokenValues) &&
Vendors.DeepEqualsReadOnlyCollections(other.Vendors) &&
Blacklisted == other.Blacklisted &&
Hash == other.Hash &&
Index == other.Index &&
Redacted == other.Redacted);
}
public dynamic Expr()
{
VisitableNode result = Term();
HashSet <TokenValues> values = new HashSet <TokenValues>();
values.Add(TokenValues.PLUS);
values.Add(TokenValues.MINUS);
values.Add(TokenValues.EQUAL);
values.Add(TokenValues.LESSTHAN);
/*
* expr : Term ((PLUS|MINUS|EQUAL|LESSTHAN) Term) *
* Term : Factor ((MUL|DIV) Factor) *
* Factor : INTEGER | LPAREN expr RPAREN | Variable | STRING | TRUE | FALSE
*/
while (values.Contains(this.currentToken.GetTokenValueType()))
{
TokenValues type = this.currentToken.GetTokenValueType();
Token curr = this.currentToken;
switch (type)
{
case TokenValues.MINUS:
Eat(TokenValues.MINUS);
break;
case TokenValues.PLUS:
Eat(TokenValues.PLUS);
break;
case TokenValues.EQUAL:
Eat(TokenValues.EQUAL);
break;
case TokenValues.LESSTHAN:
Eat(TokenValues.LESSTHAN);
break;
default:
throw new InterpreterException("syntax error");
}
result = new BinOp(result, curr, this.Term());
}
return(result);
}
public bool Equals(DestinyFactionDefinition input)
{
if (input == null)
{
return(false);
}
return
((
DisplayProperties == input.DisplayProperties ||
(DisplayProperties != null && DisplayProperties.Equals(input.DisplayProperties))
) &&
(
ProgressionHash == input.ProgressionHash ||
(ProgressionHash.Equals(input.ProgressionHash))
) &&
(
TokenValues == input.TokenValues ||
(TokenValues != null && TokenValues.SequenceEqual(input.TokenValues))
) &&
(
RewardItemHash == input.RewardItemHash ||
(RewardItemHash.Equals(input.RewardItemHash))
) &&
(
RewardVendorHash == input.RewardVendorHash ||
(RewardVendorHash.Equals(input.RewardVendorHash))
) &&
(
Vendors == input.Vendors ||
(Vendors != null && Vendors.SequenceEqual(input.Vendors))
) &&
(
Hash == input.Hash ||
(Hash.Equals(input.Hash))
) &&
(
Index == input.Index ||
(Index.Equals(input.Index))
) &&
(
Redacted == input.Redacted ||
(Redacted != null && Redacted.Equals(input.Redacted))
));
}
public async Task <IHttpActionResult> SSOLogIn(string token)
{
string jsonValues = GetTokenValues(token);
TokenValues tokenValues = JsonConvert.DeserializeObject <TokenValues>(jsonValues);
var baseUrl = ConfigurationManager.AppSettings["BASE_URL"];
TimeSpan ts = DateTime.FromBinary(long.Parse(tokenValues.exp)).AddSeconds(60) - DateTime.Now.ToUniversalTime();
if (ts.TotalSeconds < 0)
{
return(Redirect(baseUrl));
}
var user = await _repo.SSOCRMLogIn(tokenValues.userName);
if (tokenValues.pageId == "salaries")
{
return(Redirect(baseUrl + "/#/meshartim/salaries/" + tokenValues.malshabId));
}
else
{
return(Redirect(baseUrl));
}
}
private static string PrettifyTokens(TokenValues vft, string?pwd)
{
return(vft.OptionToken?.RawValue == vft.ValueToken?.RawValue
? $"{vft.OptionToken?.RawValue}".Trim()
: $"{vft.OptionToken?.RawValue} {pwd ?? vft.ValueToken?.RawValue}".Trim());
}
public Token(TokenValues type, string value)
{
this.type = type;
this.value = value;
}
