/// <summary> /// Create new instance. /// </summary> /// <param name="targetFolder"> /// Target repository folder. /// </param> /// <param name="backwards"> /// Whether to iterate backwards. /// </param> /// <exception cref="ObjectDisposedException"> /// The target repository instance is disposed. /// </exception> /// <exception cref="InvalidOperationException"> /// The <paramref name="targetFolder"/> is detached. /// </exception> public DataFileIterator(IRepositoryFolder targetFolder, bool backwards) { RepositoryFolder.CheckNotDetached(targetFolder); _targetFolder = RepositoryFolder.CastFolder(targetFolder); _backwards = backwards; Current = NextForward = NextBackwards = Next = Previous = null; }
/// <summary> /// Initialise iteration position. /// </summary> /// <param name="seekTime"> /// Data timestamp; files containig data items with the timestamp will be iterated. /// </param> /// <param name="backwards"> /// Direction in which to search for data files if the <paramref name="seekTime"/> is not covered by any /// existing data file /// </param> /// <returns> /// First found data file; null if none found. /// </returns> /// <remarks> /// The data in a data file does not have to be entirely in the specified datetime range for the file to be iterated. If any data in the file /// falls in the sought range it will be returned by the iterator. /// </remarks> /// <exception cref="ObjectDisposedException"> /// The target repository instance is disposed. /// </exception> /// <exception cref="InvalidOperationException"> /// The <paramref name="targetFolder"/> is detached. /// </exception> public IRepositoryFile Seek(DateTime seekTime, bool backwards) { RepositoryFolder.CheckNotDetached(Folder); DateTime seekTimeCorrected; IRepositoryFile currentFile = _targetFolder.RootDataFolder.Seek(seekTime, backwards); if (currentFile != null) { seekTimeCorrected = currentFile.Name.FirstItemTimestamp; } else { seekTimeCorrected = seekTime; } SeekExact(seekTimeCorrected); Check.Ensure(Current == null || Current.Name == currentFile.Name, "Seek results differ"); Check.Ensure(Current == null || GetComparer(backwards).Compare( backwards ? Current.Name.FirstItemTimestamp : Current.Name.LastItemTimestamp , seekTime ) >= 0 ); Check.Ensure(NextBackwards == null || NextBackwards.Name.End <= seekTime); Check.Ensure(NextForward == null || NextForward.Name.FirstItemTimestamp > seekTime); return(Current); }
public ActivitiesRepositoryPage(RepositoryFolder <Activity> activitiesFolder, Context context, ObservableList <Guid> Tags = null, RoutedEventHandler AddActivityHandler = null, ePageViewMode viewMode = ePageViewMode.Default) { InitializeComponent(); mActivitiesFolder = activitiesFolder; mContext = context; /* * if (Tags != null) * { * mTags = Tags; * xActivitiesRepositoryListView.Tags = mTags; * } * * if (AddActivityHandler != null) * mAddActivityHandler = AddActivityHandler; * else * mAddActivityHandler = AddFromRepository; * * mViewMode = viewMode; */ SetActivitiesRepositoryListView(); SetGridAndTreeData(); }
/// <summary> /// Only set current if owns the <paramref name="seekTime"/>. Set next and previous as per <paramref name="seekTime"/> /// </summary> /// <param name="seekTime"> /// Data timestamp /// </param> /// <returns> /// Existing <see cref="IRepositoryFile"/> if it covers the <paramref name="seekTime"/>. /// <see langword="null"/> otherwise /// </returns> /// <exception cref="ObjectDisposedException"> /// The target repository instance is disposed. /// </exception> /// <exception cref="InvalidOperationException"> /// The <paramref name="targetFolder"/> is detached. /// </exception> public IRepositoryFile SeekExact(DateTime seekTime) { RepositoryFolder.CheckNotDetached(Folder); IRepositoryFile owner; IRepositoryFile predecessor; IRepositoryFile successor; _targetFolder.RootDataFolder.CutDataFiles(seekTime, out predecessor, out owner, out successor); Current = owner; NextBackwards = predecessor; NextForward = successor; if (Backwards) { Next = NextBackwards; Previous = NextForward; } else { Next = NextForward; Previous = NextBackwards; } return(Current); }
/// <summary> /// Add folder to read and optionally prepare it for reading /// </summary> /// <param name="folder"> /// Folder to add /// </param> /// <param name="position"> /// <see langword="null"/> means do not prepare it for reading /// </param> /// <returns> /// <see langword="false"/> - the folder is already being read /// <see langword="true"/> otherwise /// </returns> /// <remarks> /// If reader has data (<see cref="HasData"/>) <paramref name="position"/> must have value /// </remarks> private bool AddFolderImpl(IRepositoryFolder folder, IFolderReadingPosition position) { Check.RequireArgumentNotNull(folder, "folder"); IFolder folderTyped = RepositoryFolder.CastFolder(folder); Check.Require(object.ReferenceEquals(folder.Repository, Repository)); Check.Require(!HasData || position != null, "If we have data we cannot leave a reader unpositioned"); if (IsAccessing(folder, false)) { return(false); } Check.Require(!_position.FolderPositions.ContainsKey(folder.FolderKey) , "Folder position found in repository reader position for a folder not being read"); RepositoryFolderReader reader = new RepositoryFolderReader(folderTyped, this); reader.Direction = this.Direction; _readers.Add(folder.FolderKey, reader); if (position != null) { SeekFolderReader(reader, position); } return(true); }
private bool ChangeAPIMapping(bool showNewMappingMessage = false) { ObservableList <ApplicationAPIModel> APIModelsList = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <ApplicationAPIModel>(); if (APIModelsList.Count == 0) { Reporter.ToUser(eUserMsgKey.NoAPIExistToMappedTo); return(false); } if (showNewMappingMessage) { Reporter.ToUser(eUserMsgKey.APIMappedToActionIsMissing); } if (apiModelPage == null) { RepositoryFolder <ApplicationAPIModel> APIModelsFolder = WorkSpace.Instance.SolutionRepository.GetRepositoryItemRootFolder <ApplicationAPIModel>(); AppApiModelsFolderTreeItem apiRoot = new AppApiModelsFolderTreeItem(APIModelsFolder); apiModelPage = new SingleItemTreeViewSelectionPage("API Models", eImageType.APIModel, apiRoot, SingleItemTreeViewSelectionPage.eItemSelectionType.Single, true, new Tuple <string, string>(nameof(ApplicationPOMModel.TargetApplicationKey) + "." + nameof(ApplicationPOMModel.TargetApplicationKey.ItemName), Convert.ToString(AAMB.TargetApplicationKey))); } List <object> selectedList = apiModelPage.ShowAsWindow(); if (selectedList != null && selectedList.Count == 1) { AAMB = (ApplicationAPIModel)selectedList[0]; mAct.APImodelGUID = AAMB.Guid; return(true); } return(false); }
public static RunSetConfig CreateNewRunset(string runSetName = "", RepositoryFolder <RunSetConfig> runSetsFolder = null) { if (string.IsNullOrEmpty(runSetName)) { if (!InputBoxWindow.GetInputWithValidation(string.Format("Add New {0}", GingerDicser.GetTermResValue(eTermResKey.RunSet)), string.Format("{0} Name:", GingerDicser.GetTermResValue(eTermResKey.RunSet)), ref runSetName, System.IO.Path.GetInvalidPathChars())) { return(null); } } RunSetConfig runSetConfig = new RunSetConfig(); runSetConfig.Name = runSetName; runSetConfig.GingerRunners.Add(new GingerRunner() { Name = "Runner 1" }); if (runSetsFolder == null) { WorkSpace.Instance.SolutionRepository.AddRepositoryItem(runSetConfig); } else { runSetsFolder.AddRepositoryItem(runSetConfig); } return(runSetConfig); }
public ActivitiesRepositoryPage(RepositoryFolder <Activity> activitiesFolder, Context context, ObservableList <Guid> Tags = null, RoutedEventHandler AddActivityHandler = null, ePageViewMode viewMode = ePageViewMode.Default) { InitializeComponent(); mActivitiesFolder = activitiesFolder; mContext = context; if (Tags != null) { mTags = Tags; xActivitiesRepositoryGrid.Tags = mTags; } if (AddActivityHandler != null) { mAddActivityHandler = AddActivityHandler; } else { mAddActivityHandler = AddFromRepository; } mViewMode = viewMode; SetActivitiesRepositoryGridView(); SetGridAndTreeData(); }
public void CutPasteAgentFromSubFolderToroot() { //Arrange string name = "Move Me Up"; string folderName = "MySubFolder 2"; AgentsPOM AgentsPOM = mGingerAutomator.MainWindowPOM.GotoAgents(); AgentsPOM.AgentsTree.SelectRootItem(); AgentsPOM.AddSubFolder(folderName); Agent MyAgent = AgentsPOM.CreateAgent(folderName, name, ePlatformType.Web, Agent.eDriverType.SeleniumChrome); //Act AgentsPOM.AgentsTree.SelectItem(name); AgentsPOM.AgentsTree.Cut(); AgentsPOM.AgentsTree.SelectRootItem(); AgentsPOM.AgentsTree.Paste(); bool agentExist = AgentsPOM.AgentsTree.IsItemExist(name); RepositoryFolder <Agent> AgentsFolder = WorkSpace.Instance.SolutionRepository.GetRepositoryItemRootFolder <Agent>(); RepositoryFolder <Agent> subFolder = AgentsFolder.GetSubFolder(folderName); Agent ACopyTag = (from x in subFolder.GetFolderItems() where x.Name == name select x).SingleOrDefault(); // assert Assert.IsTrue(agentExist, "Agent exist"); Assert.IsTrue(ACopyTag != null); Assert.AreEqual(@"~\Agents\" + folderName, ACopyTag.ContainingFolder); Assert.AreEqual(MyAgent, ACopyTag, "Same agent object in memeory"); }
public void StopRecording() { try { PlatformDriver.StopRecording(); if (ListPOMObjectHelper != null) { RepositoryFolder <ApplicationPOMModel> repositoryFolder = WorkSpace.Instance.SolutionRepository.GetRepositoryItemRootFolder <ApplicationPOMModel>(); foreach (var cPom in ListPOMObjectHelper) { if (!string.IsNullOrEmpty(cPom.PageTitle) && !string.IsNullOrEmpty(cPom.PageURL)) { try { PomLearnUtils utils = new PomLearnUtils(cPom.ApplicationPOM); cPom.ApplicationPOM.ContainingFolder = repositoryFolder.FolderRelativePath; cPom.ApplicationPOM.ContainingFolderFullPath = repositoryFolder.FolderFullPath; utils.SaveLearnedPOM(); } catch (Exception e) { WorkSpace.Instance.SolutionRepository.AddRepositoryItem(cPom.ApplicationPOM); Reporter.ToLog(eLogLevel.ERROR, "Error while saving the POM", e); } } } } } catch (Exception ex) { Reporter.ToLog(eLogLevel.ERROR, "Error in Stop recording", ex); } }
/// <summary> /// Get data file iterator. /// </summary> /// <param name="folder"> /// Folder whose data files to iterate over. /// </param> /// <param name="backwards"> /// Initial iteration direction. /// </param> /// <returns> /// <see cref="IDataFileIterator"/> /// </returns> /// <remarks> /// Note that you must call one of the Seek methods to start iteration after the iterator instance is created. /// </remarks> public IDataFileIterator GetDataFileIterator(IRepositoryFolder folder, bool backwards) { CheckHelper.CheckRepositoryNotDisposed(Repository); Check.DoRequireArgumentNotNull(folder, "folder"); RepositoryFolder.CheckNotDetached(folder); return(new DataFileIterator(folder, backwards)); }
public void DeleteBfsSubFolderWithAllItemsLoaded() { //Arrange ObservableList <MyRepositoryItem> MRIs = mSolutionRepository.GetAllRepositoryItems <MyRepositoryItem>(); //add new sub folder with new bf's to be deleted RepositoryFolder <MyRepositoryItem> MRIRF = mSolutionRepository.GetRepositoryItemRootFolder <MyRepositoryItem>(); RepositoryFolder <MyRepositoryItem> folderToDelete = (RepositoryFolder <MyRepositoryItem>)MRIRF.AddSubFolder("DeleteSubFolder_FolderForDelete"); MyRepositoryItem MRI1 = new MyRepositoryItem("DeleteSubFolder_MRI1"); folderToDelete.AddRepositoryItem(MRI1); MyRepositoryItem MRI2 = new MyRepositoryItem("DeleteSubFolder_MRI2"); folderToDelete.AddRepositoryItem(MRI2); //add new sub-sub folder with new MRI's to be deleted RepositoryFolder <MyRepositoryItem> subfolderToDelete = (RepositoryFolder <MyRepositoryItem>)folderToDelete.AddSubFolder("DeleteSubFolder_subfolderToDelete"); MyRepositoryItem MRI3 = new MyRepositoryItem("DeleteSubFolder_MRI3"); subfolderToDelete.AddRepositoryItem(MRI3); //Act mSolutionRepository.DeleteRepositoryItemFolder(folderToDelete); //Assert Assert.IsTrue(Directory.Exists(folderToDelete.FolderFullPath) == false); Assert.AreEqual((mSolutionRepository.GetRepositoryItemByGuid <MyRepositoryItem>(MRI1.Guid)), null, "make sure all deleted folder items were removed from cache"); Assert.AreEqual((mSolutionRepository.GetRepositoryItemByGuid <MyRepositoryItem>(MRI3.Guid)), null, "make sure all deleted folder sub folder items were removed from cache"); }
/// <summary> /// Check read and/or write access status to the <paramref name="folder"/>. /// </summary> /// <param name="folder"> /// Folder to check current access to. /// </param> /// <param name="subtree"> /// Whether to check access to all folders in the subtree or only to the <paramref name="folder"/> itself /// </param> /// <param name="read"> /// Whether to check read access, i.e. whether target folder[s] is/are being read from /// </param> /// <param name="write"> /// Whether to check write access, i.e. whether target folder[s] is/are being written to /// </param> /// <remarks> /// Access to readers and writers registry is synchronised; all concurrent calls accessing registry of readers and writers /// will wait until this method finishes. /// </remarks> private bool IsDataBeingAccessed(IRepositoryFolder folder, bool subtree, bool write, bool read) { Exceptions.DifferentRepositoriesExceptionHelper.Check(this, folder.Repository); Util.Check.Require(write || read); IFolder f = RepositoryFolder.CastFolder(folder, "folder"); bool retval = false; _dataAccessorRegistryLock.EnterReadLock(); try { if (read) { retval = IsDataBeingAccessed(_readers, f, subtree); } if (!retval && write) { retval = IsDataBeingAccessed(_writers, f, subtree); } } finally { _dataAccessorRegistryLock.ExitReadLock(); } return(retval); }
protected List <ITreeViewItem> GetChildrentGeneric <T>(RepositoryFolder <T> RF, string OrderBy) { List <ITreeViewItem> Childrens = new List <ITreeViewItem>(); ObservableList <RepositoryFolder <T> > subFolders = RF.GetSubFolders(); foreach (RepositoryFolder <T> envFolder in subFolders) { Childrens.Add(GetTreeItem(envFolder)); } subFolders.CollectionChanged -= TreeFolderItems_CollectionChanged; // track sub folders subFolders.CollectionChanged += TreeFolderItems_CollectionChanged; // track sub folders //Add direct childrens ObservableList <T> folderItems = RF.GetFolderItems(); // why we need -? in case we did refresh and reloaded the item TODO: research, make children called once folderItems.CollectionChanged -= TreeFolderItems_CollectionChanged; folderItems.CollectionChanged += TreeFolderItems_CollectionChanged;//adding event handler to add/remove tree items automatically based on folder items collection changes foreach (T item in folderItems.OrderBy(OrderBy)) { ITreeViewItem tvi = GetTreeItem(item); Childrens.Add(tvi); } return(Childrens); }
private void CreateTestFolders(List <RepositoryFolder> folderList, int level) { if (level > MaxLevel) { return; } for (var i = 0; i < NumberOfFoldersPerLevel; i++) { var folderParts = folderTestData[folderIndexCounter].Split(';'); var newFolder = new RepositoryFolder { Id = folderParts[0], LogicalName = folderParts[1] }; folderList.Add(newFolder); folderIndexCounter++; if (folderIndexCounter == folderTestData.Length) { folderIndexCounter = 0; } // Create subfolders CreateTestFolders(newFolder.Folders, level + 1); CreateTestFiles(newFolder.Files); } }
public ActivitiesRepositoryPage(RepositoryFolder <Activity> activitiesFolder, BusinessFlow businessFlow = null, ObservableList <Guid> Tags = null, RoutedEventHandler AddActivityHandler = null) { InitializeComponent(); mActivitiesFolder = activitiesFolder; if (Tags != null) { mTags = Tags; xActivitiesRepositoryGrid.Tags = mTags; } if (AddActivityHandler != null) { mAddActivityHandler = AddActivityHandler; } else { mAddActivityHandler = AddFromRepository; } mBusinessFlow = businessFlow; mContext.BusinessFlow = mBusinessFlow; SetActivitiesRepositoryGridView(); SetGridAndTreeData(); }
/// <summary> /// LOADS A WEB.CONFIG SECTION INTO A REPOSITORYSETTINGS CLASS /// </summary> /// <param name="section">XML NODE WHICH CONTAINS CONFIG TO LOAD</param> /// <returns>RETURNS A LOADED REPOSITORY SETTINGS CLASS</returns> public static RepositorySettings LoadFromXml(XmlNode section) { RepositorySettings tmpReturn = new RepositorySettings(); RepositoryFolder tmpRepoFolder; //LOOP THROUGH EACH DATASTORE NODE AND ADD THEM TO THE LIST OF REPO FOLDERS foreach (XmlNode tmpNode in section.SelectNodes("DataStore")) { //DETECT IF ITS AN ABSOLUTE PATH OF A PARTIAL PATH if (tmpNode.Attributes["Path"].Value.StartsWith("~")) { tmpRepoFolder = new RepositoryFolder(HttpContext.Current.Server.MapPath(tmpNode.Attributes["Path"].Value), tmpNode.Attributes["AccessMode"].Value.ToLower()); } else { tmpRepoFolder = new RepositoryFolder(tmpNode.Attributes["Path"].Value, tmpNode.Attributes["AccessMode"].Value); } //ADD THE REPO FOLDER TO THE LIST OF FOLDERS RETURNING tmpReturn.mRepositoryFolders.Add(tmpRepoFolder); } //VALIDATE THE CONTENTS OF THE RETURN if (!ValidateConfig(tmpReturn)) { return(null); } else { return(tmpReturn); } }
/// <summary> /// Set custom property value. /// </summary> /// <param name="name"> /// Property name. /// </param> /// <param name="value"> /// Property value. Specify null to remove property. /// </param> /// <remarks> /// Every repository folder can have an arbitrary set of named string properties. This should not be overused as the storage is not optimised for performance and /// large volumes of data. /// If property with the specified name is already set it will be overwritten. To remove a propert set its value to null. /// The value is immediately saved to disk. /// </remarks> /// <seealso cref="GetCustomProperty(string)"/> public void SetCustomProperty(string name, string value) { RepositoryFolder.CheckNotDetached(_folder); Check.RequireArgumentNotNull(name, "name"); NameValuePair pair = FindCustomProperty(name); if (pair != null) { if (value == null) { _folderConfig.Config.CustomParameters.Remove(pair); } else { pair.Value = value; } } else { _folderConfig.Config.CustomParameters.Add(new NameValuePair() { Name = name, Value = value }); } Save(); }
private void InitControls() { //TODO: uncomments once we have BusinessFlowsFolderTreeItem which get RF //RepositoryFolder<BusinessFlow> RF1 = mSolutionRepository.GetRepositoryItemRootFolder<BusinessFlow>(); //BusinessFlowsFolderTreeItem t = new BusinessFlowsFolderTreeItem(RF1); //TVFrame.SetContent(new TreeViewExplorerPage(t)); RepositoryFolder <BusinessFlow> RF2 = mSolutionRepository.GetRepositoryItemRootFolder <BusinessFlow>(); ObservableList <BusinessFlow> BFs = RF2.GetFolderItems(); Grid1.ItemsSource = BFs; RepositoryFolder <BusinessFlow> RF3 = mSolutionRepository.GetRepositoryItemRootFolder <BusinessFlow>(); ObservableList <BusinessFlow> BFs2 = RF3.GetFolderItems(); Grid2.ItemsSource = BFs2; // EnvsComboBox.in EnvsListBox.ItemsSource = mSolutionRepository.GetAllRepositoryItems <ProjEnvironment>(); EnvsListBox.DisplayMemberPath = nameof(ProjEnvironment.Name); EnvsComboBox.ItemsSource = mSolutionRepository.GetAllRepositoryItems <ProjEnvironment>(); EnvsComboBox.DisplayMemberPath = nameof(ProjEnvironment.Name); // Go get first env Guid Guid guid = mSolutionRepository.GetAllRepositoryItems <ProjEnvironment>()[0].Guid; ProjEnvironment env1 = mSolutionRepository.GetRepositoryItemByGuid <ProjEnvironment>(guid); EnvNameTextBox.BindControl(env1, nameof(ProjEnvironment.Name)); AllBFsListBox.ItemsSource = mSolutionRepository.GetAllRepositoryItems <BusinessFlow>(); AllBFsListBox.DisplayMemberPath = nameof(BusinessFlow.Name); }
private void LoadRepositories(ICollection <string> collection) { LocationTree.ItemsSource = new List <IRepoControl>(); LocationList.Clear(); foreach (string url in collection) { string[] parts = url.Split(urlSplitChars, StringSplitOptions.RemoveEmptyEntries); if (parts.Length == 0) { return; } RepositoryFolder currentNode = LocationTree; for (int i = 0; i < parts.Length - 1; i++) { currentNode = currentNode.GetOrAddChildFolder(parts[i]); } LocationList.Add(currentNode.AddChildRepository(parts[parts.Length - 1], url, NewItem_Checked)); } LocationList.Sort((c1, c2) => c1.Content.ToString().CompareTo(c2.Content.ToString())); }
private static List <T> GetDataAccessors <T>( LinkedList <Util.WeakReferenceT <T> > list , IRepositoryFolder folder , bool subtree , bool firstOnly) where T : class, IRepositoryDataAccessor { List <T> retval = new List <T>(); for (LinkedListNode <Util.WeakReferenceT <T> > node = list.First; node != null;) { LinkedListNode <Util.WeakReferenceT <T> > nextNode = node.Next; IRepositoryDataAccessor accessor = node.Value.Target; if (accessor == null) { _logger.Info("Purging dead accessor"); list.Remove(node); } else { if (accessor.IsAccessing(RepositoryFolder.CastFolder(folder, "folder"), subtree)) { _logger.InfoFormat("GetDataAccessors found alive writer for {0}", folder.LogicalPath); retval.Add((T)accessor); if (firstOnly) { break; } } } node = nextNode; } return(retval); }
private bool ChangeAPIMapping(bool showNewMappingMessage = false) { RepositoryFolder <ApplicationAPIModel> APIModels = WorkSpace.Instance.SolutionRepository.GetRepositoryItemRootFolder <ApplicationAPIModel>(); if (APIModels.GetFolderItems().Count == 0) { Reporter.ToUser(eUserMsgKeys.NoAPIExistToMappedTo); return(false); } if (showNewMappingMessage) { Reporter.ToUser(eUserMsgKeys.APIMappedToActionIsMissing); } if (apiModelPage == null) { AppApiModelsFolderTreeItem apiRoot = new AppApiModelsFolderTreeItem(APIModels); apiModelPage = new SingleItemTreeViewSelectionPage("API Models", eImageType.APIModel, apiRoot, SingleItemTreeViewSelectionPage.eItemSelectionType.Single); } List <object> selectedList = apiModelPage.ShowAsWindow(); if (selectedList != null && selectedList.Count == 1) { AAMB = (ApplicationAPIModel)selectedList[0]; mAct.APImodelGUID = AAMB.Guid; return(true); } return(false); }
private void AddBftoSubFolderButton_Click(object sender, RoutedEventArgs e) { RepositoryFolder <BusinessFlow> root = mSolutionRepository.GetRepositoryItemRootFolder <BusinessFlow>(); RepositoryFolder <BusinessFlow> subfolder = root.GetSubFolders()[0]; BusinessFlow BF = new BusinessFlow("BFSF BF " + DateTime.Now); subfolder.AddRepositoryItem(BF); }
public POMModelsPage(RepositoryFolder <ApplicationPOMModel> POMsFolder) { InitializeComponent(); mPOMsFolder = POMsFolder; SetAPIModelGridData(); SetAPIModelsGridView(); }
public ActionsRepositoryPage(RepositoryFolder <Act> actionsFolder) { InitializeComponent(); mActionsFolder = actionsFolder; SetActionsGridView(); SetGridAndTreeData(); }
public PomLearnUtils(ApplicationPOMModel pom, Agent agent = null, RepositoryFolder <ApplicationPOMModel> pomModelsFolder = null) { POM = pom; mAgent = agent; mPomModelsFolder = pomModelsFolder; mElementsList.CollectionChanged += ElementsListCollectionChanged; }
public BusinessFlowsPage(RepositoryFolder <BusinessFlow> RF) { InitializeComponent(); //Fixme create NewBusinessFlowsFolderTreeItem which get RF //BusinessFlowsFolderTreeItem t = new BusinessFlowsFolderTreeItem(RF); // MainFrame.SetContent(new TreeViewExplorerPage(t)); }
/// <summary> /// Create data file accessor instance. /// </summary> /// <param name="folder"> /// Data folder containig the file. /// </param> /// <param name="file"> /// Data file to be accessed; may not exist on disk. /// </param> /// <returns> /// New <see cref="IDataFileAccessor"/> instance. /// </returns> public IDataFileAccessor GetDataFileAccessor(IDataFolder folder, IRepositoryFileName file) { Check.DoRequireArgumentNotNull(folder, "folder"); Check.DoRequireArgumentNotNull(file, "file"); RepositoryFolder.CheckNotDetached(folder.RepoFolder); return(new RepositoryFileAccessor(folder, file)); }
public ExplorerBusinessFlowsPage(RepositoryFolder <BusinessFlow> repositoryFolder) { InitializeComponent(); grdBusinessFlows.btnRefresh.Visibility = Visibility.Collapsed; SetBusinessFlowsGridView(); grdBusinessFlows.DataSourceList = repositoryFolder.GetFolderItems(); }
public VariablesRepositoryPage(RepositoryFolder <VariableBase> variablesFolder) { InitializeComponent(); mVariablesFolder = variablesFolder; SetVariablesGridView(); SetGridAndTreeData(); }