/// <summary>
/// add new http header to request
/// </summary>
/// <param name="key">request key</param>
/// <param name="name">header name</param>
/// <param name="value">header value</param>
protected void AddCustomeHeaderToRequest(string key, string name, string value)
{
try {
var request = ProgramStorageQueries.GetRequest(key);
request.Headers.Add(name, VariableAnalysis.ExecuteVariableCommand(value) ?? value);
} catch (Exception e) {
CMD.ShowApplicationMessageToUser($"message : {e.Message}\nroute : {this.ToString()}", showType: ShowType.DANGER);
}
}
/// <summary>
/// Add http header to request
/// </summary>
/// <param name="key">request key</param>
/// <param name="headers">http web headers</param>
protected void AddHeaderToRequest(string key, string name, string value)
{
try {
var request = ProgramStorageQueries.GetRequest(key);
var prop = request.GetType().GetProperty(name);
prop.SetValue(request, VariableAnalysis.ExecuteVariableCommand(command: value) ?? value);
} catch (Exception e) {
CMD.ShowApplicationMessageToUser($"message : {e.Message}\nroute : {this.ToString()}", showType: ShowType.DANGER);
}
}
internal PSVariable TrySetVariable(string name, object value)
{
int num;
name = VariableAnalysis.GetUnaliasedVariableName(name);
if (this._nameToIndexMap.TryGetValue(name, out num))
{
this.SetValue(num, value);
return(new LocalVariable(name, this, num));
}
return(null);
}
internal bool TrySetParameter(string name, object value)
{
int num;
name = VariableAnalysis.GetUnaliasedVariableName(name);
if (this._nameToIndexMap.TryGetValue(name, out num))
{
this.SetValue(num, value);
return(true);
}
return(false);
}
/// <summary>
/// add cookie to request cookie container
/// </summary>
/// <param name="Key">request key</param>
/// <param name="name">cookie name</param>
/// <param name="value">cookie value</param>
/// <param name="path">cookie save path in server</param>
/// <param name="domain">cookie domain</param>
protected void AddNewCookie(string name, string value, string path, string domain, string Key = null)
{
try {
var request = ProgramStorageQueries.GetRequest(Key);
var cookie = new Cookie(name, VariableAnalysis.ExecuteVariableCommand(value) ?? value, path, domain);
var cookieContainer = ProgramStorageQueries.GetCookieContainer(ProgramStorageQueries.GetRequestKey(request));
cookieContainer.Add(cookie);
request.CookieContainer = cookieContainer;
} catch (Exception e) {
CMD.ShowApplicationMessageToUser($"message : {e.Message}\nroute : {this.ToString()}", showType: ShowType.DANGER);
}
}
internal bool TryGetLocalVariable(string name, bool fromNewOrSet, out PSVariable result)
{
int num;
name = VariableAnalysis.GetUnaliasedVariableName(name);
if (this._nameToIndexMap.TryGetValue(name, out num) && (fromNewOrSet || this.IsValueSet(num)))
{
result = new LocalVariable(name, this, num);
return(true);
}
result = null;
return(false);
}
/// <summary>
/// write data on request stream
/// </summary>
/// <param name="key">request key</param>
/// <param name="data">data for write</param>
protected void WriteData(string key, string data)
{
try {
var request = ProgramStorageQueries.GetRequest(key);
var stream = request.GetRequestStream();
byte[] bytes = Encoding.ASCII.GetBytes(VariableAnalysis.ExecuteVariableCommand(data) ?? data);
request.ContentLength = bytes.Length;
stream.Write(bytes, 0, bytes.Length);
stream.Close();
CMD.ShowApplicationMessageToUser($"{VariableAnalysis.ExecuteVariableCommand(data) ?? data} wited on request\nlentgh : {bytes.Length} content_legth set auto", showType: ShowType.SUCCESS);
} catch (Exception e) {
CMD.ShowApplicationMessageToUser($"message : {e.Message}\nroute : {this.ToString()}", showType: ShowType.DANGER);
}
}
/// <summary>
/// fetch data and value from web page
/// </summary>
/// <param name="key">response</param>
/// <param name="tag">Intended html element name</param>
/// <param name="attribute">Intended html attribute</param>
/// <param name="target">Intended target (attribute name)</param>
/// <param name="varCommand">The command to be processed to store the value</param>
protected void FetchValueFromHtmlPage(string key, string tag, string attribute, string target, string varCommand)
{
try
{
var stream = ProgramStorageQueries.GetResponseStream(key);
var data = GetDocument(stream);
var html = data.DocumentNode.SelectSingleNode($"//{tag}[@{attribute}]");
var result = html.Attributes[target].Value;
VariableAnalysis.ExecuteVariableCommand(varCommand, result);
}
catch (Exception e)
{
CMD.ShowApplicationMessageToUser($"message : {e.Message}\nroute : {this.ToString()}", showType: ShowType.DANGER);
}
}
/// <summary>
/// fetch header value from response headers
/// </summary>
/// <param name="name">header name</param>
/// <param name="key">response key</param>
/// <param name="varCommand">The command to be processed to store the value</param>
protected void FetchHeader(string name, string key, string varCommand)
{
try
{
var response = ProgramStorageQueries.GetResponse(key);
foreach (var item in response.Headers)
{
if (item.ToString() == name)
{
var val = response.Headers.GetValues(item.ToString())[0];
VariableAnalysis.ExecuteVariableCommand(varCommand, val);
}
}
}
catch (Exception e)
{
CMD.ShowApplicationMessageToUser($"message : {e.Message}\nroute : {this.ToString()}", showType: ShowType.DANGER);
}
}
internal bool Compile(bool optimized)
{
if (this._attributes == null)
{
this.InitializeMetadata();
}
if (optimized && (this.NameToIndexMap == null))
{
this.CompileOptimized();
}
optimized = optimized && !VariableAnalysis.AnyVariablesCouldBeAllScope(this.NameToIndexMap);
if (!optimized && !this._compiledUnoptimized)
{
this.CompileUnoptimized();
return(optimized);
}
if (optimized && !this._compiledOptimized)
{
this.CompileOptimized();
}
return(optimized);
}
public PSVariable(string name, object value, ScopedItemOptions options, Collection <Attribute> attributes)
{
this.name = string.Empty;
this.description = string.Empty;
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
this.name = name;
this.attributes = new PSVariableAttributeCollection(this);
this.SetValueRawImpl(value, true);
if (attributes != null)
{
foreach (Attribute attribute in attributes)
{
this.attributes.Add(attribute);
}
}
this.options = options;
if (this.IsAllScope)
{
VariableAnalysis.NoteAllScopeVariable(name);
}
}
/// <summary>
/// Used to analyze scriptbloct, functionmemberast or functiondefinitionast
/// </summary>
/// <param name="ast"></param>
/// <returns></returns>
public void AnalyzeImpl(Ast ast, VariableAnalysis outerAnalysis)
{
if (!(ast is ScriptBlockAst || ast is FunctionMemberAst || ast is FunctionDefinitionAst))
{
return;
}
_variables = FindAllVariablesVisitor.Visit(ast);
Init();
if (ast is FunctionMemberAst || ast is FunctionDefinitionAst)
{
IEnumerable<ParameterAst> parameters = FindParameters(ast, ast.GetType());
if (parameters != null)
{
ProcessParameters(parameters);
}
}
else
{
ScriptBlockAst sbAst = ast as ScriptBlockAst;
if (sbAst != null && sbAst.ParamBlock != null && sbAst.ParamBlock.Parameters != null)
{
ProcessParameters(sbAst.ParamBlock.Parameters);
}
}
if (ast is FunctionMemberAst)
{
(ast as FunctionMemberAst).Body.Visit(this.Decorator);
}
else if (ast is FunctionDefinitionAst)
{
(ast as FunctionDefinitionAst).Body.Visit(this.Decorator);
}
else
{
ast.Visit(this.Decorator);
}
Ast parent = ast;
while (parent.Parent != null)
{
parent = parent.Parent;
}
List<TypeDefinitionAst> classes = parent.FindAll(item =>
item is TypeDefinitionAst && (item as TypeDefinitionAst).IsClass, true)
.Cast<TypeDefinitionAst>().ToList();
if (outerAnalysis != null)
{
// Initialize the variables from outside
var outerDictionary = outerAnalysis.InternalVariablesDictionary;
foreach (var details in outerDictionary.Values)
{
if (details.DefinedBlock != null)
{
var assignTarget = new AssignmentTarget(details.RealName, details.Type);
assignTarget.Constant = details.Constant;
if (!_variables.ContainsKey(assignTarget.Name))
{
_variables.Add(assignTarget.Name, new VariableAnalysisDetails
{
Name = assignTarget.Name,
RealName = assignTarget.Name,
Type = assignTarget.Type
});
}
Entry.AddFirstAst(assignTarget);
}
}
foreach (var key in _variables.Keys)
{
if (outerDictionary.ContainsKey(key))
{
var outerItem = outerDictionary[key];
var innerItem = _variables[key];
innerItem.Constant = outerItem.Constant;
innerItem.Name = outerItem.Name;
innerItem.RealName = outerItem.RealName;
innerItem.Type = outerItem.Type;
}
}
}
var dictionaries = Block.SparseSimpleConstants(_variables, Entry, classes);
VariablesDictionary = dictionaries.Item1;
InternalVariablesDictionary = new Dictionary<string, VariableAnalysisDetails>(StringComparer.OrdinalIgnoreCase);
foreach (var KVP in dictionaries.Item2)
{
var analysis = KVP.Value;
if (analysis == null)
{
continue;
}
if (!InternalVariablesDictionary.ContainsKey(analysis.RealName))
{
InternalVariablesDictionary.Add(analysis.RealName, analysis);
}
else
{
InternalVariablesDictionary[analysis.RealName] = analysis;
}
}
}
/// <summary>
/// Updates the variablesdictionary of the outeranalysis based on that of the inneranalysis
/// </summary>
/// <param name="OuterAnalysis"></param>
/// <param name="InnerAnalysis"></param>
internal static void UpdateOuterAnalysis(VariableAnalysis OuterAnalysis, VariableAnalysis InnerAnalysis)
{
if (OuterAnalysis == null || InnerAnalysis == null)
{
return;
}
foreach (var key in InnerAnalysis.VariablesDictionary.Keys)
{
if (OuterAnalysis.VariablesDictionary.ContainsKey(key))
{
OuterAnalysis.VariablesDictionary[key] = InnerAnalysis.VariablesDictionary[key];
}
else
{
OuterAnalysis.VariablesDictionary.Add(key, InnerAnalysis.VariablesDictionary[key]);
}
}
}
