object UnwrapInputVariableFromViewModel()
{
if (_inputVariable == null)
{
return(null);
}
AssemblyViewModel assemblyVM = _inputVariable as AssemblyViewModel;
if (assemblyVM != null)
{
return(assemblyVM.GetAssemblyInternal());
}
TypeViewModel typeVM = _inputVariable as TypeViewModel;
if (typeVM != null)
{
return(typeVM.GetTypeInternal());
}
ObjectViewModel objectVM = _inputVariable as ObjectViewModel;
if (objectVM != null)
{
return(objectVM.GetInstanceInternal());
}
Debug.Fail("Unexpected input variable type: " + _inputVariable.GetType());
return(null);
}
public MainWindow(IEnumerable <AssemblyModel> assemblies)
: this()
{
foreach (var assemblyModel in assemblies)
{
var assemblyViewModel = new AssemblyViewModel(assemblyModel.AssemblyFilePath);
foreach (var classVM in assemblyViewModel.Classes)
{
var classM = assemblyModel.Classes.FirstOrDefault(x => x.ClassName == classVM.Name);
if (classM != null)
{
foreach (var methodVM in classVM.Methods)
{
var methodM = classM.Methods.FirstOrDefault(mm => mm.MethodName == methodVM.Name);
if (methodM != null)
{
methodVM.FriendlyName = methodM.FriendlyName;
methodVM.IsSelected = true;
}
}
}
}
this.Assemblies.Add(assemblyViewModel);
}
}
public MainWindow()
{
InitializeComponent();
var avm = new AssemblyViewModel();
DataContext = avm;
}
private void AddAssembly(Assembly assembly)
{
var assebmlyVM = new AssemblyViewModel(assembly, ParentTypeFilter);
if (assebmlyVM.Types.Count > 0)
{
Assemblies.Add(assebmlyVM);
}
}
public IActionResult Index()
{
var model = new AssemblyViewModel();
model.TestHistory = AssemblyData.GetTestModuleResultsData();
model.ShipmentHistory = AssemblyData.GetShipmentHistory();
return(View(model));
}
public void Test1()
{
const string asm1Name = "Slider";
const string asm2Name = "Bed Assembly";
const string part1Name = "Base";
const string part2Name = "Bed";
const string part3Name = "Flange";
var doc = new AmlDocument();
var project = new ProjectViewModel(doc);
doc.CaexDocument.CAEXFile.InstanceHierarchy.Insert(project.CaexObject as InstanceHierarchyType);
var asm1 = new AssemblyViewModel(doc)
{
Name = asm1Name
};
var asm2 = new AssemblyViewModel(doc)
{
Name = asm2Name
};
var part1 = new PartViewModel(doc)
{
Name = part1Name
};
var part2 = new PartViewModel(doc)
{
Name = part2Name
};
var part3 = new PartViewModel(doc)
{
Name = part3Name
};
project.Parts.Add(asm1);
asm1.Parts.Add(asm2);
asm1.Parts.Add(part1);
asm2.Parts.Add(part2);
asm2.Parts.Add(part3);
var stream = doc.CaexDocument.SaveToStream(true);
var caex = CAEXDocument.LoadFromStream(stream);
var doc2 = new AmlDocument(caex);
var ih = doc2.CaexDocument.CAEXFile.InstanceHierarchy.First;
var vm = new ProjectViewModel(ih, doc2);
}
private void RunConsoleApp(AssemblyData assemblyData, ILogger logger, ISerializer serializer)
{
_reflector = new Reflector();
logger.Log("");
logger.Log("Using Console mode.");
AsyncSerializer caller = new AsyncSerializer(serializer.Serialize);
AssemblyViewModel assemblyVM = new AssemblyViewModel(assemblyData);
Console.WriteLine(assemblyVM.AssemblyToString());
_browser = new ObjectBrowser(logger, assemblyVM);
Console.WriteLine("");
Console.WriteLine("1 - serializacja");
Console.WriteLine("2 - deserializacja");
Console.WriteLine("3 - otworz");
int choice = Int32.Parse(Console.ReadLine());
switch (choice)
{
case 1:
caller.BeginInvoke(_browser, serializationPath, logger, null, null);
break;
case 2:
_browser = serializer.Deserialize <ObjectBrowser>(serializationPath, logger);
Console.WriteLine(_browser.GetLatestAssemblyViewModel().AssemblyToString());
break;
case 3:
string path = Console.ReadLine();
_reflector.Reflect(path, logger);
_browser.AddAssemblyViewModel(logger, new AssemblyViewModel(_reflector._AssemblyModel));
Console.WriteLine(_browser.GetLatestAssemblyViewModel().AssemblyToString());
break;
default:
break;
}
Console.Read();
}
public BrowserView()
{
log = (Application.Current as WindowApp.App).logger;
log.Log("Using Window mode.");
AssemblyViewModel assemblyVM = new AssemblyViewModel((Application.Current as WindowApp.App).assemblyData);
_assemblies = new ObservableCollection <AssemblyViewModel>
{
assemblyVM
};
_assembly = new AssemblyViewModel();
_assembly = assemblyVM;
_reflector = new Reflector();
SerializeCommand = new RelayCommand(CommandParameter => Serialize());
DeserializeCommand = new RelayCommand(CommandParameter => Deserialize());
OpenFileCommand = new RelayCommand(CommandParameter => OpenFile());
}
public async Task <List <AssemblyViewModel> > RunTests()
{
var assembliesTests = myNUnit.MyNUnitRun(pathToFolderWithTests);
var testsList = new List <AssemblyViewModel>();
while (!assembliesTests.IsEmpty)
{
var assembly = new AssemblyViewModel();
assembly.Tests = new List <TestViewModel>();
assembliesTests.TryDequeue(out var info);
assembly.Name = info.Name;
var infoArray = info.Tests.ToArray();
foreach (var item in infoArray)
{
var test = new TestViewModel();
test.Result = item.Result;
test.Name = item.Name;
test.StartTime = DateTime.Now;
if (item.Result == "Passed")
{
test.Time = item.Time;
}
else
{
test.IgnoreReason = item.IgnoreReason;
}
assembly.Tests.Add(test);
}
homeRepository.AssembliesHistory.Add(new AssemblyViewModel
{
Name = assembly.Name,
Tests = assembly.Tests
});
testsList.Add(assembly);
}
await homeRepository.SaveChangesAsync();
return(testsList);
}
private void OpenFile()
{
OpenFileDialog openFileDialog = new OpenFileDialog
{
Filter = "Dynamic Library File(*.dll)| *.dll|"
+ "Executable File(*.exe)| *.exe|"
+ "XML File(*.xml)| *.xml",
RestoreDirectory = true
};
openFileDialog.ShowDialog();
if (openFileDialog.FileName.Length == 0)
{
MessageBox.Show("No files selected");
}
else
{
_reflector.Reflect(openFileDialog.FileName, log);
AssemblyViewModel assemblyVM = new AssemblyViewModel(_reflector._AssemblyModel);
_assemblies.Add(assemblyVM);
}
}
private XModule CreateModule(AssemblyViewModel assembly, ClassViewModel cls, MethodViewModel method, TCFolder parent)
{
var module = XModule.Create();
module.ParentFolder.Set(parent);
module.Name = method.FriendlyName ?? method.Name;
var assemblyParam = module.CreateTechnicalIDParam();
var classNameParam = module.CreateTechnicalIDParam();
var methodNameParam = module.CreateTechnicalIDParam();
var engineParam = module.CreateConfigurationParam();
var setParam = module.CreateConfigurationParam();
assemblyParam.Name = "LibraryFile";
assemblyParam.Value = assembly.FilePath;
classNameParam.Name = "ClassName";
classNameParam.Value = cls.FullName;
methodNameParam.Name = "MethodName";
methodNameParam.Value = method.Name;
engineParam.Name = "Engine";
engineParam.Value = "TosCode";
setParam.Name = "SpecialExecutionTask";
setParam.Value = "Execute";
foreach (var parameter in method.Parameters)
{
CreateModuleAttribute(module, parameter);
}
if (method.ReturnType != typeof(void))
{
var returnAttribute = module.CreateModuleAttribute();
BuildModuleAttribute(returnAttribute, "Result", method.ReturnType, 1, true, XTestStepActionMode.Verify);
var returnParam = returnAttribute.CreateConfigurationParam();
returnParam.Name = "Result";
returnParam.Value = "true";
}
return(module);
}
public Type Deserialize <Type>(string name, ILogger log)
{
log.Log("Deserialize to DB...");
var db = new TPAEntities();
DbSet <Model> models = db.Model;
ObservableCollection <AssemblyViewModel> assemblies = new ObservableCollection <AssemblyViewModel>();
foreach (Model model in models)
{
AssemblyViewModel assembly = new AssemblyViewModel();
ObservableCollection <NamespaceViewModel> assemblyNamespaces = new ObservableCollection <NamespaceViewModel>();
foreach (Namespace modelNamespace in model.Namespace)
{
NamespaceViewModel assemblyNamespace = new NamespaceViewModel
{
NamespaceName = modelNamespace.Name
};
// assemblyNamespaces.Add()
}
assembly.Namespaces = assemblyNamespaces;
assemblies.Add(assembly);
}
return(default(Type));
}
public TypeViewModel(TypeInfo typeInfo, AssemblyViewModel assemblyViewModel, AssemblyBrowserWindowViewModel windowViewModel)
{
_typeInfo = typeInfo;
_windowViewModel = windowViewModel;
_assemblyViewModel = assemblyViewModel;
_name = typeInfo.Name;
_fullName = typeInfo.FullName;
_extendedInfo = IsInternal
? string.Format("{0}\n{1}", FullName, Resources.Internal)
: FullName;
if (_typeInfo.IsEnum)
{
var enumValues = _typeInfo.Fields.Where(f => f.Name != "value__").Select(f => f.Name);
if (enumValues.Count() > 0)
{
var values = string.Join("\n", _typeInfo.Fields.Where(f => f.Name != "value__").Select(f => f.Name));
_extendedInfo = string.Format("{0}\n\n{1}", _extendedInfo, values);
}
}
else if (_typeInfo.IsInterface)
{
var members = _typeInfo.Events.Select(m => m.Text)
.Concat(_typeInfo.Properties.Select(p => p.Text))
.Concat(_typeInfo.Methods.Select(p => p.Text));
if (members.Count() > 0)
{
var values = string.Join("\n", members);
_extendedInfo = string.Format("{0}\n\n{1}", _extendedInfo, values);
}
}
if (HasBaseType)
{
var baseType = _typeInfo.BaseType;
_baseTypeName = baseType.Name;
_baseTypeFullName = baseType.FullName;
if (baseType == null)
{
_baseTypeFullName = _baseTypeFullName + "\n" + Resources.NotAvailable;
_isBaseTypeAvailable = false;
}
}
var properties = typeInfo.Properties
.Where(p => p.IsPublic)
.Select(p => new PropertyViewModel(p))
.OfType<MemberViewModel>();
var events = typeInfo.Events
.Where(e => e.IsPublic)
.Select(e => new EventViewModel(e))
.OfType<MemberViewModel>();
var methods = typeInfo.Methods
.Where(m => m.IsPublic)
.Select(m => new MethodViewModel(m))
.OfType<MemberViewModel>();
Members = properties.Concat(events).Concat(methods);
_membersCount = typeInfo.MembersCount;
VisualizeCommand = new DelegateCommand(VisualizeCommandHandler);
NavigateCommand = new DelegateCommand(NavigateCommandHandler);
NavigateToBaseCommand = new DelegateCommand(NavigateToBaseCommandHandler);
ShowMembersCommand = new DelegateCommand(ShowMembersCommandHandler);
BrowseAncestryCommand = new DelegateCommand(BrowseAncestryCommandHandler);
BrowseInteractionsCommand = new DelegateCommand(BrowseInteractionsCommandHandler);
ExpandCommand = new DelegateCommand(ExpandCommandHandler);
RefreshBackground();
ResetName();
}
