public IActionResult DataPicker([FromQuery] int docId, [FromQuery] int?pageIndex,
[FromQuery] string?oldPath, [FromQuery] string target, [FromQuery] bool multiplesCanBePicked)
{
var sampleData = _fileDatabase.GetSampleData();
var project = _fileDatabase.GetDocumentById(docId);
string[]? repeat = null;
if (pageIndex is not null)
{
var page = project.Pages[pageIndex.Value];
if (page.RepeatMode.Repeats)
{
repeat = page.RepeatMode.DataPath;
}
}
var prev = Array.Empty <string>();
if (!string.IsNullOrWhiteSpace(oldPath))
{
prev = oldPath.Split('.');
}
var tree = JsonDataReader.BuildDataSourcePicker(project, sampleData, prev, repeat, pageIndex, multiplesCanBePicked);
var list = JsonDataReader.FlattenTree(tree);
var model = new DataSourceViewModel
{
Nodes = list, Target = target
};
return(PartialView("DataPathPicker", model) !);
}
private void AppendMethod(SiteDb siteDb, List <DataMethodSetting> methods, bool isGlobal, List <DataSourceViewModel> target)
{
var groups = methods.GroupBy(o => o.DeclareType);
foreach (var item in groups)
{
var dataSource = target.FirstOrDefault(o => o.Type == item.Key);
if (dataSource == null)
{
var first = item.FirstOrDefault();
dataSource = new DataSourceViewModel()
{
Type = item.Key
};
if (first != null)
{
dataSource.IsThridPartyDataSource = first.IsThirdPartyType;
dataSource.TypeHash = first.DeclareTypeHash;
}
target.Add(dataSource);
}
// TODO... check that kind of datamethod that is from code.
foreach (var dataMethod in item)
{
dataSource.AddMethod(siteDb, dataMethod, isGlobal);
}
}
}
public IActionResult DataSource(int dataSourceId)
{
DataSourceViewModel dataSourceViewModel = new DataSourceViewModel(_appConfiguration, HttpContext.Request);
dataSourceViewModel.DataSource = new AdminFacade(_appConfiguration, _memoryCache).GetDataSource(dataSourceId);
return(View(dataSourceViewModel));
}
public ActionResult Index()
{
var dataSources = new Entities().DataSources.ToList();
var vm = new DataSourceViewModel();
vm.SetDashboard(dataSources);
return(View(vm));
}
public async Task <IActionResult> ChooseDataSource(string id)
{
var sensors = await this.sensorService.ListSensorsAsync();
var model = new DataSourceViewModel()
{
SensorApi = sensors.Select(se => new SensorAPIViewModel(se))
};
return(View(model));
}
public void SetUp()
{
_settings = new DataSource();
_logFile = new Mock<ILogFile>();
_dataSource = new Mock<IDataSource>();
_dataSource.Setup(x => x.UnfilteredLogFile).Returns(_logFile.Object);
_dataSource.Setup(x => x.Settings).Returns(_settings);
_dataSource.SetupProperty(x => x.LastViewed);
_dataSource.Setup(x => x.Search).Returns(new Mock<ILogFileSearch>().Object);
_dataSource.SetupProperty(x => x.VisibleLogLine);
_viewModel = new DataSourceViewModel(_dataSource.Object);
}
public void SetUp()
{
_settings = new DataSource();
_logFile = new Mock <ILogFile>();
_dataSource = new Mock <IDataSource>();
_dataSource.Setup(x => x.UnfilteredLogFile).Returns(_logFile.Object);
_dataSource.Setup(x => x.Settings).Returns(_settings);
_dataSource.SetupProperty(x => x.LastViewed);
_dataSource.Setup(x => x.Search).Returns(new Mock <ILogFileSearch>().Object);
_dataSource.SetupProperty(x => x.VisibleLogLine);
_viewModel = new DataSourceViewModel(_dataSource.Object);
}
public List <DataSourceViewModel> Datasource(ApiCall call)
{
List <DataSourceViewModel> dataSourceList = new List <DataSourceViewModel>();
foreach (var item in GlobalDb.DataMethodSettings.All().GroupBy(o => o.DeclareType))
{
List <DataMethodViewModel> dataSourceMethods = new List <DataMethodViewModel>();
var methodlist = item.ToList();
foreach (var methoditem in methodlist)
{
DataMethodViewModel onemethod = new DataMethodViewModel
{
Id = methoditem.Id,
IsGlobal = true,
IsConfigurable = methoditem.Parameters.Any(),
MethodName = methoditem.MethodName,
DisplayName = methoditem.DisplayName,
OriginalMethodName = methoditem.OriginalMethodName,
MethodSignatureHash = methoditem.MethodSignatureHash,
Parameters = methoditem.Parameters
};
dataSourceMethods.Add(onemethod);
}
DataSourceViewModel datasource = new DataSourceViewModel
{
Type = methodlist[0].DeclareType,
IsThridPartyDataSource = methodlist[0].IsThirdPartyType,
TypeHash = methodlist[0].DeclareTypeHash
};
var existing = dataSourceList.Find(o => o.TypeHash == datasource.TypeHash);
if (existing != null)
{
existing.Methods.AddRange(dataSourceMethods);
}
else
{
datasource.Methods = dataSourceMethods;
dataSourceList.Add(datasource);
}
}
return(dataSourceList);
}
private static void ComboboxSelectionChnaged(object sender, SelectionChangedEventArgs e)
{
DataSourceViewModel DSViewModel = (DataSourceViewModel)testCaseTreeView.SelectedItem;
ComboBox combo = (ComboBox)sender;
DataSource ds = (DataSource)combo.SelectedValue;
DSViewModel.SelectedIndex = combo.SelectedIndex;
if (ds.Name.Equals("Database"))
{
DealWithDataBase(DSViewModel.SelectedDataSource);
}
if (ds.Name.Equals("Excel Sheet"))
{
DealWithExcelSheet(DSViewModel.SelectedDataSource);
}
}
public void SetUp()
{
_settings = new DataSource();
_logFile = new Mock <ILogSource>();
_dataSource = new Mock <IDataSource>();
_dataSource.Setup(x => x.UnfilteredLogSource).Returns(_logFile.Object);
_dataSource.Setup(x => x.Settings).Returns(_settings);
_dataSource.SetupProperty(x => x.LastViewed);
_dataSource.Setup(x => x.Search).Returns(new Mock <ILogSourceSearch>().Object);
_dataSource.SetupProperty(x => x.VisibleLogLine);
var actionCenter = new Mock <IActionCenter>();
var applicationSettings = new Mock <IApplicationSettings>();
_viewModel = new DataSourceViewModel(_dataSource.Object, actionCenter.Object, applicationSettings.Object);
}
private static void ExcelSheetDetailsEdited(object sender, RoutedEventArgs e)
{
if (!testCaseTreeView.SelectedItem.GetType().Name.Equals("DataSourceViewModel"))
{
return;
}
DataSourceViewModel datasourceVM = (DataSourceViewModel)testCaseTreeView.SelectedItem;
ExcelSheet excel = null;
if (datasourceVM.SelectedDataSource == null || datasourceVM.SelectedDataSource.GetType().Name != "ExcelSheet")
{
excel = new ExcelSheet();
}
else
{
excel = (ExcelSheet)datasourceVM.SelectedDataSource;
}
var children = child_grid.Children;
foreach (var child in children)
{
object element = ((Border)child).Child;
Type type = element.GetType();
if (type.Name.Equals("TextBox"))
{
if (((TextBox)element).Name.Equals("ExcelSheetPath"))
{
excel.ExcelSheetPath = ((TextBox)element).Text;
}
}
else if (type.Name.Equals("CheckBox"))
{
if (((CheckBox)element).Name.Equals("IsFirstRowHeader"))
{
excel.FirstRowContainsHeader = ((CheckBox)element).IsChecked.Value;
}
}
}
((DataSourceViewModel)testCaseTreeView.SelectedItem).SelectedDataSource = excel;
}
public IActionResult Filter(DataSource dataSource)
{
DataSourceViewModel model = new DataSourceViewModel();
IContext context = new Context();
if (dataSource == null || string.IsNullOrEmpty(dataSource.Body))
{
return(RedirectToAction("Filter"));
}
// Store the original data
_databaseManager.Add(new Source()
{
Body = dataSource.Body
});
// Convert textarea data into list of strings
context.SetBody(new List <string>(
dataSource.Body.Split(
new string[] { "\r\n" },
StringSplitOptions.RemoveEmptyEntries
)
));
this._pipelineManager.Register(this._filterFactory.GetFilter("CircularShiftFilter"))
.Register(this._filterFactory.GetFilter("AlphabetizerFilter"))
.Register(this._filterFactory.GetFilter("NoiseWordFilter"));
stopWatch.Start();
model.ContextBody = this._pipelineManager.PerformOperation(context)
.GetOutput();
stopWatch.Stop();
model.Time = stopWatch.Elapsed.TotalMilliseconds / 1000;
// Store the kwic output in the database (from list to string)
_databaseManager.AddKWIC(new KWICSource()
{
Body = String.Join("\r\n", model.ContextBody)
});
model.Body = string.Join("\n", model.ContextBody.ToArray());
return(View("Filter", model));
}
private void New_DataSource_Button_Click(object sender, RoutedEventArgs e)
{
object element = this.viewModel.RoboViewModel.SelectedNode;
if (element != null && element.GetType().Name.Equals("TestSuitViewModel"))
{
TestSuitViewModel elementModel = (TestSuitViewModel)element;
DataSourceViewModel ds = new DataSourceViewModel();
ds.Name = "3rd Data Source";
ds.Description = "3rd DS desc";
elementModel.AllCollection.Add(ds);
elementModel.IsExpanded = true;
ds.IsSelected = true;
}
else
{
MessageBox.Show("Please select the suit under which new Data Source to be added.", "Error", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
protected override void OnLoad(string filename)
{
if (File.Exists(filename) == false)
{
return;
}
var doc = new XmlDocument();
doc.Load(filename);
foreach (XmlElement dataSourceNode in doc.SelectNodes("SignalVisualizer/DataSources/DataSource"))
{
try
{
var isRunning = XmlConvert.ToBoolean(dataSourceNode.Attributes["IsRunning"].Value);
var guid = XmlConvert.ToGuid(dataSourceNode.Attributes["Guid"].Value);
DataSourceViewModel vm = rootViewModel.DataSourceViewModels.FirstOrDefault(svm => svm.DataSource.UniqueIdentifier == guid);
if (vm != null)
{
vm.DataSource.Load(dataSourceNode.ChildNodes.OfType <XmlElement>().FirstOrDefault());
if (isRunning)
{
vm.Start();
}
}
}
catch { }
}
rootViewModel.Groups.Clear();
foreach (XmlElement groupNode in doc.SelectNodes("SignalVisualizer/Groups/Group"))
{
var group = rootViewModel.AddGroup();
group.LoadLayout(groupNode);
}
}
public bool Serialize(XmlTextWriter w, RoboViewModel robo)
{
this.writer = w;
Type suitCollectionType = new ObservableCollection <TestSuitViewModel>().GetType();
Type sequenceCollectionType = new ObservableCollection <TestSequenceViewModel>().GetType();
Type stepCollectionType = new ObservableCollection <TestStepViewModel>().GetType();
Type appsCollectionType = new ObservableCollection <AppsViewModel>().GetType();
Type dataSourceCollectionType = new ObservableCollection <DataSourceViewModel>().GetType();
Type variableCollectionType = new ObservableCollection <VariableViewModel>().GetType();
Type stringType = string.Empty.GetType();
Type boolType = bool.TrueString.GetType();
Type intType = int.MinValue.GetType();
Type doubleType = double.MinValue.GetType();
Type suitType = new TestSuitViewModel().GetType();
Type seqType = new TestSequenceViewModel().GetType();
Type stepType = new TestStepViewModel().GetType();
Type appType = new AppsViewModel().GetType();
Type dsType = new DataSourceViewModel().GetType();
Type varType = new VariableViewModel().GetType();
Type[] types = { suitCollectionType, sequenceCollectionType, stepCollectionType, appsCollectionType,
dataSourceCollectionType, variableCollectionType, stringType, boolType, intType, doubleType,
suitType, seqType, stepType, appType, dsType, varType };
writer.WriteStartDocument(true);
writer.Formatting = Formatting.Indented;
writer.Indentation = 2;
writer.WriteStartElement("Suits");
AppendNodeRobo(types, robo);
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Close();
return(true);
}
private PlayedGameDataSourcesViewModel MapPlayedGamesDataSources(PlayedGameDataSourcesDto data)
{
PlayedGameDataSourcesViewModel dataSourceViewModel = new PlayedGameDataSourcesViewModel()
{
Teams = new Dictionary <int, DataSourceViewModel>(),
Results = new Dictionary <int, DataSourceViewModel>()
};
foreach (var teamItem in data.Teams)
{
DataSourceViewModel sourceViewModel = Mapper.Map <DataSourceDto, DataSourceViewModel>(teamItem.Value);
dataSourceViewModel.Teams.Add(teamItem.Key, sourceViewModel);
}
foreach (var resultItem in data.Results)
{
DataSourceViewModel sourceViewModel = Mapper.Map <DataSourceDto, DataSourceViewModel>(resultItem.Value);
dataSourceViewModel.Results.Add(resultItem.Key, sourceViewModel);
}
return(dataSourceViewModel);
}
private static void DataBaseDetailsEdited(object sender, RoutedEventArgs e)
{
DataSourceViewModel datasourceVM = (DataSourceViewModel)testCaseTreeView.SelectedItem;
DataBase tempDB = null;
if (datasourceVM.SelectedDataSource == null || datasourceVM.SelectedDataSource.GetType().Name != "DataBase")
{
tempDB = new DataBase();
}
else
{
tempDB = (DataBase)datasourceVM.SelectedDataSource;
}
var children = child_grid.Children;
foreach (var child in children)
{
object element = ((Border)child).Child;
Type type = element.GetType();
if (type.Name.Equals("ComboBox"))
{
if (((ComboBox)element).Name.Equals("DataBaseType"))
{
if (((ComboBox)element).SelectedValue != null)
{
tempDB.SelectedDataBaseType = ((ComboBox)element).SelectedValue.ToString();
}
}
}
if (type.Name.Equals("TextBox"))
{
if (((TextBox)element).Name.Equals("DataBaseHost"))
{
tempDB.DatabaseHost = ((TextBox)element).Text;
}
else if (((TextBox)element).Name.Equals("DataBasePort"))
{
tempDB.DatabasePort = ((TextBox)element).Text;
}
else if (((TextBox)element).Name.Equals("UserName"))
{
tempDB.UserName = ((TextBox)element).Text;
}
else if (((TextBox)element).Name.Equals("Query"))
{
tempDB.Query = ((TextBox)element).Text;
}
}
if (type.Name.Equals("PasswordBox"))
{
if (((PasswordBox)element).Name.Equals("Password"))
{
tempDB.Password = ((PasswordBox)element).Password;
}
}
}
((DataSourceViewModel)testCaseTreeView.SelectedItem).SelectedDataSource = tempDB;
}
internal static void DealWithDataSourceViewModel(DataSourceViewModel TSModel, Grid maingrid, Grid childGrid, Grid support_grid, TreeView TestCaseTreeView)
{
main_grid = maingrid;
child_grid = childGrid;
help_grid = support_grid;
testCaseTreeView = TestCaseTreeView;
string name = TSModel.Name;
string desc = TSModel.Description;
int SelectedIndex = TSModel.SelectedIndex;
if (TSModel.SourceTypes.Count == 0)
{
TSModel.SourceTypes.Add(new DataSource("Database"));
TSModel.SourceTypes.Add(new DataSource("Excel Sheet"));
TSModel.SourceTypes.Add(new DataSource("CSV File"));
}
ObservableCollection <DataSource> SourceTypes = TSModel.SourceTypes;
Label labelName = new Label();
labelName.Content = "Name";
addToGrid(main_grid, labelName, 0, true);
TextBox txtName = new TextBox();
txtName.Text = name;
addToGrid(main_grid, txtName, 1, false);
Label labelDesc = new Label();
labelDesc.Content = "Description";
addToGrid(main_grid, labelDesc, 0, true);
TextBox txtDesc = new TextBox();
txtDesc.TextWrapping = TextWrapping.Wrap;
txtDesc.VerticalScrollBarVisibility = ScrollBarVisibility.Visible;
txtDesc.MinHeight = 70;
txtDesc.Text = desc;
addToGrid(main_grid, txtDesc, 1, false);
Label labelDS = new Label();
labelDS.Content = "Data Source Type";
addToGrid(main_grid, labelDS, 0, true);
ComboBox comboDS = new ComboBox();
comboDS.SelectionChanged += new SelectionChangedEventHandler(ComboboxSelectionChnaged);
Binding bind = new Binding();
bind.Source = SourceTypes;
comboDS.DisplayMemberPath = "Name";
comboDS.SetBinding(ComboBox.ItemsSourceProperty, bind);
addToGrid(main_grid, comboDS, 1, false);
comboDS.SelectedIndex = SelectedIndex;
main_grid.LostFocus += new RoutedEventHandler(DSMainGridDetailsEdited);
}
