public ManagedFolder CreateFolder(string foldername)
{
var folder = new ManagedFolder($"{_path}\\{foldername}");
SubFolders.Add(folder);
return(folder);
}
public void SortSubFolders(SortAction sortAction, ref PGFolderComparer defaultcomparer)
{
PGFolderComparer comparer = PGFolderComparer.GetComparerBySortAction(sortAction, defaultcomparer);
SubFolders.Sort(comparer);
defaultcomparer = comparer;
}
public ComponentFolder
(
TFolderMetaData metaData
)
{
MetaData = metaData;
_subFoldersBehavior = SubFolders.AddBehavior(OnAddSubFolderItem, OnRemoveSubFolderItem);
_bbsBehavior = ComponentInfos.AddBehavior(OnAddComponentItem, OnRemoveComponentItem);
}
public FolderViewModel(string path, FolderViewModel parent = null)
{
Path = path;
Parent = parent;
if (!string.IsNullOrEmpty(path) && Directory.GetDirectories(Path).Any())
{
SubFolders.Add(new FolderViewModel(string.Empty, this));
}
}
AddSubFolder(TFolderMetaData subFolderMetaData)
{
ComponentFolder <TId, TFolderMetaData, TComponentMetaData> subFolder =
new ComponentFolder <TId, TFolderMetaData, TComponentMetaData>(subFolderMetaData);
SubFolders.Add(subFolder);
return(subFolder);
}
public IFolder OpenSubFolder(string name)
{
if (SubFolderCount <= 0)
{
return(default(IFolder));
}
return(SubFolders.FirstOrDefault(folder => folder.Name.CompareTo(name) == 0));
}
public void RemoveSubFolder(Folder folder)
{
if (SubFolders == null)
{
throw new Exception();
}
SubFolders.Remove(folder);
}
public void RemoveFolder(string cn)
{
for (int i = SubFolders.Count - 1; i > -1; i--)
{
if (SubFolders[i].CN == cn)
{
SubFolders.RemoveAt(i);
return;
}
}
}
public async Task <string> GetSubFolder(string file, string[] labels, SubFolders subFolder, IFormatter formatter)
{
_subFolders = subFolder;
foreach (string label in labels)
{
KeysAlternatives keyAlternative = GetKeysFromLabel(label);
_subFolders = _parser.InvokeWithAlternative(keyAlternative, _subFolders, file);
}
return(await _subFolders.GetSubFolder(formatter));
}
public dynamic ToTree()
{
return(new
{
title = Instance.Name,
key = Instance.Guid,
description = Instance.Description,
createUserName = Instance.CreateUserName,
createTime = Instance.CreateTime.ToString("yyyy-MM-dd HH:mm:ss"),
children = SubFolders.Select(x => x.ToTree())
});
}
//public Folder()
// : this("C:") { }
public Folder()
{
if (SubFolders == null)
{
SubFolders = new ObservableCollection <Folder>();
}
foreach (var dir in Directory.GetLogicalDrives())
{
Folder folder = new Folder(dir);
SubFolders.Add(folder);
}
}
private async Task TryGetSubFolders(bool withSecond)
{
if (_isLoading || _isLoaded)
{
return;
}
_isLoading = true;
var subFolders = await CurrentFolder.GetFoldersAsync();
SubFolders.AddAll(subFolders.Select(it => new TreeViewItemModel(it, withSecond)));
_isLoaded = true;
_isLoading = false;
}
public void CreateSubDirectory(string subfolder)
{
var subdir = Path.Combine(BaseDir, subfolder);
SubFolders.Add(subdir);
if (!Directory.Exists(subdir))
{
Directory.CreateDirectory(subdir);
Logger($"Directory '{subdir}' has been created!");
}
}
/// <summary>
/// Selects the folder to Filter.
/// </summary>
internal void SelectFolder()
{
using (WF.FolderBrowserDialog fbd = new WF.FolderBrowserDialog())
{
if (!string.IsNullOrEmpty(Properties.Settings.Default.LastTracked))
{
if (Directory.Exists(Properties.Settings.Default.LastTracked))
{
fbd.SelectedPath = Properties.Settings.Default.LastTracked;
}
}
fbd.ShowNewFolderButton = false;
var dr = fbd.ShowDialog();
switch (dr)
{
case WF.DialogResult.OK:
case WF.DialogResult.Yes:
WatchedFolder = fbd.SelectedPath;
if (Directory.Exists(WatchedFolder))
{
Status = _normalStates[1];
DirectoryInfo dInf = new DirectoryInfo(WatchedFolder);
foreach (var subDir in dInf.GetDirectories("*", SearchOption.TopDirectoryOnly))
{
var folder = new FolderExclude(subDir.Name, subDir.FullName)
{
Exclude = false
};
folder.PropertyChanged += Folder_PropertyChanged;
SubFolders.Add(folder);
}
Properties.Settings.Default.LastTracked = WatchedFolder;
Properties.Settings.Default.Save();
BorderColor = Brushes.Green;
}
else
{
BorderColor = Brushes.Red;
}
break;
default:
break;
}
}
}
/// <summary>
/// Adds the subfolder structure to the subfolder list.
/// </summary>
private void fillSubfolders()
{
foreach (var child in Info.GetDirectories())
{
try
{
SubFolders.Add(new Folder(child.FullName));
}
catch (UnauthorizedAccessException)
{
UnavailableFolders.Add(child.FullName);
}
}
}
private void CheckForestRuns()
{
Dictionary <string, string> temp = SubFolders;
foreach (string name in temp.Keys)
{
if (GlobalHelper.PathContainsFile(SubFolders[name], XML_NAME))
{
SyncRuns.Add(new SyncRun(ForestName, ForestName, name, temp[name]));
SubFolders.Remove(name);
}
}
}
public void RemoveElement(ProjectElementBase element)
{
if (element is Project)
{
Projects.Remove(element as Project);
return;
}
if (element is SolutionFolder)
{
SubFolders.Remove(element as SolutionFolder);
return;
}
throw new Exception("Not correct type of item");
}
private void GetSubFolders(bool value)
{
if (value && SubFolders.Any(o => string.IsNullOrEmpty(o.FolderName)))
{
SubFolders.Clear();
var subfolders = Directory.GetDirectories(Path);
foreach (var item in subfolders)
{
try
{
SubFolders.Add(new FolderViewModel(item, this));
}
catch (Exception e) { }
}
}
}
public void LoadSubFolders(bool loadChild)
{
SubFolders.Clear();
try
{
foreach (var subFolderPath in _model.GetSubDirectories())
{
var subFolder = new FolderViewModel(subFolderPath);
if (loadChild)
{
subFolder.LoadSubFolders(false);
}
SubFolders.Add(subFolder);
}
}
catch (Exception ex) { }
}
public void AddElement(ProjectElementBase element)
{
if (element is Project)
{
Projects.Add(element as Project);
element.Parent = this;
return;
}
if (element is SolutionFolder)
{
SubFolders.Add(element as SolutionFolder);
element.Parent = this;
return;
}
throw new Exception("Not correct type of item");
}
public void RemoveElementRange(IList <ProjectElementBase> elements)
{
foreach (ProjectElementBase e in elements)
{
if (e is Project)
{
Projects.Remove(e as Project);
continue;
}
if (e is SolutionFolder)
{
SubFolders.Remove(e as SolutionFolder);
continue;
}
throw new Exception("Not correct type of item");
}
}
public UserDirectory(string path, PackageComponentsComponentItemsFolder parentItemsFolder, bool isTopLevel) : base(path, parentItemsFolder)
{
IsTopLevel = isTopLevel;
if (Path.Length <= 256)
{
if (System.IO.Directory.Exists(Path))
{
foreach (var dir in System.IO.Directory.EnumerateDirectories(Path))
{
SubFolders.Add(new UserDirectory(dir, parentItemsFolder, false));
}
foreach (var file in System.IO.Directory.EnumerateFiles(path))
{
Files.Add(new UserFile(file, parentItemsFolder));
}
}
}
}
public SubFolders InvokeWithAlternative(KeysAlternatives keysAlternatives, SubFolders subFolders, string filePath)
{
var metadataService = GetMetadataService(filePath);
ActionModel model = new ActionModel
{
File = new FileInfo(filePath),
MetadataService = metadataService,
Folders = subFolders,
Type = _actionType[keysAlternatives.Key],
Alternative = Instantiate(
new ActionModel
{
MetadataService = metadataService,
Folders = subFolders,
Type = keysAlternatives.Alternative == null ? null : _actionType[keysAlternatives.Alternative]
})
};
return(Instantiate(model));
}
private void FillInnerFoldersList()
{
IEnumerable <string> dirs = null;
dirs = Directory.EnumerateDirectories(Path, "*", SearchOption.TopDirectoryOnly);
if (dirs != null)
{
try
{
var exceptions = new ConcurrentQueue <Exception>();
Parallel.ForEach(dirs, directory =>
{
try
{
FolderItem baseFolder = new FolderItem(directory);
SubFolders.Add(baseFolder);
foreach (var item in baseFolder.log)
{
log.Add(item);
}
}
catch (Exception e)
{
exceptions.Enqueue(e);
}
});
if (exceptions.Count > 0)
{
throw new AggregateException(exceptions);
}
}
catch (AggregateException e)
{
throw e;
}
}
}
private void LoadSubFolders(DirectoryInfo dir)
{
SubFolders.Clear();
var securityTmp = dir.GetAccessControl();
if (!securityTmp.AreAccessRulesProtected || !securityTmp.AreAuditRulesProtected)
{
var subDirs = dir.GetDirectories();
if (subDirs.Length > 0)
{
for (int i = 0; i < subDirs.Length; i++)
{
if ((subDirs[i].Attributes & FileAttributes.Hidden) != FileAttributes.Hidden)
{
FolderElement tmpFolder = new FolderElement(new DirectoryInfo(subDirs[i].FullName));
tmpFolder.Parent = this;
SubFolders.Add(tmpFolder);
}
}
}
}
}
private string GetExperimentFolder(ExperimentInfo experimentInfo, string rootFolder)
{
Trace.Assert(experimentInfo != null, "ExperimentInfo is null");
Trace.Assert(experimentInfo.ExperimentReference != null, "ExperimentInfo.ExperimentReference is null");
Trace.Assert(experimentInfo.ExperimentReference.Name != null, "ExperimentInfo.ExperimentReference.Name is null");
Trace.Assert(experimentInfo.ExperimentReference.User != null, "ExperimentInfo.ExperimentReference.User is null");
// start with the root folder ...
string result = rootFolder;
// ... and add each subfolder
string temp = GetSubPath(SubFolders.ElementAtOrDefault(0), experimentInfo);
if (!string.IsNullOrEmpty(temp))
{
result = Path.Combine(result, temp);
}
temp = GetSubPath(SubFolders.ElementAtOrDefault(1), experimentInfo);
if (!string.IsNullOrEmpty(temp))
{
result = Path.Combine(result, temp);
}
temp = GetSubPath(SubFolders.ElementAtOrDefault(2), experimentInfo);
if (!string.IsNullOrEmpty(temp))
{
result = Path.Combine(result, temp);
}
temp = GetSubPath(SubFolders.ElementAtOrDefault(3), experimentInfo);
if (!string.IsNullOrEmpty(temp))
{
result = Path.Combine(result, temp);
}
return(result);
}
public void AddItem(IFolder folder)
{
SubFolders.Add(folder);
}
public AssetManagerFolder(IProject project, XmlElement xmlElement)
: base(project, xmlElement)
{
_parentFolder = null;
SubFolders = new SubFolders(this, Caching.Enabled);
Files = new AssetManagerFiles(this, Caching.Enabled);
}
public static bool DoesDirectoryExist(SubFolders folder) => Directory.Exists(GetDirectory() + folder.ToString());
public bool CreateFolder(string name)
{
return(SubFolders.Add(name) != null);
}
public static async Task <string> ExecuteWithAlternative(SubFolders alternative, string defaultString)
{
return(alternative == null
? defaultString
: await alternative.GetSubFolder(Config.Get <JustValueFormatters>()));
}
