/// <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();
}
