private void AddToFlatFile(Attribute attribute, Namespace @namespace, @Class @class, NamespaceRecommendations recommendations)
{
var currentNamespace = EnsureNamespace(@namespace, recommendations);
RecommendedActions recommendation = new RecommendedActions()
{
Source = "Amazon",
Preferred = "Yes",
TargetFrameworks = targetFrameworks,
Description = GetDescription(attribute.Actions),
Actions = attribute.Actions
};
Recommendations r = new Recommendations()
{
Type = "Attribute",
Name = attribute.Key,
KeyType = "Name",
Value = attribute.FullKey,
ContainingType = @class.Key,
RecommendedActions = new List <RecommendedActions>()
{
recommendation
}
};
currentNamespace.Recommendations.Add(r);
}
private void AddToFlatFile(Namespace @namespace, NamespaceRecommendations recommendations)
{
var currentNamespace = EnsureNamespace(@namespace, recommendations);
if (@namespace.Actions != null && @namespace.Actions.Count > 0)
{
RecommendedActions recommendation = new RecommendedActions()
{
Source = "Amazon",
Preferred = "Yes",
TargetFrameworks = targetFrameworks,
Description = GetDescription(@namespace.Actions),
Actions = @namespace.Actions
};
Recommendations r = new Recommendations()
{
Type = "Namespace",
Name = @namespace.@namespace,
KeyType = "Name",
Value = @namespace.@namespace,
ContainingType = string.Empty,
RecommendedActions = new List <RecommendedActions>()
{
recommendation
}
};
currentNamespace.Recommendations.Add(r);
}
}
/// <summary>
/// Processes each rule object by creating tokens and associated actions
/// </summary>
/// <param name="rootobject">An object containing tokens and actions to run on these tokens</param>
private void ProcessObject(NamespaceRecommendations namespaceRecommendations)
{
var namespaces = namespaceRecommendations.NameSpaces;
foreach (var @namespace in namespaces)
{
foreach (var recommendation in @namespace.Recommendations)
{
RecommendedActions recommendedActions = recommendation.RecommendedActions
.Where(ra => ra.Preferred == "Yes" && ra.TargetFrameworks.Any(t => t.Name.Equals(_targetFramework))).FirstOrDefault();
//There are recommendations, but none of them are preferred
if (recommendedActions == null && recommendation.RecommendedActions.Count > 0)
{
LogHelper.LogError("No preferred recommendation set for recommendation {0} with target framework {1}", recommendation.Value, _targetFramework);
continue;
}
else if (recommendedActions != null)
{
if (recommendedActions.Actions != null && recommendedActions.Actions.Count > 0)
{
var targetCPUs = new List <string> {
"x86", "x64", "ARM64"
};
try
{
targetCPUs = recommendedActions.TargetFrameworks.FirstOrDefault(t => t.Name == _targetFramework)?.TargetCPU;
}
catch
{
LogHelper.LogError("Error parsing CPUs for target framework");
}
var recommendationType = Enum.Parse(typeof(ActionTypes), recommendation.Type);
switch (recommendationType)
{
case ActionTypes.Namespace:
{
var usingToken = new UsingDirectiveToken()
{
Key = recommendation.Value, Description = recommendedActions.Description, TargetCPU = targetCPUs
};
var namespaceToken = new NamespaceToken()
{
Key = recommendation.Value, Description = recommendedActions.Description, TargetCPU = targetCPUs
};
if (!_rootNodes.Usingdirectivetokens.Contains(usingToken))
{
_rootNodes.Usingdirectivetokens.Add(usingToken);
}
if (!_rootNodes.NamespaceTokens.Contains(namespaceToken))
{
_rootNodes.NamespaceTokens.Add(namespaceToken);
}
ParseActions(usingToken, recommendedActions.Actions);
ParseActions(namespaceToken, recommendedActions.Actions);
break;
}
case ActionTypes.Class:
{
if (recommendation.KeyType == CTA.Rules.Config.Constants.BaseClass || recommendation.KeyType == CTA.Rules.Config.Constants.ClassName)
{
var token = new ClassDeclarationToken()
{
Key = recommendation.Value, Description = recommendedActions.Description, TargetCPU = targetCPUs, FullKey = recommendation.Value, Namespace = @namespace.Name
};
if (!_rootNodes.Classdeclarationtokens.Contains(token))
{
_rootNodes.Classdeclarationtokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
}
else if (recommendation.KeyType == CTA.Rules.Config.Constants.Identifier)
{
var token = new IdentifierNameToken()
{
Key = recommendation.Value, Description = recommendedActions.Description, TargetCPU = targetCPUs, FullKey = recommendation.Value, Namespace = @namespace.Name
};
if (!_rootNodes.Identifiernametokens.Contains(token))
{
_rootNodes.Identifiernametokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
}
break;
}
case ActionTypes.Interface:
{
if (recommendation.KeyType == CTA.Rules.Config.Constants.BaseClass || recommendation.KeyType == CTA.Rules.Config.Constants.ClassName)
{
var token = new InterfaceDeclarationToken()
{
Key = recommendation.Value, Description = recommendedActions.Description, TargetCPU = targetCPUs, FullKey = recommendation.Value, Namespace = @namespace.Name
};
if (!_rootNodes.InterfaceDeclarationTokens.Contains(token))
{
_rootNodes.InterfaceDeclarationTokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
}
else if (recommendation.KeyType == CTA.Rules.Config.Constants.Identifier)
{
var token = new IdentifierNameToken()
{
Key = recommendation.Value, Description = recommendedActions.Description, TargetCPU = targetCPUs, FullKey = recommendation.Value, Namespace = @namespace.Name
};
if (!_rootNodes.Identifiernametokens.Contains(token))
{
_rootNodes.Identifiernametokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
}
break;
}
case ActionTypes.Method:
{
var token = new InvocationExpressionToken()
{
Key = recommendation.Name, Description = recommendedActions.Description, TargetCPU = targetCPUs, Namespace = @namespace.Name, FullKey = recommendation.Value, Type = recommendation.ContainingType
};
if (!_rootNodes.Invocationexpressiontokens.Contains(token))
{
_rootNodes.Invocationexpressiontokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
break;
}
case ActionTypes.Expression:
{
var token = new ExpressionToken()
{
Key = recommendation.Name, Description = recommendedActions.Description, TargetCPU = targetCPUs, Namespace = @namespace.Name, FullKey = recommendation.Value, Type = recommendation.ContainingType
};
if (!_rootNodes.Expressiontokens.Contains(token))
{
_rootNodes.Expressiontokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
break;
}
case ActionTypes.Attribute:
{
var token = new AttributeToken()
{
Key = recommendation.Name, Description = recommendedActions.Description, TargetCPU = targetCPUs, Namespace = @namespace.Name, FullKey = recommendation.Value, Type = recommendation.ContainingType
};
if (!_rootNodes.Attributetokens.Contains(token))
{
_rootNodes.Attributetokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
break;
}
case ActionTypes.ObjectCreation:
{
var token = new ObjectCreationExpressionToken()
{
Key = recommendation.Name, Description = recommendedActions.Description, TargetCPU = targetCPUs, Namespace = @namespace.Name, FullKey = recommendation.Value, Type = recommendation.ContainingType
};
if (!_rootNodes.ObjectCreationExpressionTokens.Contains(token))
{
_rootNodes.ObjectCreationExpressionTokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
break;
}
case ActionTypes.MethodDeclaration:
{
var token = new MethodDeclarationToken()
{
Key = recommendation.Name, Description = recommendedActions.Description, TargetCPU = targetCPUs, Namespace = @namespace.Name, FullKey = recommendation.Value, Type = recommendation.ContainingType
};
if (!_rootNodes.MethodDeclarationTokens.Contains(token))
{
_rootNodes.MethodDeclarationTokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
break;
}
case ActionTypes.ElementAccess:
{
var token = new ElementAccessToken()
{
Key = recommendation.Name, Description = recommendedActions.Description, TargetCPU = targetCPUs, Namespace = @namespace.Name, FullKey = recommendation.Value, Type = recommendation.ContainingType
};
if (!_rootNodes.ElementAccesstokens.Contains(token))
{
_rootNodes.ElementAccesstokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
break;
}
case ActionTypes.MemberAccess:
{
var token = new MemberAccessToken()
{
Key = recommendation.Name, Description = recommendedActions.Description, TargetCPU = targetCPUs, Namespace = @namespace.Name, FullKey = recommendation.Value, Type = recommendation.ContainingType
};
if (!_rootNodes.MemberAccesstokens.Contains(token))
{
_rootNodes.MemberAccesstokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
break;
}
case ActionTypes.Project:
{
var token = new ProjectToken()
{
Key = recommendation.Name, Description = recommendedActions.Description, TargetCPU = targetCPUs, Namespace = @namespace.Name, FullKey = recommendation.Value
};
if (!_rootNodes.ProjectTokens.Contains(token))
{
_rootNodes.ProjectTokens.Add(token);
}
ParseActions(token, recommendedActions.Actions);
break;
}
default:
break;
}
}
}
}
}
}
