/// <summary> /// Function that forms a list of statuses compared to a specific DirectoryData data passed. /// </summary> /// <param name="currentDD">Specific DirectoryData to form a file statuses from.</param> /// <returns>LoadedFileStatus list which tells if the file datas read from Fhsks are correct or if its not tell whats wrong with it.</returns> public static List <LoadedFileStatus> CheckFileStatusesOfDirectoryData(DirectoryData currentDD) { List <LoadedFileStatus> result = new List <LoadedFileStatus>(); foreach (var item in currentDD.Files) { string currentLocalPath = currentDD.FindFileGetLocalPath(item.RelativePath); if (File.Exists(currentLocalPath)) { FileInfo fi = new FileInfo(currentLocalPath); if (fi.LastWriteTime != item.LastModifiedTime) { result.Add(LoadedFileStatus.Modified); } else { result.Add(LoadedFileStatus.NotTouched); } } else { result.Add(LoadedFileStatus.DoesntExist); } } return(result); }
public void TestUpdateDetails() { using (var mock = AutoMock.GetStrict()) { var settings = mock.Mock <ISettings>(); settings.SetupGet(m => m.DataFilename).Returns("song.xml"); var fileSystem = mock.Mock <IFileSystem>(); fileSystem.Setup(m => m.Path.Combine(@"C:\test\bla", "song.xml")).Returns(@"C:\test\bla\song.xml"); var song = new SongModel { Path = @"C:\test\bla" }; var data = new DirectoryData { Status = DirectoryStatus.SONG, Song = song }; var exporter = mock.Mock <IExporter>(); exporter.Setup(m => m.Write(@"C:\test\bla\song.xml", data)); var songService = mock.Create <Song>(); songService.UpdateDetails(song); settings.VerifyGet(m => m.DataFilename, Times.Once); fileSystem.Verify(m => m.Path.Combine(@"C:\test\bla", "song.xml"), Times.Once); exporter.Verify(m => m.Write(@"C:\test\bla\song.xml", data), Times.Once); } }
/// <summary> /// Function that performs synchronization actions based of SyncData parameters and specific SyncExecAccessPermit. /// </summary> /// <param name="ConflictList">The list of SyncData's which specifies how conflict of the specific file should be solved.</param> /// <param name="SourceData">The directory being synchronized.</param> /// <param name="TargetData">The comparing directory to be synchronized with.</param> public static void SynchronizeConflict(List <SyncData> ConflictList, DirectoryData SourceData, DirectoryData TargetData) { foreach (var item in ConflictList) { if (item.SCS.HasFlag(SyncConflictState.DoesntExistInSource)) { if (accessOption.HasFlag(SyncShareAllowanceNonExistnant.ShareToSource)) { SolveNonExistantFileToOtherDirectory(SourceData, TargetData, item); } } else if (item.SCS.HasFlag(SyncConflictState.DoesntExistInTarget)) { if (accessOption.HasFlag(SyncShareAllowanceNonExistnant.ShareToTarget)) { SolveNonExistantFileToOtherDirectory(TargetData, SourceData, item); } } else if (item.SCS.HasFlag(SyncConflictState.OlderInSource) || item.SCS.HasFlag(SyncConflictState.NewerInSource) || item.SCS.HasFlag(SyncConflictState.BiggerInSource) || item.SCS.HasFlag(SyncConflictState.OlderInSource)) { SolveStatedPrioritizedConflict(SourceData, TargetData, item); } } }
private void WriteCheckIfExists(HttpContext context) { FS = Engine.Resolve <IFileSystem>(); var parentDirectory = context.Request["selected"]; var filenames = Selection.RequestValueAccessor("filenames"); var selected = new Directory(DirectoryData.Virtual(parentDirectory), null); if (string.IsNullOrEmpty(parentDirectory) || !Engine.SecurityManager.IsAuthorized(context.User, selected, N2.Security.Permission.Read)) { context.Response.WriteJson(new { Status = "Error", Message = "Not allowed" }); return; } if (string.IsNullOrEmpty(filenames)) { context.Response.WriteJson(new { Status = "Error", Message = "No files selected" }); return; } var fns = filenames.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); context.Response.WriteJson( new { Status = "Checked", Files = (from fileName in fns let newPath = Url.Combine(context.Request.ApplicationPath + selected.Url, HttpUtility.UrlDecode(fileName)) where FS.FileExists(newPath) select fileName).ToArray() }); }
/// <summary> /// Lists the installed modules. /// </summary> /// <returns>The installed modules.</returns> public override Module[] ListInstalledModules() { List <Module> list = new List <Module> (); string ModulesPath = this.GetModulesRootPath(); SystemLogger.Log(SystemLogger.Module.PLATFORM, "Listing installed modules under path: " + ModulesPath); DirectoryData modulesDirectory = new DirectoryData(ModulesPath); if (this.GetFileSystemService().ExistsDirectory(modulesDirectory)) { DirectoryData[] apps = this.GetFileSystemService().ListDirectories(modulesDirectory); foreach (DirectoryData app in apps) { SystemLogger.Log(SystemLogger.Module.PLATFORM, "directory: " + app.FullName); DirectoryData[] versions = this.GetFileSystemService().ListDirectories(app); foreach (DirectoryData version in versions) { SystemLogger.Log(SystemLogger.Module.PLATFORM, "version: " + version.FullName); Module module = new Module(); module.Id = Path.GetFileName(app.FullName); module.Version = this.ParseModuleVersion(Path.GetFileName(version.FullName)); list.Add(module); } } } else { SystemLogger.Log(SystemLogger.Module.PLATFORM, "Modules directory does not exists: " + ModulesPath); } return(list.ToArray()); }
internal static Items.Directory New(DirectoryData dir, ContentItem parent, IDependencyInjector injector) { var node = new Directory(dir, parent); injector.FulfilDependencies(node); return(node); }
public override DirectoryData Scan(string path, bool logDirectories = false) { try { var dir = new DirectoryInfo(path); var dirs = dir.EnumerateDirectories("*.*").ToList(); var files = dir.EnumerateFiles("*.*").ToList(); var fileTypes = GetFileTypes(files); var logDirs = logDirectories ? dirs : null; LogDirectoryFiles(logDirs, files); _logger.SaveLogs(); var dirData = new DirectoryData() { Directories = dirs, DirectoryCount = dirs.Count(), FileCount = files.Count(), DirectoryFileSize = files.Sum(fi => fi.Length), FileTypes = fileTypes, }; return(dirData); } catch (Exception exception) { _errorLogger.Log(exception, $"An exception occurred attempting to scan {path}."); return(new DirectoryData()); } }
/// <summary> /// Function that performs action of synchronization based on the corresponding SyncData which has to contain SyncActionState and SyncDirection. /// </summary> /// <param name="SourceData">The directory being synchronized.</param> /// <param name="TargetData">The comparing directory to be synchronized with.</param> /// <param name="SD">Corresponding SyncData with parameters to decide what to do with the file.</param> private static void SolveStatedPrioritizedConflict(DirectoryData SourceData, DirectoryData TargetData, SyncData SD) { switch (SD.SAS) { case SyncActionState.Skip: return; case SyncActionState.Delete: File.Delete(TargetData.FindFileGetLocalPath(SD.FD.RelativePath)); File.Delete(SourceData.FindFileGetLocalPath(SD.FD.RelativePath)); break; case SyncActionState.Share: if (SD.SD != SyncDirection.None) { if (SD.SD == SyncDirection.Target) { UpdateExistingFile(TargetData.FindFileGetLocalPath(SD.FD.RelativePath), SourceData.FindFileGetLocalPath(SD.FD.RelativePath)); } else if (SD.SD == SyncDirection.Source) { UpdateExistingFile(SourceData.FindFileGetLocalPath(SD.FD.RelativePath), TargetData.FindFileGetLocalPath(SD.FD.RelativePath)); } } break; case SyncActionState.Copy: break; default: break; } }
public void UpdateDetails(SongModel song) { var path = fileSystem.Path.Combine(song.Path, settings.DataFilename); var data = new DirectoryData { Status = DirectoryStatus.SONG, Song = song }; exporter.Write(path, data); }
public void DirectoryInfo() { var d = new DirectoryData(path); Assert.AreEqual(d.Directory, parentPath); Assert.AreEqual(d.FullFilePath, path); Assert.AreEqual <ListingTypeOption>(d.ListingType, ListingTypeOption.Directory); Assert.AreEqual(d.Name, "Test"); }
/// <summary> /// Function that serialize DirectoryData object to a Fhsks file. /// </summary> /// <param name="DD">DirectoryData object to be serialized.</param> /// <param name="StorageFilePath">Path the serialized data to be written to.</param> public static void WriteDirectoryDataToFile(DirectoryData DD, string StorageFilePath) { if (!Directory.Exists("FHSKS")) { Directory.CreateDirectory("FHSKS"); } File.WriteAllText(StorageFilePath, JsonConvert.SerializeObject(DD)); }
public static IEnumerable <DirectoryData> GetAllDirectoryInfos(this DirectoryData directoryData) { yield return(directoryData); foreach (var child in directoryData.GetDirectories().SelectMany(GetAllDirectoryInfos)) { yield return(child); } }
/// <summary> /// Löscht das Verzeichnis. /// </summary> public void Delete() { if (Parent == null) { throw new InvalidOperationException(); } DirectoryData.Delete(true); parent.Detach(this); }
/// <summary> /// Konstruktor. /// </summary> /// <param name="path">Physikalischer Pfad zu dieser Datei.</param> /// <param name="cnfgRow">DataRow welche die Daten dieses Files enthält.</param> /// <param name="parent">Das Verzeichnis welche diese Datei enthält.</param> public FileWrapper(string path, DirectoryData.FileConfigRow cnfgRow, DirectoryWrapper parent) { if (null == parent) throw new ArgumentNullException("Verzeichnis darf nicht null sein."); this.parent = parent; this.fileInfo = new FileInfo(path); this.fileInfoCfg = cnfgRow; this.fileInfoCfg.Name = this.fileInfo.Name; }
/// <summary> /// Enumerate directories and files under the project path of |projet|. /// </summary> private IEnumerable <DirectoryWithFiles> TraverseFileSystem(DirectoryName directoryName, bool isSymLink) { using (new TimeElapsedLogger($"Traversing directory \"{directoryName.FullPath}\" to collect directory/file names", _cancellationToken)) { var directory = new DirectoryData(directoryName, isSymLink); var bag = new ConcurrentBag <DirectoryWithFiles>(); var task = TraverseDirectoryAsync(directory, bag, _cancellationToken); task.Wait(_cancellationToken); return(bag); } }
public Directory(IFileSystem fs, DirectoryData directory, ContentItem parent) : base(fs) { Parent = parent; Name = directory.Name; Title = directory.Name; Updated = directory.Updated; Created = directory.Created; url = directory.VirtualPath; }
/// <summary> /// GET /rest/db/browse /// </summary> /// <returns>Version info</returns> public DirectoryData GetDbBrowse(String folder) { IRestResponse res = this.GET("/db/browse?folder=" + folder); if (res.ErrorException != null) { throw new ApiException(res.ErrorMessage); } return(DirectoryData.DeserializeJson(res.Content)); }
private void TestBtn_Click(object sender, EventArgs e) { dd1 = new DirectoryData(CurrentPD.SourceDirectoryPath); dd2 = new DirectoryData(CurrentPD.TargetDirectoryPath); CurrentSession = ConflictSolver.FormConflictFileDataList(dd1, dd2); SyncClassifier.ClassifySyncDatas(CurrentSession, CurrentPD.StatementDataString); FillTheTable(); }
public List <DirectoryEntry> Directory() { var databaseEntries = DirectoryData.GetAllEntries(); return(databaseEntries.Select(dbDirectoryEntry => new DirectoryEntry { Pkid = dbDirectoryEntry.Pkid, Name = dbDirectoryEntry.Name, TelephoneNumber = dbDirectoryEntry.TelephoneNumber }).ToList()); }
public Directory(DirectoryData directory, ContentItem parent) { Parent = parent; originalName = directory.Name; Name = directory.Name; Title = directory.Name; Updated = directory.Updated; Created = directory.Created; localUrl = N2.Web.Url.ToAbsolute(directory.VirtualPath); }
public Directory(DirectoryData directory, ContentItem parent) { Parent = parent; originalName = directory.Name; Name = directory.Name; Title = directory.Name; Updated = directory.Updated; Created = directory.Created; url = directory.VirtualPath; }
public Directory(DirectoryData directory, ContentItem parent) { Parent = parent; originalName = directory.Name; Name = directory.Name; Title = directory.Name; Updated = directory.Updated; Created = directory.Created; url = directory.VirtualPath; }
public Directory(DirectoryData directory, ContentItem parent) { Parent = parent; originalName = directory.Name; Name = directory.Name; Title = directory.Name; Updated = directory.Updated; Created = directory.Created; localUrl = N2.Web.Url.ToAbsolute(directory.VirtualPath); }
/// <summary> /// Erzeugt ein neues Unterverzeichnis. /// </summary> /// <param name="dirName"></param> /// <param name="dirDescription"></param> public void CreateSubDir(string dirName, string dirDescription) { DirectoryInfo newDirInfo = DirectoryData.CreateSubdirectory(dirName); // Erzeugen der Wrapper mit der selben Sortierung. DirectoryWrapper dirWrapper = new DirectoryWrapper(newDirInfo.FullName, this); dirWrapper.Description = dirDescription; dirWrapper.SaveData(); subDirectories = null; // Neu einlesen der Unterverzeichnisse. }
/// <summary> /// Function that removes non-existant files from specified DirectoryData FileData list based on pre-computed LoadedFileStatus list. /// </summary> /// <param name="lfs">Pre-computed LoadedFileStatus list</param> /// <param name="currentDD">Specific DirectoryData to correct.</param> public static void RemoveNotExistingFiles(List <LoadedFileStatus> lfs, DirectoryData currentDD) { for (int i = 0; i < currentDD.Files.Count; i++) { if (lfs[i] == LoadedFileStatus.DoesntExist) { lfs.RemoveAt(i); currentDD.Files.RemoveAt(i); i--; } } }
public DirectoryData(DirectoryInfo info, DirectoryData _parent = null, bool storeRelativePath = false, string rootPath = "") { fullName = info.FullName; if (storeRelativePath) { fullName = fullName.Replace(rootPath + Path.DirectorySeparatorChar.ToString(), ""); } parent = _parent; if (parent != null) { parent.directories.Add(this); } }
public JObject getFolderTree(DirectoryData d) { BrowseManager browse = new BrowseManager(); Directory_browse.Models.Directory dir = browse.getFolderTree(d.FullName); JObject dirJSON = JObject.FromObject(new { Dir = dir }); return(dirJSON); }
private void WriteDirectoryCreate(HttpContext context) { ValidateTicket(context.Request["ticket"]); FS = Engine.Resolve <IFileSystem>(); var parentDirectory = context.Request["selected"]; var selected = new Directory(DirectoryData.Virtual(parentDirectory), null); if (string.IsNullOrEmpty(parentDirectory) || !Engine.SecurityManager.IsAuthorized(context.User, selected, N2.Security.Permission.Write)) { context.Response.WriteJson(new { Status = "Error", Message = "Not allowed" }); return; } var name = context.Request["name"]; if (string.IsNullOrWhiteSpace(name)) { context.Response.WriteJson(new { Status = "Error", Message = "Directory name required" }); return; } var regex = new Regex("[^a-zA-Z0-9_ ]"); name = regex.Replace(name, ""); if (name.Length == 0) { context.Response.WriteJson(new { Status = "Error", Message = "Directory name required (Special characters are stripped out)" }); return; } var newDir = VirtualPathUtility.AppendTrailingSlash(context.Request.ApplicationPath + selected.Url) + name; try { if (FS.DirectoryExists(newDir)) { context.Response.WriteJson(new { Status = "Exists", Message = "Directory already exists" }); } else { FS.CreateDirectory(newDir); context.Response.WriteJson(new { Status = "Ok", Message = "Directory created" }); } } catch (Exception e) { context.Response.WriteJson(new { Status = "Error", Message = "Create directory failed", Detail = e.Message }); } }
public void CreateDirectory(string applicationName, string directoryName, string description) { if (string.IsNullOrWhiteSpace(directoryName)) { throw new SettingsStoreException(Constants.ERROR_DIRECTORY_NO_NAME); } var application = GetApplicationsData(applicationName).SingleOrDefault(); if (application == null) { throw new SettingsNotFoundException(Constants.ERROR_APPLICATION_UNKNOWN); } if (!Auth.AllowCreateDirectory(applicationName, directoryName)) { throw new SettingsAuthorizationException(AuthorizationScope.Directory, AuthorizationLevel.Create, directoryName, Auth.CurrentIdentity.Id); } if (DirectoryExists(application, directoryName)) { throw new SettingsDuplicateException(Constants.ERROR_DIRECTORY_ALREADY_EXISTS); } if (!NameValidator.ValidateName(directoryName)) { throw new SettingsNotFoundException(Constants.ERROR_DIRECTORY_NAME_INVALID); } DirectoryData directory; using (TransactionScope scope = new TransactionScope()) { directory = new DirectoryData(); directory.ApplicationId = application.Id; directory.Name = directoryName.Trim(); if (description != null) { directory.Description = description.Trim(); } directory.Created = DateTime.Now; Store.Context.Directories.Add(directory); Store.Save(); scope.Complete(); } Auth.Invalidate(); }
/// <summary> /// Function that checks for existant files that hasnt been detected by reading Fhsks file it because they are new. /// </summary> /// <param name="lfs">Pre-computed LoadedFileStatus list</param> /// <param name="currentDD">Specific DirectoryData to correct.</param> public static void AddNewFiles(List <LoadedFileStatus> lfs, DirectoryData currentDD) { string[] files = Directory.GetFiles(currentDD.RootPath, "*", SearchOption.AllDirectories); for (int i = 0; i < files.Length; i++) { string buff = files[i].Replace(currentDD.RootPath, ""); if (!currentDD.CheckFileExistanceByRelativePath(buff)) { currentDD.AddFileData(files[i]); lfs.Add(LoadedFileStatus.NotTouched); } } }
private void GetDirectoryData(DirectoryData parentData, string directory, string tabString = "", int currentDepth = 0) { if (searchDepth != -1 && currentDepth <= searchDepth) { System.IO.DirectoryInfo dInfo = new System.IO.DirectoryInfo(directory); if (dInfo.Exists) { DirectoryData dd = new DirectoryData(dInfo, parentData, storeRelativePaths, Directory); pathData.Add(dd); //D.Log(tabString + "DIR: " + directory); DirectoryInfo[] dirs = dInfo.GetDirectories(searchPattern); // filter out any dirs that should be ignored if (ignoreStrings != null) { List <DirectoryInfo> newDirs = new List <DirectoryInfo>(); foreach (DirectoryInfo di in dirs) { string path = di.FullName.Replace(directory + Path.DirectorySeparatorChar.ToString(), ""); bool ignore = false; foreach (string pattern in ignoreStrings) { if (Regex.IsMatch(path, pattern)) { ignore = true; break; } } if (!ignore) { newDirs.Add(di); } } dirs = newDirs.ToArray(); } // recurse through directories foreach (DirectoryInfo di in dirs) { GetDirectoryData(dd, di.FullName, tabString + "\t", currentDepth + 1); } } else { throw new Exception("In GetDirectoryData, but the directory passed (" + directory + ") does not exist!"); } } }
public NSData ProcessDocumentResource(string resourcePath) { SystemLogger.Log(SystemLogger.Module.PLATFORM, "# IPhoneResourceHandler. Processing document resource path: " + resourcePath); // url should be escaped to reach the real filesystem path for the requested file. resourcePath = Uri.UnescapeDataString(resourcePath); // Getting Root Directory for Files in this platform. IFileSystem fileSystemService = (IFileSystem)IPhoneServiceLocator.GetInstance().GetService("file"); DirectoryData rootDir = fileSystemService.GetDirectoryRoot(); resourcePath = Path.Combine(rootDir.FullName, resourcePath); // Get Resources as Binary Data and Write them to the server response return(NSData.FromArray(IPhoneUtils.GetInstance().GetResourceAsBinary(resourcePath, false))); }
private IList <DirectoryEntry> GetDirectoryEntries(DirectoryData directory) { var path = _project.RootPath.Combine(directory.DirectoryName.RelativePath); try { return(_fileSystem.GetDirectoryEntries(path)); } catch (Win32Exception e) { Logger.LogWarn("Skipping directory \"{0}\": {1} ({2})", path, e.Message, e.NativeErrorCode); return(ArrayUtilities.EmptyList <DirectoryEntry> .Instance); } catch (Exception e) { Logger.LogWarn(e, "Skipping directory \"{0}\"", path); return(ArrayUtilities.EmptyList <DirectoryEntry> .Instance); } }
private IList <DirectoryData> GetFlatten(DirectoryData data) { lock (StorageLock) { var list = new List <DirectoryData>(); list.Add(data); if (data.Children?.Any() ?? false) { foreach (var child in data.Children) { list.AddRange(GetFlatten(child)); } } return(list); } }
internal static Items.Directory New(DirectoryData dir, ContentItem parent, IFileSystem fs, ImageSizeCache sizes) { var node = new Directory(dir, parent); node.Set(fs); node.Set(sizes); return node; }
public DirectoryData(DirectoryInfo info, DirectoryData _parent = null, bool storeRelativePath = false, string rootPath = "") { fullName = info.FullName; if ( storeRelativePath ) { fullName = fullName.Replace( rootPath + Path.DirectorySeparatorChar.ToString(), "" ); } parent = _parent; if ( parent != null ) { parent.directories.Add( this ); } }
private bool IsUserInRoleRecursive(string distinguishedUserName, DirectoryData roleEntry) { if (roleEntry == null) { return false; } string[] members; if (!roleEntry.TryGetValue(_membersAttribute, out members)) { // The membership attribute does not exists for this item, cannot be a member here return false; } foreach (string distinguishedMemberName in members) { if (String.Compare(distinguishedMemberName, distinguishedUserName, StringComparison.OrdinalIgnoreCase) == 0) { return true; } DirectoryData member = this._factory.GetEntry(distinguishedMemberName); if (member == null) { continue; } if (member.SchemaClassName == "group") { return IsUserInRoleRecursive(distinguishedUserName, member); } } return false; }
protected void PopulateData(CommunityGroupData cGrp, List<UserData> groupAdmins, DirectoryData[] aCategories) { int groupAdminCount = 0; this.GroupName_TB.Text = cGrp.GroupName; this.ShortDescription_TB.Text = cGrp.GroupShortDescription; this.Description_TB.Text = cGrp.GroupLongDescription; if (cGrp.GroupHidden) { this.PublicJoinHidden_RB.Checked = true; } else { this.PublicJoinYes_RB.Checked = cGrp.GroupEnroll; this.PublicJoinNo_RB.Checked = !(cGrp.GroupEnroll); } this.Location_TB.Text = cGrp.GroupLocation; if (groupAdmins.Count == 0) { ltr_admin_name.Text = cGrp.GroupAdmin.DisplayName.ToString(); } else { int order = 0; for (groupAdminCount = 0; groupAdminCount < groupAdmins.Count; groupAdminCount++) { if (order != 0) this.ltr_admin_name.Text += ", "; if (groupAdmins[groupAdminCount].DisplayName != "") this.ltr_admin_name.Text += groupAdmins[groupAdminCount].DisplayName; else this.ltr_admin_name.Text += groupAdmins[groupAdminCount].FirstName; order += 1; } } //this.ltr_admin_name.Text= this.ltr_admin_name.Text.ToString().Remove(this.ltr_admin_name.Text.ToString().LastIndexOf(","), 1); this.GroupAvatar_TB.Text = cGrp.GroupImage; this.cmd_browse.Attributes.Add("onclick", "javascript:return false;"); this.cmd_browse.Visible = false; this.EnableDistributeToSite_CB.Checked = cGrp.GroupEnableDistributeToSite; this.AllowMembersToManageFolders_CB.Checked = cGrp.AllowMembersToManageFolders; this.chkEnableDocumentNotifications.Checked = cGrp.EnableDocumentsInNotifications; this.chkEnableEmail.Checked = cGrp.EnableGroupEmail; this.lblEmailAccountValue.Text = cGrp.EmailAccountName; this.lblEmailAddressValue.Text = cGrp.EmailAddress; MailServerData mailServer = GetNotificationEmailServer(); this.lblEmailServerPortValue.Text = mailServer.POPPort.ToString(); this.lblEmailServerValue.Text = mailServer.POPServer; this.chkUseSsl.Checked = mailServer.POPSSL; ucEktronGroupEmailSetting.Visible = cGrp.EnableGroupEmail; this.ltr_avatarpath.Text = ""; List<string> cat_list = new List<string>(); string TaxonomyList = string.Empty; if ((aCategories != null) && aCategories.Length > 0) { for (int i = 0; i <= (aCategories.Length - 1); i++) { cat_list.Add(("<li>" + aCategories[i].DirectoryPath.Remove(0, 1).Replace("\\", " > ") + "</li>")); } TaxonomyList = string.Join(string.Empty, cat_list.ToArray()); } else { TaxonomyList = GetMessage("lbl cgroup no cat"); } ltr_cat.Text += TaxonomyList; calendardata = _CalendarApi.GetPublicCalendar(Ektron.Cms.Common.EkEnumeration.WorkSpace.Group, cGrp.GroupId); if (calendardata != null) { this.FeaturesCalendar_CB.Checked = true; } _doesForumExists = m_refCommunityGroupApi.DoesCommunityGroupForumExists(Ektron.Cms.Common.EkEnumeration.WorkSpace.Group, cGrp.GroupId); if (_doesForumExists != 0) { this.FeaturesForum_CB.Checked = true; } var todoList = GetGroupTodoList(); if (todoList != null) { FeaturesTodo_CB.Enabled = false; FeaturesTodo_CB.Checked = true; } if (this.m_sPageAction == "viewgroup") { this.GroupName_TB.Enabled = false; this.ShortDescription_TB.Enabled = false; this.Description_TB.Enabled = false; this.PublicJoinYes_RB.Enabled = false; this.PublicJoinNo_RB.Enabled = false; this.PublicJoinHidden_RB.Enabled = false; this.Location_TB.Enabled = false; this.GroupAvatar_TB.Enabled = false; this.EnableDistributeToSite_CB.Enabled = false; this.AllowMembersToManageFolders_CB.Enabled = false; this.FeaturesCalendar_CB.Enabled = false; this.FeaturesForum_CB.Enabled = false; this.FeaturesTodo_CB.Enabled = false; } else if (this.m_sPageAction == "addeditgroup") { if (this.m_refContentApi.IsAdmin() == false) { this.AllowMembersToManageFolders_CB.Enabled = false; } } }
internal static Items.Directory New(DirectoryData dir, ContentItem parent, IDependencyInjector injector) { var node = new Directory(dir, parent); injector.FulfilDependencies(node); return node; }
private List<string> GetRolesForUserRecursive(DirectoryData entry) { var subtree = new List<string>(); string[] propertyValue; if (entry.TryGetValue(_memberOfAttribute, out propertyValue)) { foreach (string role in propertyValue) { DirectoryData roleEntry = this._factory.GetEntry(role); if (roleEntry == null || roleEntry.SchemaClassName != "group") { continue; } string[] roleName; if (roleEntry.TryGetValue(this._roleNameAttribute, out roleName)) { subtree.Add(roleName[0]); } subtree.AddRange(GetRolesForUserRecursive(roleEntry)); } } return subtree; }
private void GetDirectoryData(DirectoryData parentData, string directory, string tabString = "", int currentDepth = 0) { if ( searchDepth != -1 && currentDepth <= searchDepth ) { System.IO.DirectoryInfo dInfo = new System.IO.DirectoryInfo(directory); if ( dInfo.Exists ) { DirectoryData dd = new DirectoryData(dInfo, parentData, storeRelativePaths, Directory); pathData.Add(dd); //D.Log(tabString + "DIR: " + directory); DirectoryInfo[] dirs = dInfo.GetDirectories(searchPattern); // filter out any dirs that should be ignored if ( ignoreStrings != null ) { List<DirectoryInfo> newDirs = new List<DirectoryInfo>(); foreach( DirectoryInfo di in dirs ) { string path = di.FullName.Replace(directory + Path.DirectorySeparatorChar.ToString(), ""); bool ignore = false; foreach( string pattern in ignoreStrings ) { if ( Regex.IsMatch( path, pattern ) ) { ignore = true; break; } } if ( !ignore ) newDirs.Add(di); } dirs = newDirs.ToArray(); } // recurse through directories foreach( DirectoryInfo di in dirs ) { GetDirectoryData( dd, di.FullName, tabString + "\t", currentDepth + 1 ); } } else { throw new Exception("In GetDirectoryData, but the directory passed (" + directory + ") does not exist!"); } } }
public FileData(FileSystemObjectProperties properties, DirectoryData parent, long fileSize) : base(properties, parent) { _bytesSize = fileSize; }