public ExtendedTreeNode[] TreeViewCreation(string startingDirectory)
{
try
{
string[] subdirectories = Directory.GetDirectories(startingDirectory);
ExtendedTreeNode[] treeNodeChildren = new ExtendedTreeNode[Directory.GetFileSystemEntries(startingDirectory).Count()]; //Directory.GetFileSystemEntries obuhvaca i foldere i datoteke
int counter = 0;
foreach (var subdir in subdirectories)
{
ExtendedTreeNode node = new ExtendedTreeNode(subdir);
node.Name = subdir;
node.Text = subdir.Substring(subdir.LastIndexOf("\\") + 1);
node.Tag = "Directory";
node.ImageIndex = 2;
node.SelectedImageIndex = 2;
treeNodeChildren[counter] = node;
counter++;
}
return(treeNodeChildren.Where((x, y) => treeNodeChildren[y] != null).ToArray());
}
catch (UnauthorizedAccessException)
{
return(null);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public void GenerateTreeView(ExtendedTreeNode mainNode, string pathServer, FTPConnection2 myFTPConnection)
{
using (Session myConnection = new Session())
{
myConnection.Open(myFTPConnection.MyConnectionOptions);
Generate(myConnection, mainNode, pathServer);
}
}
private void SuperNodeCreation(string superNodeName)
{
superNode = new ExtendedTreeNode(superNodeName);
superNode.Name = superNodeName;
superNode.Text = superNodeName;
superNode.Tag = superNodeName;
superNode.ImageIndex = 0;
superNode.SelectedImageIndex = 0;
}
public GeneriranjeServerTreeViewa(string rootPathServer)
{
superNode = new ExtendedTreeNode(rootPathServer);
superNode.Name = rootPathServer;
superNode.Text = rootPathServer;
superNode.Tag = rootPathServer;
superNode.ImageIndex = 0;
superNode.SelectedImageIndex = 0;
Control.CheckForIllegalCrossThreadCalls = false;
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public static ExtendedTreeNode KreiranjeNovogTreeNoda(string folderServerPath, string folderName)
{
ExtendedTreeNode newNode = new ExtendedTreeNode(folderName);
newNode.Text = folderName;
newNode.Name = folderServerPath + "/" + folderName;
newNode.Tag = "Directory";
newNode.ImageIndex = 2;
newNode.SelectedImageIndex = 2;
return(newNode);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public static void AddingNewTreeNodes(ExtendedTreeNode rootNode, string localPath, string serverPath)
{
string folderName = Path.GetFileName(localPath);
ExtendedTreeNode newNode = KreiranjeNovogTreeNoda(serverPath, folderName);
string[] dirs = Directory.GetDirectories(localPath);
foreach (string dir in dirs)
{
localPath = dir;
}
rootNode.Nodes.Add(newNode);
}
public void Generate(Session myConnection, ExtendedTreeNode mainNode, string pathServer)
{
RemoteDirectoryInfo directoryInfo = myConnection.ListDirectory(pathServer);
int numberOfFolders = directoryInfo.Files.Where(x => x.IsDirectory && x.Name != "..").Count();
if (numberOfFolders > 0)
{
ExtendedTreeNode folderNode = new ExtendedTreeNode("?");
folderNode.Text = "?";
folderNode.Name = "?";
folderNode.Tag = "Directory";
folderNode.ImageIndex = 2;
folderNode.SelectedImageIndex = 2;
mainNode.Nodes.Add(folderNode);
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public static void GeneriranjeNovihTreeNodovaPrilikomUploada(string localPath, string serverPath, FTPConnection2 myFTPConnection, TreeView treeview)
{
string path_newFileOrFolder = serverPath + "/" + Path.GetFileName(localPath);
if (treeview.Nodes.Find(path_newFileOrFolder, true).Count() != 0) // prilikom overwritea nodovi vec postoje pa ih ne treba ponovo generirati
{
treeview.Nodes.Find(path_newFileOrFolder, true)[0].Remove();
}
FileAttributes localFileAttribute = File.GetAttributes(localPath);
if (localFileAttribute == FileAttributes.Directory)
{
ExtendedTreeNode rootNode = (ExtendedTreeNode)treeview.Nodes.Find(serverPath, true)[0];
AddingNewTreeNodes(rootNode, localPath, serverPath);
}
}
public void DeleteFilesOnServer(ExtendedTreeNode node)
{
try
{
using (Session myConnection = new Session())
{
myConnection.Open(MyConnectionOptions);
string pathToDelete = node.Name;
Delete(pathToDelete, myConnection);
}
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
throw new Exception(ex.Message);
}
}
public void DownloadFilesAndFolders(string pathLocal, ExtendedTreeNode node)
{
try
{
using (Session myConnection = new Session())
{
myConnection.Open(MyConnectionOptions);
string pathServer = node.Name;
pathLocal = pathLocal + "\\" + node.Text;
Download(pathServer, pathLocal, myConnection);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public static ExtendedTreeNode KreiranjeNovogTreeNoda(string path, string folderName)
{
ExtendedTreeNode newNode = new ExtendedTreeNode(folderName);
newNode.Text = folderName;
newNode.Name = path + "\\" + folderName;
newNode.Tag = "Directory";
newNode.ImageIndex = 2;
newNode.SelectedImageIndex = 2;
string[] directories = Directory.GetDirectories(newNode.Name);
if (directories.Count() > 0)
{
newNode.Nodes.Add("newSubnode");
}
return(newNode);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public List <TreeNode> ExpandTreeNode(ExtendedTreeNode nodeToExpand, FTPConnection2 myFTPConnection)
{
List <TreeNode> nodesToReturn = new List <TreeNode>();
using (Session myConnection = new Session())
{
myConnection.Open(myFTPConnection.MyConnectionOptions);
RemoteDirectoryInfo directoryInfo = myConnection.ListDirectory(nodeToExpand.Name);
foreach (RemoteFileInfo file in directoryInfo.Files)
{
if (file.Name != ".." && file.IsDirectory)
{
ExtendedTreeNode folderNode = new ExtendedTreeNode(file.Name);
folderNode.Text = file.Name;
if (nodeToExpand.Name.Equals("/"))
{
folderNode.Name = "/" + file.FullName;
}
else
{
folderNode.Name = file.FullName;
}
folderNode.Tag = "Directory";
folderNode.ImageIndex = 2;
folderNode.SelectedImageIndex = 2;
Generate(myConnection, folderNode, folderNode.Name);
nodesToReturn.Add(folderNode);
}
}
}
return(nodesToReturn);
}
public async Task <bool> UploadFilesAndFolders(ExtendedTreeNode node, string pathServer)
{
try
{
using (Session myConnection = new Session())
{
myConnection.Open(MyConnectionOptions);
pathServer = pathServer + "/";
string pathLocal = node.Name;
Task <bool> task1 = new Task <bool>(() => Upload(pathServer, pathLocal, myConnection));
task1.Start();
bool wasItSuccessful = await task1;
return(wasItSuccessful);
}
}
catch (Exception e)
{
ErrorMessage = e.Message;
throw new Exception(e.Message);
}
}
public void Expand(ExtendedTreeNode nodeToExpand)
{
try
{
if (!nodeToExpand.Text.Equals(superNode.Text))
{
nodeToExpand.Nodes.Clear();
ExtendedTreeNode[] treeNodeChildren = TreeViewCreation(nodeToExpand.Name);
foreach (ExtendedTreeNode node in treeNodeChildren)
{
nodeToExpand.Nodes.Add(node);
}
foreach (ExtendedTreeNode dir in nodeToExpand.Nodes)
{
if (dir.Name != "" && (dir.Tag.Equals("Directory") || dir.Tag.Equals("Drive")))
{
treeNodeChildren = TreeViewCreation(dir.Name);
if (treeNodeChildren != null)
{
foreach (ExtendedTreeNode node in treeNodeChildren)
{
dir.Nodes.Add(node);
}
}
}
}
}
else
{
nodeToExpand.Nodes.Clear();
string[] drives = Environment.GetLogicalDrives();
foreach (var drive in drives)
{
DriveInfo myDrive = new DriveInfo(drive);
if (myDrive.IsReady)
{
ExtendedTreeNode driveNode = new ExtendedTreeNode(drive);
driveNode.Text = drive;
driveNode.Name = drive;
driveNode.Tag = "Drive";
driveNode.ImageIndex = 1;
driveNode.SelectedImageIndex = 1;
ExtendedTreeNode[] myNode = TreeViewCreation(drive);
foreach (ExtendedTreeNode node in myNode)
{
driveNode.Nodes.Add(node);
}
nodeToExpand.Nodes.Add(driveNode);
}
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
