public IValue FindProcessById(int PID)
{
System.Diagnostics.Process process;
try
{
process = System.Diagnostics.Process.GetProcessById(PID);
}
catch (ArgumentException)
{
return(ValueFactory.Create());
}
return(ValueFactory.Create(new ProcessContext(process)));
}
public IValue GetEnvironmentVariable(string varName, EnvironmentVariableTargetEnum target = EnvironmentVariableTargetEnum.Process)
{
EnvironmentVariableTarget targetParam = GetSystemEnvVariableTarget(target);
string value = System.Environment.GetEnvironmentVariable(varName, targetParam);
if (value == null)
{
return(ValueFactory.Create());
}
else
{
return(ValueFactory.Create(value));
}
}
public void Delete(IValue Element)
{
//TODO: Сделал топорно, надо придумать как правильно
string ElName = ((FormField)Element).Name;
_elements.Remove(ElName);
Control CurControl = ((FormField)Element).getBaseControl();
CurControl.Controls.Clear();
CurControl.Dispose();
CurControl = null;
//TODO: А нужно ли очищать входящий IValue Element, если да - то как?
Element = ValueFactory.Create();
}
public IValue GetBodyAsBinaryData()
{
if (_body == null)
{
return(ValueFactory.Create());
}
using (var stream = _body.OpenReadStream())
{
var data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
return(new BinaryDataContext(data));
}
}
public IValue GetEnvironmentVariable(string varName)
{
SystemLogger.Write("WARNING! Deprecated method: 'SystemInfo.GetEnvironmentVariable' is deprecated, use 'GetEnvironmentVariable' from global context");
string value = System.Environment.GetEnvironmentVariable(varName);
if (value == null)
{
return(ValueFactory.Create());
}
else
{
return(ValueFactory.Create(value));
}
}
public static IValue Constructor(IValue[] parameters)
{
// path, encoding, lineDelimiter,eolDelimiter, monopoly
var reader = new ScriptTextReader();
if (parameters.Length == 0)
{
reader.AnalyzeDefaultLineFeed = false;
return(reader);
}
if (parameters.Length == 1)
{
reader.AnalyzeDefaultLineFeed = false;
reader.Open(parameters[0].AsString(), null, "\n", "\r\n");
return(reader);
}
var encoding = ValueFactory.Create();
var lineDelimiter = "\n";
var eolDelimiter = "";
var monopoly = false;
if (parameters.Length > 1)
{
encoding = parameters[1];
}
if (parameters.Length > 2)
{
lineDelimiter = parameters[2].AsString();
}
if (parameters.Length > 3)
{
eolDelimiter = parameters[3].AsString();
}
if (parameters.Length > 4)
{
monopoly = parameters[4].AsBoolean();
}
if (lineDelimiter != string.Empty)
{
reader.AnalyzeDefaultLineFeed = false;
}
reader.Open(parameters[0].AsString(), encoding, lineDelimiter, eolDelimiter, monopoly);
return(reader);
}
public static IValue ConvertReturnValue <TRet>(TRet param)
{
var type = typeof(TRet);
object objParam = (object)param;
if (type == typeof(IValue))
{
return((IValue)param);
}
else if (type == typeof(string))
{
return(ValueFactory.Create((string)objParam));
}
else if (type == typeof(int))
{
return(ValueFactory.Create((int)objParam));
}
else if (type == typeof(decimal))
{
return(ValueFactory.Create((decimal)objParam));
}
else if (type == typeof(double))
{
return(ValueFactory.Create((decimal)(double)objParam));
}
else if (type == typeof(DateTime))
{
return(ValueFactory.Create((DateTime)objParam));
}
else if (type == typeof(bool))
{
return(ValueFactory.Create((bool)objParam));
}
else if (typeof(IRuntimeContextInstance).IsAssignableFrom(type))
{
if (objParam != null)
{
return(ValueFactory.Create((IRuntimeContextInstance)objParam));
}
else
{
return(ValueFactory.Create());
}
}
else
{
throw new NotSupportedException("Type is not supported");
}
}
protected override void AddNode(INode node, bool named, Action <INode> modify)
{
const string supported = "generic lists and generic enumerable interfaces";
if (!SpecifiedType.IsGenericEnumerable)
{
throw new TypeNotSupportedException(
"non generic {0}".ToFormat(SpecifiedType.IsList ? "list" : "enumerable"),
SpecifiedType, Mode.Deserialize, supported);
}
if (_itemType.CanBeCastTo <INode>())
{
if (_itemType.Is <INode>() || _itemType.IsTypeOf(node))
{
_list.Value.Add(node);
}
}
else
{
if (Context.Options.TypeFilter.WhenNot(_itemType, Context.Options))
{
return;
}
if (!ActualType.IsList)
{
throw new TypeNotSupportedException(
"enumerable", ActualType, Mode.Deserialize, supported);
}
if (named)
{
var itemName = GetItemName(_itemType);
if (!node.Name.Equals(itemName, Context.Options.Deserialization.NameComparison))
{
if (Context.Options.Deserialization.IgnoreUnmatchedArrayItems)
{
return;
}
if (!Context.Options.Deserialization.IgnoreArrayItemNames)
{
throw new InvalidItemNameDeserializationException(node.Name, itemName);
}
}
}
var value = ValueFactory.Create(_itemType);
NodeFactory.CreateDeserializable(named ? Name : null, value, this, Context).Configure(modify);
_list.Value.Add(value.Instance);
}
}
public IValue Consume(int WaitTime = 1000)
{
var consumer = consumerAsync;
while (true)
{
try
{
var consumeResult = consumer.Consume(WaitTime);
if (consumeResult != null)
{
if (consumeResult.IsPartitionEOF)
{
Console.WriteLine($"Reached end of topic {consumeResult.Topic}, partition {consumeResult.Partition}, offset {consumeResult.Offset}.");
return(ValueFactory.Create());
}
var obj = new MapImpl();
latestOffset = obj;
obj.Insert(
ValueFactory.Create("Канал"), ValueFactory.Create(
consumeResult.TopicPartitionOffset.Topic
)
);
obj.Insert(
ValueFactory.Create("Раздел"), ValueFactory.Create(
consumeResult.TopicPartitionOffset.Partition
)
);
obj.Insert(
ValueFactory.Create("Смещение"), ValueFactory.Create(
consumeResult.TopicPartitionOffset.Offset
)
);
return(ValueFactory.Create(consumeResult.Message.Value));
}
} catch (ConsumeException e)
{
throw new Exception(
$"Error occured: {e.Error.Reason}"
);
}
}
}
public static ObjectNodeBase CreateDeserializableRoot(string name, CachedType type, string format, Options options)
{
var context = new Context(options, Mode.Deserialize, format);
var @object = ValueFactory.Create(type);
if (!context.Options.Deserialization.IgnoreRootName)
{
var expectedName = context.Options.TypeNameConventions.GetName(@object.SpecifiedType, context, true);
if (!name.Equals(expectedName, options.Deserialization.NameComparison))
{
throw new InvalidRootNameDeserializationException(type, format, name, expectedName);
}
}
return(CreateDeserializable(name, @object, null, context));
}
public MapImpl EnvironmentVariables()
{
SystemLogger.Write("WARNING! Deprecated method: 'SystemInfo.EnvironmentVariables' is deprecated, use 'EnvironmentVariables' from global context");
var varsMap = new MapImpl();
var allVars = System.Environment.GetEnvironmentVariables();
foreach (DictionaryEntry item in allVars)
{
varsMap.Insert(
ValueFactory.Create((string)item.Key),
ValueFactory.Create((string)item.Value));
}
return(varsMap);
}
public MapImpl EnvironmentVariables(EnvironmentVariableTargetEnum target = EnvironmentVariableTargetEnum.Process)
{
EnvironmentVariableTarget targetParam = GetSystemEnvVariableTarget(target);
var varsMap = new MapImpl();
var allVars = System.Environment.GetEnvironmentVariables(targetParam);
foreach (DictionaryEntry item in allVars)
{
varsMap.Insert(
ValueFactory.Create((string)item.Key),
ValueFactory.Create((string)item.Value));
}
return(varsMap);
}
public void WrapStructureIndices()
{
lock (TestOrderingLock.Lock)
{
var se = new MinimalTypeSystemHack();
var structure = new StructureImpl("Свойство1,Свойство2",
ValueFactory.Create(1),
ValueFactory.Create("Hello"));
dynamic dynStructure = new DynamicContextWrapper(structure);
Assert.Equal <int>(1, (int)dynStructure["Свойство1"]);
Assert.Equal <string>("Hello", dynStructure["Свойство2"]);
}
}
public void ContentTypeIsReflectedInHeadersAfterAssignment()
{
lock (TestOrderingLock.Lock)
{
var se = new MinimalTypeSystemHack();
var context = new DefaultHttpContext();
var response = new DefaultHttpResponse(context);
var scriptRequest = new HttpResponseImpl(response);
scriptRequest.ContentType = "text/plain";
Assert.True(scriptRequest.Headers.GetIndexedValue(ValueFactory.Create("Content-Type")).AsString().Equals("text/plain"));
Assert.Equal("text/plain", scriptRequest.RealObject.Headers["Content-Type"]);
Assert.Equal("text/plain", scriptRequest.RealObject.ContentType);
}
}
internal void CopyFrom(ValueTreeRowCollection src)
{
_rows.Clear();
ValueTreeColumnCollection Columns = Owner().Columns;
foreach (ValueTreeRow row in src._rows)
{
ValueTreeRow new_row = Add();
foreach (ValueTreeColumn Column in Columns)
{
new_row.Set(Column, row.Get(ValueFactory.Create(Column.Name)));
}
new_row.Rows.CopyFrom(row.Rows);
}
}
public void ContentTypeIsReflectedInHeadersAfterSetHeaders()
{
var response = MockRequestClass();
var headers = new MapImpl();
headers.SetIndexedValue(ValueFactory.Create("Content-Type"), ValueFactory.Create("text/plain"));
var scriptRequest = new HttpResponseImpl(response);
scriptRequest.SetHeaders(headers);
Assert.Equal("text/plain", scriptRequest.Headers.GetIndexedValue(ValueFactory.Create("Content-Type")).AsString());
Assert.Equal("text/plain", scriptRequest.RealObject.Headers["Content-Type"]);
Assert.Equal("text/plain", scriptRequest.RealObject.ContentType);
}
public bool Property(string name, IVariable variable = null)
{
if (_values.TryGetValue(name, out IValue out_value))
{
variable.Value = out_value;
return(true);
}
else
{
out_value = ValueFactory.Create();
}
variable.Value = out_value;
return(false);
}
private void UpdateCookies()
{
var cookieMap = new MapImpl();
if (_realObject.Cookies != null)
{
foreach (var cookie in _realObject.Cookies)
{
cookieMap.SetIndexedValue(ValueFactory.Create(cookie.Key),
ValueFactory.Create(cookie.Value));
}
}
Cookies = new FixedMapImpl(cookieMap);
}
public IValue Adjust(IValue value)
{
if (value?.DataType == DataType.Boolean)
{
return(value);
}
try
{
// TODO: вменяемое приведение без Попытки
return(ValueFactory.Create(value.AsBoolean()));
} catch { }
return(ValueFactory.Create(false));
}
public FormFileContext(IFormFile realObject)
{
_realObject = realObject;
_headers = new Lazy <FixedMapImpl>(() =>
{
var mapHdrs = new MapImpl();
foreach (var realObjectHeader in _realObject.Headers)
{
mapHdrs.SetIndexedValue(ValueFactory.Create(realObjectHeader.Key), ValueFactory.Create(realObjectHeader.Value));
}
return(new FixedMapImpl(mapHdrs));
}
);
}
private void UpdateHeaders()
{
var mapHdrs = new MapImpl();
if (_realObject.Headers != null)
{
foreach (var realObjectHeader in _realObject.Headers)
{
mapHdrs.SetIndexedValue(ValueFactory.Create(realObjectHeader.Key),
ValueFactory.Create(realObjectHeader.Value));
}
}
Headers = new FixedMapImpl(mapHdrs);
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="parentCntrl"></param>
public FormGroup(Control parentCntrl)
{
this._item = new GroupBox();
this._formGroupType = (int)EnumFormGroupType.UsualGroup;
this._parentControl = parentCntrl;
this._name = "";
this._visible = true;
this._enabled = true;
this._title = "";
//this._toolTip = "";
this._parent = ValueFactory.Create();
this._elements = new Elements(this, _item);
}
private IValue CallStrTemplate(IValue[] arguments)
{
var srcFormat = arguments[0].AsString();
if (srcFormat == String.Empty)
{
return(ValueFactory.Create(""));
}
var re = new System.Text.RegularExpressions.Regex(@"(%%)|(%\d+)|(%\D)");
int matchCount = 0;
int passedArgsCount = arguments.Skip(1).Where(x => x != null).Count();
var result = re.Replace(srcFormat, (m) =>
{
if (m.Groups[1].Success)
{
return("%");
}
if (m.Groups[2].Success)
{
matchCount++;
var number = int.Parse(m.Groups[2].Value.Substring(1));
if (number < 1 || number > 11)
{
throw new RuntimeException("Ошибка при вызове метода контекста (СтрШаблон): Ошибка синтаксиса шаблона в позиции " + (m.Index + 1));
}
if (arguments[number] != null)
{
return(arguments[number].AsString());
}
else
{
return("");
}
}
throw new RuntimeException("Ошибка при вызове метода контекста (СтрШаблон): Ошибка синтаксиса шаблона в позиции " + (m.Index + 1));
});
if (passedArgsCount > matchCount)
{
throw RuntimeException.TooManyArgumentsPassed();
}
return(ValueFactory.Create(result));
}
public void RunApp(string cmdLine, string currentDir = null, bool wait = false, [ByRef] IVariable retCode = null)
{
var sInfo = new System.Diagnostics.ProcessStartInfo();
var enumArgs = Utils.SplitCommandLine(cmdLine);
bool fNameRead = false;
StringBuilder argsBuilder = new StringBuilder();
foreach (var item in enumArgs)
{
if (!fNameRead)
{
sInfo.FileName = item;
fNameRead = true;
}
else
{
argsBuilder.Append(' ');
argsBuilder.Append(item);
}
}
if (argsBuilder.Length > 0)
{
argsBuilder.Remove(0, 1);
}
sInfo.Arguments = argsBuilder.ToString();
if (currentDir != null)
{
sInfo.WorkingDirectory = currentDir;
}
var p = new System.Diagnostics.Process();
p.StartInfo = sInfo;
p.Start();
if (wait)
{
p.WaitForExit();
if (retCode != null)
{
retCode.Value = ValueFactory.Create(p.ExitCode);
}
}
}
public IValue add(string ElementName, string ElementType, IValue ElementParent)
{
Control parentCntrl = (this._frm);
if (ElementParent != ValueFactory.Create())
{
parentCntrl = ((IFormElement)ElementParent).getControl();
}
else
{
ElementParent = _parent;
}
IValue newItem = null;
if (ElementType.ToUpper() == ("ГруппаФормы").ToUpper())
{
newItem = new FormGroup(parentCntrl);
}
if (ElementType.ToUpper() == ("ПолеФормы").ToUpper())
{
newItem = new FormField(parentCntrl);
}
if (ElementType.ToUpper() == ("КнопкаФормы").ToUpper())
{
newItem = new FormButton(parentCntrl);
}
if (ElementType.ToUpper() == ("ТаблицаФормы").ToUpper())
{
newItem = new FormTable(parentCntrl);
}
if (ElementType.ToUpper() == ("ДеревоФормы").ToUpper())
{
newItem = new FormTree(parentCntrl);
}
((IFormElement)newItem).setParent(ElementParent);
((IFormElement)newItem).Name = ElementName;
((IElementsContainer)ElementParent).Items.AddElement(ElementName, newItem);
//_elements.Add(ElementName, newItem);
return(newItem);
}
public void Insert(string name, IValue val = null)
{
var num = RegisterProperty(name);
if (num == _values.Count)
{
_values.Add(null);
}
if (val == null)
{
val = ValueFactory.Create();
}
SetPropValue(num, val);
}
public IValue GetSystemOptionValue(string optionKey)
{
string value = null;
if (_config != null)
{
value = _config[optionKey];
}
if (value != null)
{
return(ValueFactory.Create(value));
}
return(ValueFactory.Create());
}
public void Boolean_Comparison()
{
var v1 = ValueFactory.Create(true);
var v2 = ValueFactory.Create(false);
var num1 = ValueFactory.Create(1);
var num0 = ValueFactory.Create(0);
Assert.True(v1.CompareTo(v2) > 0);
Assert.True(v2.CompareTo(v1) < 0);
Assert.True(v1.CompareTo(num1) == 0);
Assert.True(v2.CompareTo(num0) == 0);
Assert.True(v1.CompareTo(num0) > 0);
Assert.True(v2.CompareTo(num1) < 0);
Assert.True(num1.CompareTo(v1) == 0);
Assert.True(num1.CompareTo(v2) > 0);
}
public void BooleanEquality()
{
Assert.True(BooleanValue.True.AsBoolean());
Assert.False(BooleanValue.False.AsBoolean());
Assert.Same(BooleanValue.True, ValueFactory.Create(true));
Assert.Same(BooleanValue.False, ValueFactory.Create(false));
Assert.NotEqual(BooleanValue.False, BooleanValue.True);
Assert.Equal(0, BooleanValue.False.AsNumber());
Assert.Equal(1, BooleanValue.True.AsNumber());
Assert.True(BooleanValue.True.CompareTo(BooleanValue.False) > 0);
Assert.Throws <RuntimeException>(() => BooleanValue.True.AsDate());
Assert.Throws <RuntimeException>(() => BooleanValue.True.AsObject());
}
public void CookiesAreAccessible()
{
var fakeCookies = new Dictionary <string, string>();
fakeCookies["test"] = "test";
var reqCookies = new Mock <IRequestCookieCollection>();
reqCookies.Setup(x => x.GetEnumerator()).Returns(fakeCookies.GetEnumerator());
var requestMock = new Mock <HttpRequest>();
requestMock.SetupGet(x => x.Cookies).Returns(reqCookies.Object);
var request = new HttpRequestImpl(requestMock.Object);
Assert.Equal(request.Cookies.GetIndexedValue(ValueFactory.Create("test")).AsString(), "test");
}