public void AssignPropertiesValues(HostedScriptEngine engine)
{
StructureImpl enums = new StructureImpl();
System.Collections.Specialized.NameValueCollection appSettings = System.Web.Configuration.WebConfigurationManager.AppSettings;
string enumsPath = appSettings["enumsPath"];
if (enumsPath != null)
{
enumsPath = ConvertRelativePathToPhysical(enumsPath);
}
string[] files = System.IO.Directory.GetFiles(enumsPath, "*.txt");
foreach (string filePathName in files)
{
StructureImpl currentEnum = new StructureImpl();
string[] enumValues = System.IO.File.ReadAllLines(filePathName);
string enumName = System.IO.Path.GetFileNameWithoutExtension(filePathName);
foreach (string currentValue in enumValues)
{
currentEnum.Insert(currentValue, ValueFactory.Create(enumName + "." + currentValue));
}
enums.Insert(System.IO.Path.GetFileNameWithoutExtension(filePathName), new FixedStructureImpl(currentEnum));
}
engine.EngineInstance.Environment.SetGlobalProperty("Перечисления", new FixedStructureImpl(enums));
}
public IValue MainModuleInfo(int proccessID)
{
var proc = Process.GetProcessById((int)proccessID);
try
{
StructureImpl strct = new StructureImpl();
strct.Insert("FileName", ValueFactory.Create(proc.MainModule.FileName));
strct.Insert("ModuleName", ValueFactory.Create(proc.MainModule.ModuleName));
var fileVersionInfo = proc.MainModule.FileVersionInfo;
StructureImpl versionInfo = new StructureImpl();
versionInfo.Insert("FileMajorPart", ValueFactory.Create(fileVersionInfo.FileMajorPart));
versionInfo.Insert("FileMinorPart", ValueFactory.Create(fileVersionInfo.FileMinorPart));
versionInfo.Insert("FileBuildPart", ValueFactory.Create(fileVersionInfo.FileBuildPart));
versionInfo.Insert("FilePrivatePart", ValueFactory.Create(fileVersionInfo.FilePrivatePart));
strct.Insert("FileVersionInfo", versionInfo);
FixedStructureImpl FixStruct = new FixedStructureImpl(strct);
return(FixStruct);
}
catch (Exception)
{
return(ValueFactory.Create());
}
}
private IList <UniqueId> SearchMessages(StructureImpl filter)
{
var imapFilter = new InternetMailImapSearchFilter(filter);
var query = imapFilter.CreateSearchQuery();
return(_currentFolder.Search(query));
}
public ArrayImpl GetConstructors()
{
ArrayImpl result = new ArrayImpl();
var constructors = AsmType.GetConstructors();
foreach (var itm in constructors)
{
ArrayImpl miparams = new ArrayImpl();
foreach (var prm in itm.GetParameters())
{
StructureImpl strct = new StructureImpl();
strct.Insert("Имя", ValueFactory.Create(prm.Name));
strct.Insert("ЗначениеПоУмолчанию", ValueFactory.Create(prm.DefaultValue.ToString()));
strct.Insert("ЭтоНеобязательный", ValueFactory.Create(prm.IsOptional));
strct.Insert("Тип", ValueFactory.Create(prm.ParameterType.Name));
miparams.Add(strct);
}
AssemblyMethod mi = new AssemblyMethod();
mi.Name = itm.Name;
mi.IsFunction = false;
mi.Params = miparams;
result.Add(ValueFactory.Create(mi));
}
return(result);
}
public void StructurePresentation()
{
var obj = new StructureImpl();
obj.Insert("first", ValueFactory.Create(1));
obj.Insert("second", ValueFactory.Create(2));
var debuggerVar = Visualizer.GetVariable(Variable.Create(obj, "myVar"));
Assert.That(debuggerVar.Presentation, Is.EqualTo("Структура"));
Assert.That(debuggerVar.IsStructured, Is.True);
var items = Visualizer
.GetChildVariables(obj)
.Select(x => Visualizer.GetVariable(x))
.ToArray();
Assert.That(items, Has.Length.EqualTo(2));
Assert.That(items[0].Name, Is.EqualTo("first"));
Assert.That(items[0].TypeName, Is.EqualTo("Число"));
Assert.That(items[0].Presentation, Is.EqualTo("1"));
Assert.That(items[0].IsStructured, Is.False);
Assert.That(items[1].Name, Is.EqualTo("second"));
Assert.That(items[1].TypeName, Is.EqualTo("Число"));
Assert.That(items[1].Presentation, Is.EqualTo("2"));
Assert.That(items[1].IsStructured, Is.False);
}
public IValue GetCursorPosition()
{
StructureImpl strct = new StructureImpl();
strct.Insert("Верх", ValueFactory.Create(Cursor.Position.Y));
strct.Insert("Лево", ValueFactory.Create(Cursor.Position.X));
FixedStructureImpl FixStruct = new FixedStructureImpl(strct);
return(FixStruct);
}
public InternetMailImapSearchFilter(StructureImpl filter)
{
foreach (var KV in filter)
{
var myPropertyIndex = this.FindProperty((KV as KeyAndValueImpl).Key.AsString());
if (myPropertyIndex != -1)
{
SetPropValue(myPropertyIndex, KV.Value);
}
}
}
public void WrapStructureIndices()
{
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("Hello", dynStructure["Свойство2"]);
}
public void WrapStructureMethodsCall()
{
var structure = new StructureImpl();
dynamic dynStructure = new DynamicContextWrapper(structure);
dynStructure.Вставить("Свойство1", 1);
dynStructure.Вставить("Свойство2", "Hello");
Assert.Equal <int>(1, (int)dynStructure["Свойство1"]);
Assert.Equal("Hello", dynStructure["Свойство2"]);
}
public void CanAccessIndexOfStruct()
{
var structImpl = new StructureImpl();
dynamic dyn = structImpl;
dyn.Вставить("Свойство", 1);
dyn.Вставить("Свойство2", "Привет");
Assert.AreEqual(1, dyn["Свойство"]);
Assert.AreEqual("Привет", dyn["Свойство2"]);
}
public IValue ScreenResolution(int SreenNumber = 0)
{
Size resolution = System.Windows.Forms.Screen.AllScreens[SreenNumber].Bounds.Size;
StructureImpl strct = new StructureImpl();
strct.Insert("Ширина", ValueFactory.Create(resolution.Width));
strct.Insert("Высота", ValueFactory.Create(resolution.Height));
FixedStructureImpl FixStruct = new FixedStructureImpl(strct);
return(FixStruct);
}
public void CanCallMethodsOfStruct()
{
var structImpl = new StructureImpl();
dynamic dyn = structImpl;
dyn.Insert("Свойство", 1);
dyn.Вставить("Свойство2", "Привет");
Assert.AreEqual(2, structImpl.Count());
Assert.True(structImpl.HasProperty("Свойство"));
Assert.True(structImpl.HasProperty("Свойство2"));
}
public ArrayImpl GetBackgroundJobs(StructureImpl filter = default)
{
if (filter == default)
{
return(new ArrayImpl(_tasks.ToArray()));
}
var arr = new ArrayImpl();
foreach (var task in _tasks)
{
var result = true;
foreach (var filterItem in filter)
{
switch (filterItem.Key.AsString().ToLower())
{
case "состояние":
case "state":
var enumval = filterItem.Value as CLREnumValueWrapper <TaskStateEnum>;
if (enumval == default)
{
continue;
}
result = result && task.State == enumval.UnderlyingValue;
break;
case "имяметода":
case "methodname":
result = result && task.MethodName.ToLower() == filterItem.Value.AsString();
break;
case "объект":
case "object":
result = result && task.Target.Equals(filterItem.Value);
break;
case "уникальныйидентификатор":
case "uuid":
result = result && task.Identifier.Equals(filterItem.Value);
break;
}
}
if (result)
{
arr.Add(task);
}
}
return(arr);
}
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 WrapStructureMethodsCall()
{
lock (TestOrderingLock.Lock)
{
var se = new MinimalTypeSystemHack();
var structure = new StructureImpl();
dynamic dynStructure = new DynamicContextWrapper(structure);
dynStructure.Вставить("Свойство1", 1);
dynStructure.Вставить("Свойство2", "Hello");
Assert.Equal <int>(1, (int)dynStructure["Свойство1"]);
Assert.Equal <string>("Hello", dynStructure["Свойство2"]);
}
}
// В режиме Pop3 отбор filter игнорируется
public ArrayImpl GetIdentifiers(ArrayImpl identifiers = null, StructureImpl filter = null)
{
var result = new ArrayImpl();
var allUids = client.GetMessageUids();
foreach (var uid in allUids)
{
var Id = ValueFactory.Create(uid);
if (identifiers == null || identifiers.Find(Id).DataType == DataType.Undefined)
{
result.Add(Id);
}
}
return(result);
}
public ArrayImpl GetHeaders(StructureImpl filter)
{
var result = new ArrayImpl();
if (client.Count > 0)
{
var allHeaders = client.GetMessageHeaders(0, client.Count);
foreach (var headers in allHeaders)
{
var mailMessage = new InternetMailMessage(headers);
result.Add(mailMessage);
}
}
return(result);
}
public ArrayImpl GetFields()
{
ArrayImpl result = new ArrayImpl();
var list = AsmType.GetFields();
foreach (var itm in list)
{
StructureImpl strct = new StructureImpl();
strct.Insert("Имя", ValueFactory.Create(itm.Name));
strct.Insert("Тип", ValueFactory.Create(itm.FieldType.Name));
strct.Insert("ЭтоЗакрытое", ValueFactory.Create(itm.IsPrivate));
strct.Insert("ЭтоОткрытое", ValueFactory.Create(itm.IsPublic));
result.Add(strct);
}
return(result);
}
public ArrayImpl GetIdentifiers(ArrayImpl identifiers, StructureImpl filter)
{
var result = new ArrayImpl();
var allUids = GetHeaders(filter);
foreach (var ivHeaderWithUid in allUids)
{
var headerWithUid = ivHeaderWithUid as InternetMailMessage;
var Id = headerWithUid.Uid.Get(0);
if (identifiers == null || identifiers.Find(Id).DataType == DataType.Undefined)
{
result.Add(Id);
}
}
return(result);
}
public void WrapStructureEnumeration()
{
var structure = new StructureImpl();
dynamic dynStructure = new DynamicContextWrapper(structure);
dynStructure.Вставить("Свойство1", 1);
dynStructure.Вставить("Свойство2", "Hello");
int cnt = 0;
foreach (var kv in dynStructure)
{
++cnt;
Assert.IsType <DynamicContextWrapper>(kv);
}
Assert.Equal(2, cnt);
}
private bool CheckFilterCriteria(ValueTableRow Row, StructureImpl Filter)
{
foreach (KeyAndValueImpl kv in Filter)
{
ValueTableColumn Column = Columns.FindColumnByName(kv.Key.AsString());
if (Column == null)
{
throw RuntimeException.PropNotFoundException(kv.Key.AsString());
}
IValue current = Row.Get(Column);
if (!current.Equals(kv.Value))
{
return(false);
}
}
return(true);
}
public ArrayImpl GetAsmProperties()
{
ArrayImpl result = new ArrayImpl();
var list = AsmType.GetProperties();
foreach (var itm in list)
{
StructureImpl strct = new StructureImpl();
strct.Insert("Имя", ValueFactory.Create(itm.Name));
strct.Insert("Тип", ValueFactory.Create(itm.PropertyType.Name));
strct.Insert("ДоступноЧтение", ValueFactory.Create(itm.CanRead));
strct.Insert("ДоступнаЗапись", ValueFactory.Create(itm.CanWrite));
//strct.Insert("ИмяМетодаЧтения", ValueFactory.Create(itm.GetMethod.Name));
//strct.Insert("ИмяМетодаЗаписи", ValueFactory.Create(itm.SetMethod.Name));
result.Add(strct);
}
return(result);
}
public ArrayImpl GetBackgroundJobs(StructureImpl filter = null)
{
if (filter == null || filter == ValueFactory.Create())
{
return(GetAllJobs());
}
ArrayImpl result = new ArrayImpl();
foreach (System.Collections.Generic.KeyValuePair <Guid, WebBackgroundJob> ci in WebBackgroundJobsManager.Jobs)
{
bool shouldAdd = true;
foreach (KeyAndValueImpl cfi in filter)
{
if (
(cfi.Key.AsString().ToLower() == "ключ" && cfi.Value.AsString() != ci.Value.Key) ||
(cfi.Key.AsString().ToLower() == "наименование" && cfi.Value.AsString() != ci.Value.Description) ||
(cfi.Key.AsString().ToLower() == "имяметода" && cfi.Value.AsString() != ci.Value.MethodName) ||
(cfi.Key.AsString().ToLower() == "начало" && cfi.Value.AsDate() != ci.Value.Begin) ||
(cfi.Key.AsString().ToLower() == "конец" && cfi.Value.AsDate() != ci.Value.End) ||
(cfi.Key.AsString().ToLower() == "состояние" && cfi.Value.AsNumber() != (int)ci.Value.State) ||
(cfi.Key.AsString().ToLower() == "регламентноезадание") ||
(cfi.Key.AsString().ToLower() == "уникальныйидентификатор" && ((GuidWrapper)cfi.Value).AsString() != ci.Value.UUID.ToString())
)
{
shouldAdd = false;
break;
}
}
if (shouldAdd)
{
result.Add(new WebBackgroundJobImpl(ci.Value));
}
}
return(result);
}
public void WrapStructureEnumeration()
{
lock (TestOrderingLock.Lock)
{
var se = new MinimalTypeSystemHack();
var structure = new StructureImpl();
dynamic dynStructure = new DynamicContextWrapper(structure);
dynStructure.Вставить("Свойство1", 1);
dynStructure.Вставить("Свойство2", "Hello");
int cnt = 0;
foreach (var kv in dynStructure)
{
++cnt;
Assert.IsType(typeof(DynamicContextWrapper), kv);
}
Assert.Equal(2, cnt);
}
}
public ArrayImpl GetHeaders(StructureImpl filter)
{
var result = new ArrayImpl();
var dataToFetch = MessageSummaryItems.Envelope
| MessageSummaryItems.Flags
| MessageSummaryItems.UniqueId
| MessageSummaryItems.InternalDate
| MessageSummaryItems.MessageSize
;
IList <IMessageSummary> allHeaders;
if (filter == null)
{
allHeaders = _currentFolder.Fetch(0, -1, dataToFetch);
}
else
{
var ids = SearchMessages(filter);
if (ids.Count == 0)
{
return(result);
}
allHeaders = _currentFolder.Fetch(ids, dataToFetch);
}
foreach (var headers in allHeaders)
{
var mailMessage = new InternetMailMessage(headers);
mailMessage.Uid.Add(ValueFactory.Create(UniqueIdToInternalId(headers.UniqueId)));
result.Add(mailMessage);
}
return(result);
}
public Query()
{
_parameters = new StructureImpl();
_text = "";
}
public ArrayImpl GetHeaders(StructureImpl filter = null)
{
return(receiver?.GetHeaders(filter));
}
public ArrayImpl GetIdentifiers(ArrayImpl identifiers = null, StructureImpl filter = null)
{
return(receiver?.GetIdentifiers(identifiers, filter));
}
public void GroupBy(string groupColumnNames, string aggregateColumnNames = null)
{
// TODO: Сворачиваем за N^2. Переделать на N*log(N)
List <ValueTableColumn> GroupColumns = GetProcessingColumnList(groupColumnNames, true);
List <ValueTableColumn> AggregateColumns = GetProcessingColumnList(aggregateColumnNames, true);
List <ValueTableRow> new_rows = new List <ValueTableRow>();
foreach (ValueTableRow row in _rows)
{
StructureImpl search = new StructureImpl();
foreach (ValueTableColumn Column in GroupColumns)
{
search.Insert(Column.Name, row.Get(Column));
}
ValueTableRow new_row = null;
foreach (ValueTableRow nrow in new_rows)
{
if (CheckFilterCriteria(nrow, search))
{
new_row = nrow;
break;
}
}
if (new_row == null)
{
new_row = new ValueTableRow(this);
foreach (ValueTableColumn Column in GroupColumns)
{
new_row.Set(Column, row.Get(Column));
}
new_rows.Add(new_row);
}
foreach (ValueTableColumn Column in AggregateColumns)
{
IValue old = new_row.Get(Column);
decimal d_old;
if (old.DataType != Machine.DataType.Number)
{
d_old = 0;
}
else
{
d_old = old.AsNumber();
}
IValue current = row.Get(Column);
decimal d_current;
if (current.DataType != Machine.DataType.Number)
{
d_current = 0;
}
else
{
d_current = current.AsNumber();
}
new_row.Set(Column, ValueFactory.Create(d_old + d_current));
}
}
_rows.Clear();
_rows.AddRange(new_rows);
{
int i = 0;
while (i < _columns.Count())
{
ValueTableColumn Column = _columns.FindColumnByIndex(i);
if (GroupColumns.IndexOf(Column) == -1 && AggregateColumns.IndexOf(Column) == -1)
{
_columns.Delete(Column);
}
else
{
++i;
}
}
}
}
public IValue ReadJSONInStruct(JSONReader Reader, bool nestedArray = false)
{
if (nestedArray)
{
ArrayImpl NestedArray = new ArrayImpl();
while (Reader.Read())
{
if (Reader.CurrentJsonTokenType == JsonToken.EndArray)
{
break;
}
else if (Reader.CurrentJsonTokenType == JsonToken.StartObject)
{
NestedArray.Add(ReadJSONInStruct(Reader));
}
else if (Reader.CurrentJsonTokenType == JsonToken.StartArray)
{
NestedArray.Add(ReadJSONInStruct(Reader, true));
}
else
{
NestedArray.Add(Reader.CurrentValue);
}
}
return(NestedArray);
}
StructureImpl ResStruct = new StructureImpl();
while ((Reader).Read())
{
if (Reader.CurrentJsonTokenType == JsonToken.PropertyName)
{
string PropertyName = Reader.CurrentValue.AsString();
Reader.Read();
if (Reader.CurrentJsonTokenType == JsonToken.StartObject)
{
ResStruct.Insert(PropertyName, ReadJSONInStruct(Reader));
}
else if (Reader.CurrentJsonTokenType == JsonToken.StartArray)
{
ResStruct.Insert(PropertyName, ReadJSONInStruct(Reader, true));
}
else
{
ResStruct.Insert(PropertyName, Reader.CurrentValue);
}
}
else if (Reader.CurrentJsonTokenType == JsonToken.EndObject)
{
break;
}
else if (Reader.CurrentJsonTokenType == JsonToken.StartArray)
{
return(ReadJSONInStruct(Reader, true));
}
}
return(ResStruct);
}
