public BackgroundOrganiser(DirectoryModel rootDirectory)
: base()
{
_rootDirectory = rootDirectory;
OnInitialise();
}
public DirectoryChangedEventArgs(IProviderService service, ProviderModel provider, DirectoryModel directory)
{
Service = service;
Provider = provider;
Directory = directory;
}
public InitResponseModel(DirectoryModel currentWorkingDirectory, Options options) : base(currentWorkingDirectory)
{
Options = options;
}
public override DirectoryModel GetDirectory(ProviderModel provider, string path = null)
{
var model = GetFromCache(provider, path);
if (model != null)
{
return(model);
}
else
{
model = new DirectoryModel();
}
if (string.IsNullOrEmpty(path))
{
model.Directories = new List <DirectoryModel>();
foreach (var driveInfo in DriveInfo.GetDrives())
{
if (!driveInfo.IsReady)
{
continue;
}
var drive = new DirectoryModel(true);
drive.Name = driveInfo.Name;
drive.Path = driveInfo.RootDirectory.FullName;
drive.Size = driveInfo.TotalSize;
model.Directories.Add(drive);
}
AddToCache(provider, model);
return(model);
}
var info = new DirectoryInfo(path);
model.Name = info.Name;
model.Path = info.FullName;
model.Created = info.CreationTime;
model.Modified = info.LastWriteTime;
model.Accessed = info.LastAccessTime;
model.IsHidden = info.Attributes.HasFlag(FileAttributes.Hidden);
model.Files = new List <FileModel>();
try
{
foreach (var fileInfo in info.GetFiles())
{
var file = new FileModel();
if (string.IsNullOrEmpty(fileInfo.Extension))
{
file.Name = fileInfo.Name;
}
else
{
file.Name = fileInfo.Name.Replace(fileInfo.Extension, string.Empty);
file.Extension = fileInfo.Extension.Substring(1).ToLowerInvariant();
}
file.Path = fileInfo.FullName;
file.Size = fileInfo.Length;
file.Created = fileInfo.CreationTime;
file.Modified = fileInfo.LastWriteTime;
file.Accessed = fileInfo.LastAccessTime;
file.IsHidden = fileInfo.Attributes.HasFlag(FileAttributes.Hidden);
model.Files.Add(file);
}
}
catch (UnauthorizedAccessException)
{
}
model.Directories = new List <DirectoryModel>();
try
{
foreach (var directoryInfo in info.GetDirectories())
{
var directory = new DirectoryModel();
directory.Name = directoryInfo.Name;
directory.Path = directoryInfo.FullName;
directory.Created = directoryInfo.CreationTime;
directory.Modified = directoryInfo.LastWriteTime;
directory.Accessed = directoryInfo.LastAccessTime;
directory.IsHidden = directoryInfo.Attributes.HasFlag(FileAttributes.Hidden);
model.Directories.Add(directory);
}
}
catch (UnauthorizedAccessException)
{
}
AddToCache(provider, model);
return(model);
}
private void AddNewFiles(DirectoryModel origDir, DirectoryModel newDir)
{
var newFiles = newDir.Files.Where(x => x.FileType == FileType.NEW);
origDir.Files.AddRange(newFiles);
}
public WikiModule(ServerConfig serverConfig)
: base("/wiki")
{
config = serverConfig;
fileReader = new FileReader(FileReaderPolicy.LimitedBlock, 500);
// add top level "site" route
Get["/{site}"] = parameters =>
{
WikiConfig wikiConfig = null;
MasterRepository masterRepository = null;
if (config.TryGetConfig(parameters["site"], out wikiConfig) &&
config.TryGetMasterRepository(parameters["site"], out masterRepository))
{
// TODO: Async-ify this
var pageResults = masterRepository.GetAvailableAssets().Result;
SiteModel model = new SiteModel()
{
IsPartialView = Request.Query.isPartial,
WikiUrl = "/",
SiteMap = pageResults
};
Context.ViewBag.SiteName = wikiConfig.SiteName;
return(View["Site.cshtml", model]);
}
else
{
return(HttpStatusCode.NotFound);
}
};
// add "directory" route, subpath should not contain a "." or a "/"
Get[@"/{site}/(?<directory>[^\.]*)"] = parameters =>
{
WikiConfig wikiConfig;
if (config.TryGetConfig(parameters["site"], out wikiConfig) &&
Directory.Exists(Path.Combine(wikiConfig.RootWikiPath, parameters["directory"])))
{
DirectoryModel model = new DirectoryModel()
{
IsPartialView = Request.Query.isPartial,
WikiUrl = parameters["directory"],
};
Context.ViewBag.SiteName = wikiConfig.SiteName;
return(View["Directory.cshtml", model]);
}
else
{
return(HttpStatusCode.NotFound);
}
};
// add "page" route, subpath should always have a file extension (and therefore at least one ".")
Get[@"/{site}/(?<page>.*\..*)"] = parameters =>
{
WikiConfig wikiConfig = null;
MasterRepository masterRepository = null;
if (config.TryGetConfig(parameters["site"], out wikiConfig) &&
config.TryGetMasterRepository(parameters["site"], out masterRepository))
{
// Async-ify
var results = masterRepository.GetPageByWikiUrl(parameters["page"]).Result;
if (results.Item1)
{
var results2 = TryGetPageContents(parameters["site"], results.Item2);
if (results2.Item1)
{
PageModel model = new PageModel()
{
IsPartialView = Request.Query.isPartial,
WikiUrl = parameters["page"],
Contents = results2.Item2
};
Context.ViewBag.SiteName = wikiConfig.SiteName;
return(View["Page.cshtml", model]);
}
else
{
// TODO: If the file doesn't exist we could potentially remove it from the cache
return(HttpStatusCode.NotFound);
}
}
else
{
// TODO: If the file doesn't exist we could potentially remove it from the cache
return(HttpStatusCode.NotFound);
}
}
else
{
return(HttpStatusCode.NotFound);
}
};
}
public override Task FormatAsync(AccountModelBase account, DirectoryModel directory = null)
{
throw new NotImplementedException();
}
public override async Task <DirectoryModel> GetDirectoryAsync(AccountModelBase account, DirectoryModel directory = null)
{
var model = GetFromCache(account, directory);
if (model != null)
{
return(model);
}
else
{
model = new DirectoryModel();
model.Path = "/";
}
var path = directory == null || string.IsNullOrEmpty(directory.Path) ? "/" : directory.Path;
model.Name = directory.Name;
model.Path = path;
model.Directories = new List <DirectoryModel>();
model.Files = new List <FileModel>();
using (var client = await GetConnection(account as AccountModel))
{
var entries = await client.GetListingAsync(path, FtpListOption.AllFiles);
foreach (var entry in entries)
{
switch (entry.Type)
{
case FtpFileSystemObjectType.Directory:
var dir = new DirectoryModel();
dir.Id = entry.FullName.GetHashCode().ToString();
dir.Name = entry.Name;
dir.Path = entry.FullName;
dir.Size = entry.Size;
dir.Created = entry.Created;
dir.Modified = entry.Modified;
model.Directories.Add(dir);
break;
case FtpFileSystemObjectType.File:
var file = new FileModel();
file.Id = entry.FullName.GetHashCode().ToString();
file.Name = entry.Name;
file.Path = entry.FullName;
file.Size = entry.Size;
file.Created = entry.Created;
file.Modified = entry.Modified;
model.Files.Add(file);
break;
}
}
if (client.IsConnected)
{
await client.DisconnectAsync();
}
}
AddToCache(account, model);
return(model);
}
public override async Task <DirectoryModel> GetDirectoryAsync(AccountModelBase account, DirectoryModel directory = null)
{
var model = GetFromCache(account, directory);
if (model != null)
{
return(model);
}
else
{
model = new DirectoryModel();
}
model.Name = directory.Name;
model.Path = directory.Path;
model.Directories = new List <DirectoryModel>();
model.Files = new List <FileModel>();
var credentials = await GetCredential();
var parent = directory == null || directory.Id == null ? "root" : directory.Id;
var query = new StringBuilder();
if (directory.Id == null)
{
query.Append(" and 'root' in parents");
}
else
{
query.Append(" and '' in parents");
}
FileList entries;
using (var client = new DriveService(GetServiceInitializer(credentials)))
{
var request = client.Files.List();
request.Q = string.Format("trashed = false and '{0}' in parents", parent);
request.PageSize = Config.PageSize;
request.Fields = "nextPageToken, files(id, name, mimeType, parents, createdTime, modifiedTime, fileExtension, size)";
entries = await request.ExecuteAsync();
while (entries.Files != null)
{
foreach (var entry in entries.Files)
{
var parents = entry.Parents;
if (entry.MimeType.Equals(MIME_TYPE_DIRECTORY))
{
var dir = new DirectoryModel();
dir.Id = entry.Id;
dir.Name = entry.Name;
dir.Path = entry.Name;
dir.Size = entry.Size;
dir.Created = entry.CreatedTime;
dir.Modified = entry.ModifiedTime;
model.Directories.Add(dir);
}
else
{
var nameParts = SplitName(entry.Name);
var file = new FileModel();
file.Id = entry.Id;
file.Name = nameParts.Name;
file.Extension = nameParts.Extension;
file.Path = entry.Name;
file.Size = entry.Size;
file.Created = entry.CreatedTime;
file.Modified = entry.ModifiedTime;
model.Files.Add(file);
}
}
if (entries.NextPageToken == null)
{
break;
}
request.PageToken = entries.NextPageToken;
entries = await request.ExecuteAsync();
}
}
AddToCache(account, model);
return(model);
}
public override void Link(FileSystemInfoEx[] entries, DirectoryModel <FileInfoEx, DirectoryInfoEx, FileSystemInfoEx> directoryModel)
{
throw new NotImplementedException();
}
public override AddActions GetSupportedAddActions(FileSystemInfoEx[] entries, DirectoryModel <FileInfoEx, DirectoryInfoEx, FileSystemInfoEx> directoryModel)
{
return(AddActions.Copy);
}
public override void Copy(FileSystemInfoEx[] entries, DirectoryModel <FileInfoEx, DirectoryInfoEx, FileSystemInfoEx> directoryModel, bool allowThread = true)
{
throw new NotImplementedException();
}
public override DirectoryInfoEx CreateDirectory(DirectoryModel <FileInfoEx, DirectoryInfoEx, FileSystemInfoEx> directoryModel, string name, string type)
{
throw new NotImplementedException();
}
public void Check(DirectoryModel tree_directory, DirectoryModel current_directory)
{
this.CheckFiles(tree_directory, current_directory);
this.CheckDirectories(tree_directory, current_directory);
}
public async void RemoveDirectory(DirectoryModel dir)
{
_db.Directories.Remove(dir);
await _db.SaveChangesAsync();
}
public DirectoryViewModel(Profile <FI, DI, FSI> profile, DirectoryModel <FI, DI, FSI> embeddedDirectoryModel)
: base(profile, embeddedDirectoryModel)
{
setupSubEntries();
HasSubDirectories = embeddedDirectoryModel.HasSubDirectories;
}
private void AddRdpItem(object sender, RoutedEventArgs e)
{
//get the parent treeviewitem
FolderTreeViewItem folderItem = null;
var item = rdpTree.SelectedItem;
if (item != null)
{
var rdpItem = item as RdpTreeViewItem;
if (rdpItem != null)
{
folderItem = rdpItem.Parent as FolderTreeViewItem;
}
else
{
folderItem = item as FolderTreeViewItem;
}
}
var directoryPath = folderItem != null ? folderItem.Path : _executingDirectory;
var dialog = new AddDialog(directoryPath);
var addLocation = GetElementPoint(add);
dialog.Owner = this;
dialog.Left = Left + addLocation.X + add.ActualWidth + 7;
dialog.Top = Top + addLocation.Y + HORRIBLE_CONSTANT;
var result = dialog.ShowDialog();
if (result.HasValue && result.Value)
{
var name = dialog.NewName;
var host = dialog.Host;
var filePath = Path.Combine(directoryPath, $"{name}.rdp");
if (!File.Exists(filePath))
{
FileHelper.GenerateRdpFile(filePath, host);
var newRdpItem = CreateRdpItem(name, filePath);
if (folderItem != null)
{
folderItem.Items.Add(newRdpItem);
folderItem.Items.Refresh();
}
else
{
rdpTree.Items.Add(newRdpItem);
rdpTree.Items.Refresh();
}
_root = new DirectoryModel(_executingDirectory);
LaunchRDPEdit(filePath);
}
else
{
//todo handle
}
}
}
public ActionResult Index(DirectoryModel model)
{
model.CurrentUser = HttpContext.CurrentUser();
CheckCookie(model);
return(View(model));
}
public DndDirectoryViewerViewModel(Profile <FI, DI, FSI> profile,
DirectoryModel <FI, DI, FSI> embedDirectoryModel)
: base(profile, embedDirectoryModel)
{
}
public ActionResult Staff(DirectoryModel model)
{
return(RedirectToRoutePermanent("Directory"));
}
public override async Task <DirectoryModel> GetDirectoryAsync(AccountModelBase account, DirectoryModel directory = null)
{
var model = GetFromCache(account, directory);
if (model != null)
{
return(model);
}
return(await Task.Run(() =>
{
model = new DirectoryModel();
if (string.IsNullOrEmpty(directory.Path))
{
model.Directories = new List <DirectoryModel>();
foreach (var driveInfo in DriveInfo.GetDrives())
{
if (!driveInfo.IsReady)
{
continue;
}
var drive = new DirectoryModel(true);
drive.Name = driveInfo.Name;
drive.Path = driveInfo.RootDirectory.FullName;
drive.Size = driveInfo.TotalSize;
model.Directories.Add(drive);
}
AddToCache(account, model);
return model;
}
DirectoryInfo info = new DirectoryInfo(directory.Path);
model.Name = info.Name;
model.Path = info.FullName;
model.Created = info.CreationTime;
model.Modified = info.LastWriteTime;
model.Accessed = info.LastAccessTime;
model.IsHidden = info.Attributes.HasFlag(FileAttributes.Hidden);
model.IsSystem = info.Attributes.HasFlag(FileAttributes.System);
model.Files = new List <FileModel>();
try
{
foreach (var fileInfo in info.GetFiles())
{
var file = new FileModel();
if (string.IsNullOrEmpty(fileInfo.Extension))
{
file.Name = fileInfo.Name;
}
else
{
file.Name = fileInfo.Name.Replace(fileInfo.Extension, string.Empty);
file.Extension = fileInfo.Extension.Substring(1).ToLowerInvariant();
}
file.Path = fileInfo.FullName;
file.Size = fileInfo.Length;
file.Created = fileInfo.CreationTime;
file.Modified = fileInfo.LastWriteTime;
file.Accessed = fileInfo.LastAccessTime;
file.IsHidden = fileInfo.Attributes.HasFlag(FileAttributes.Hidden);
file.IsSystem = fileInfo.Attributes.HasFlag(FileAttributes.System);
model.Files.Add(file);
}
}
catch (UnauthorizedAccessException)
{
}
model.Directories = new List <DirectoryModel>();
try
{
foreach (var directoryInfo in info.GetDirectories())
{
var dir = new DirectoryModel();
dir.Name = directoryInfo.Name;
dir.Path = directoryInfo.FullName;
dir.Created = directoryInfo.CreationTime;
dir.Modified = directoryInfo.LastWriteTime;
dir.Accessed = directoryInfo.LastAccessTime;
dir.IsHidden = directoryInfo.Attributes.HasFlag(FileAttributes.Hidden);
dir.IsSystem = directoryInfo.Attributes.HasFlag(FileAttributes.System);
model.Directories.Add(dir);
}
}
catch (UnauthorizedAccessException)
{
}
AddToCache(account, model);
return model;
}));
}
public BackgroundOrganiser(DirectoryModel rootDirectory) : base()
{
_rootDirectory = rootDirectory;
OnInitialise();
}
public BaseOpenResponseModel(DirectoryModel currentWorkingDirectory)
{
Files = new List <object>();
CurrentWorkingDirectory = currentWorkingDirectory;
}
public OpenResponse(DirectoryModel currentWorkingDirectory, FullPath fullPath) : base(currentWorkingDirectory)
{
Options = new Options(fullPath);
Files.Add(currentWorkingDirectory);
}
private void Callback()
{
NewDirectoryModel = null;
}
public override async Task <DirectoryModel> GetDirectoryAsync(AccountModelBase account, DirectoryModel directory = null)
{
var model = GetFromCache(account, directory);
if (model != null)
{
return(model);
}
else
{
model = new DirectoryModel();
}
model.Name = directory.Name;
model.Path = directory.Path;
model.Directories = new List <DirectoryModel>();
model.Files = new List <FileModel>();
var accountDetails = account as AccountModel;
var client = new DropboxClient(accountDetails.Token);
var path = directory == null || directory.Path == null ? string.Empty : directory.Path;
var entries = await client.Files.ListFolderAsync(path);
foreach (var entry in entries.Entries)
{
if (entry.IsDeleted)
{
continue;
}
if (entry.IsFolder)
{
var dir = new DirectoryModel();
dir.Name = entry.Name;
dir.Path = entry.PathDisplay;
model.Directories.Add(dir);
}
else if (entry.IsFile)
{
var nameParts = SplitName(entry.Name);
var fileInfo = entry.AsFile;
var file = new FileModel();
file.Name = nameParts.Name;
file.Extension = nameParts.Extension;
file.Path = entry.PathDisplay;
file.Size = (long)fileInfo.Size;
file.Modified = fileInfo.ClientModified;
model.Files.Add(file);
}
}
AddToCache(account, model);
return(model);
}
private ActionResult GetIndexView(DirectoryModel model)
{
return(View("Index", model));
}
public SubDirectoryViewModel(string letter, DirectoryModel model)
{
this.Letter = letter;
this.Entries = new ObservableCollection <DirectoryEntryModel>(model.GetDirectory().Where(d => d.SortLetter == letter));
}
public DirectoryViewerViewModel(Profile <FI, DI, FSI> profile,
DirectoryModel <FI, DI, FSI> embedDirectoryModel, int viewSize = (int)ViewMode.vmGrid)
: base(profile, embedDirectoryModel)
{
init(profile, viewSize);
}
public SelectionChangedEventArgs(ProviderServiceBase service, AccountModelBase account, DirectoryModel directory, NavigationDirection direction = NavigationDirection.Unknown)
{
Service = service;
Account = account;
Directory = directory;
Direction = direction;
}
private static bool RealFolderHasSamePathAsVirtualFolder(IList<DirectoryModel> realFolders, DirectoryModel f)
{
return realFolders.Any(realFolder => realFolder.FullPath.StartsWith(f.FullPath, StringComparison.InvariantCultureIgnoreCase));
}
private async Task PutDirectoryInDB(DirectoryModel dir)
{
_db.Directories.Add(dir);
await _db.SaveChangesAsync();
}
