private IQueryable <FileTypeDAO> OrFilter(IQueryable <FileTypeDAO> query, FileTypeFilter filter) { if (filter.OrFilter == null || filter.OrFilter.Count == 0) { return(query); } IQueryable <FileTypeDAO> initQuery = query.Where(q => false); foreach (FileTypeFilter FileTypeFilter in filter.OrFilter) { IQueryable <FileTypeDAO> queryable = query; if (FileTypeFilter.Id != null && FileTypeFilter.Id.HasValue) { queryable = queryable.Where(q => q.Id, FileTypeFilter.Id); } if (FileTypeFilter.Code != null && FileTypeFilter.Code.HasValue) { queryable = queryable.Where(q => q.Code, FileTypeFilter.Code); } if (FileTypeFilter.Name != null && FileTypeFilter.Name.HasValue) { queryable = queryable.Where(q => q.Name, FileTypeFilter.Name); } initQuery = initQuery.Union(queryable); } return(initQuery); }
private NativeFilePickerAcceptType[] BuildFileTypesMap() { var allExtensions = FileTypeFilter.Except(new[] { "*" }); var acceptTypes = allExtensions .Select(fileType => BuildNativeFilePickerAcceptType(fileType)) .ToList(); if (!FileTypeFilter.Contains("*")) { var fullAcceptItem = new NativeFilePickerAcceptTypeItem { MimeType = "*/*", Extensions = allExtensions.ToArray() }; var fullAcceptType = new NativeFilePickerAcceptType() { Description = "All files", Accept = new[] { fullAcceptItem } }; acceptTypes.Insert(0, fullAcceptType); } return(acceptTypes.ToArray()); }
///<inheritdoc/> public async Task <IList <ImageFile> > GetFilesFromFolderAsync(string folderPath) { folderPath = Path.GetDirectoryName(folderPath); StorageFolder targetStorageFolder = null; try { targetStorageFolder = await StorageFolder.GetFolderFromPathAsync(folderPath); } catch (UnauthorizedAccessException e) { throw new Contract.Exceptions.UnauthorizedAccessException(e); } var storageFiles = (await targetStorageFolder.GetFilesAsync()); List <ImageFile> imageFiles = new List <ImageFile>(); foreach (var item in storageFiles) { if (FileTypeFilter.Contains(item.FileType.ToLower())) { imageFiles.Add(await FileToImageFileAsync(item, false)); } } return(imageFiles); }
public async Task <ActionResult <List <Contract_FileTypeDTO> > > SingleListFileType([FromBody] Contract_FileTypeFilterDTO Contract_FileTypeFilterDTO) { if (UnAuthorization) { return(Forbid()); } if (!ModelState.IsValid) { throw new BindException(ModelState); } FileTypeFilter FileTypeFilter = new FileTypeFilter(); FileTypeFilter.Skip = 0; FileTypeFilter.Take = 20; FileTypeFilter.OrderBy = FileTypeOrder.Id; FileTypeFilter.OrderType = OrderType.ASC; FileTypeFilter.Selects = FileTypeSelect.ALL; FileTypeFilter.Id = Contract_FileTypeFilterDTO.Id; FileTypeFilter.Code = Contract_FileTypeFilterDTO.Code; FileTypeFilter.Name = Contract_FileTypeFilterDTO.Name; List <FileType> FileTypes = await FileTypeService.List(FileTypeFilter); List <Contract_FileTypeDTO> Contract_FileTypeDTOs = FileTypes .Select(x => new Contract_FileTypeDTO(x)).ToList(); return(Contract_FileTypeDTOs); }
/// <summary> /// Get the iFolder System Policy /// </summary> /// <returns>An SystemPolicy Object</returns> public static SystemPolicy GetPolicy() { SystemPolicy props = new SystemPolicy(); Store store = Store.GetStore(); string domain = store.DefaultDomain; // space limit props.SpaceLimitUser = DiskSpaceQuota.GetLimit(domain); //ifolder limit props.NoiFoldersLimit = iFolderLimit.GetLimit(domain); // sync internval props.SyncInterval = Simias.Policy.SyncInterval.GetInterval(domain); // file size props.FileSizeLimit = FileSizeFilter.GetLimit(domain); props.EncryptionStatus = Simias.Policy.SecurityState.GetStatus(domain); // Disable sharing policy props.SharingStatus = Simias.Policy.Sharing.GetStatus(domain); // file types SystemPolicy.SplitFileTypes(FileTypeFilter.GetPatterns(domain), out props.FileTypesIncludes, out props.FileTypesExcludes); return(props); }
public async Task <int> Count(FileTypeFilter filter) { IQueryable <FileTypeDAO> FileTypes = DataContext.FileType.AsNoTracking(); FileTypes = DynamicFilter(FileTypes, filter); return(await FileTypes.CountAsync()); }
public SearchStartResponse SearchStartAsync(string folderPath, bool recursive = true, string[] globPatterns = null, string[] extentionPatterns = null, FileTypeFilter fileType = FileTypeFilter.file, long minSizeBytes = 0, long maxSizeBytes = long.MaxValue, DateTime?modifiedTimeFrom = null, DateTime?modifiedTimeTo = null, DateTime?createdTimeFrom = null, DateTime?createdTimeTo = null, DateTime?accessedTimeTo = null, DateTime?accessedTimeFrom = null, string owner = null, string group = null) { dynamic requiredParams = new { api = "SYNO.FileStation.Search", version = 1, method = "start", folder_path = folderPath, recursive, pattern = string.Join(",", globPatterns ?? new[] { "" }), extension = string.Join(",", extentionPatterns ?? new[] { "" }), filetype = fileType, size_from = minSizeBytes, size_to = maxSizeBytes, mtime_from = modifiedTimeFrom, mtime_to = modifiedTimeTo, crtime_from = createdTimeFrom, crtime_to = createdTimeTo, atime_from = accessedTimeFrom, atiime_to = accessedTimeTo, owner, group }; var proc = new FuncProcessor <SearchStartResponse>("/entry.cgi", _session.sid, requiredParams); return(proc.Run()); }
public SearchStatusResponse SearchStatus(string taskId, int?offset = null, int?limit = 100, SortBy sortBy = SortBy.name, SortDirection sortDirection = SortDirection.asc, string[] pattern = null, FileTypeFilter fileType = FileTypeFilter.file, FileSearchListAddtionalOptions additional = null) { dynamic requiredParams = new { api = "SYNO.FileStation.Search", version = 1, method = "list", taskid = taskId, offset, limit, sort_by = sortBy, sort_direction = sortDirection, pattern = string.Join(",", pattern ?? new[] { "" }), filetype = fileType }; var proc = new FuncProcessor <SearchStatusResponse>("/entry.cgi", _session.sid, requiredParams, new { additional = TrueBooleanValuesFromObjectToCommaSeparatedList(additional) }); return(proc.Run()); }
/// <summary> /// Get the User Policy /// </summary> /// <param name="userID">The User ID</param> /// <returns>The UserPolicy Object</returns> public static UserPolicy GetPolicy(string userID, string AdminId) { UserPolicy props = new UserPolicy(); props.UserID = userID; Store store = Store.GetStore(); Domain domain = store.GetDomain(store.DefaultDomain); Member member = domain.GetMemberByID(userID); if (member == null) { throw new UserDoesNotExistException(userID); } Access.Rights rights = (member != null) ? member.Rights : Access.Rights.Deny; props.isAdmin = (rights == Access.Rights.Admin); props.LoginEnabled = !(domain.GetLoginpolicy(userID)); // disk space DiskSpaceQuota quota = DiskSpaceQuota.Get(member); props.SpaceLimitEffective = quota.Limit; //props.SpaceUsed = quota.UsedSpace; props.SpaceUsed = Simias.Server.Catalog.GetUsedSpaceOfUserID(userID); //props.SpaceAvailable = quota.AvailableSpace; props.SpaceLimit = DiskSpaceQuota.GetLimit(member); props.SpaceAvailable = props.SpaceLimitEffective - props.SpaceUsed; props.EncryptionStatus = Simias.Policy.SecurityState.GetStatus(member); // To return disable sharing value for an user props.SharingStatus = Simias.Policy.Sharing.GetStatus(member); // file size props.FileSizeLimit = FileSizeFilter.GetLimit(member); props.FileSizeLimitEffective = FileSizeFilter.Get(member).Limit; //No of ifolders limit props.NoiFoldersLimit = iFolderLimit.Get(member).Limit; // sync interval props.SyncInterval = Simias.Policy.SyncInterval.GetInterval(member); props.SyncIntervalEffective = Simias.Policy.SyncInterval.Get(member).Interval; // file types SystemPolicy.SplitFileTypes(FileTypeFilter.GetPatterns(member), out props.FileTypesIncludes, out props.FileTypesExcludes); // file types effective SystemPolicy.SplitFileTypes(FileTypeFilter.Get(member, false).FilterUserList, out props.FileTypesIncludesEffective, out props.FileTypesExcludesEffective); props.AdminGroupRights = iFolderUser.GetAdminRights(AdminId, userID); return(props); }
/// <summary> /// Constructs a SyncPolicy object. /// </summary> /// <param name="collection">The collection the policy belongs to.</param> public SyncPolicy(Collection collection) { // Check if files pass policy. //Member member = collection.GetCurrentMember(); dsQuota = DiskSpaceQuota.Get(collection); fsFilter = FileSizeFilter.Get(collection); ftFilter = FileTypeFilter.Get(collection); OwnerID = collection.Owner.UserID; }
/// <summary> /// Create An iFolder Entry /// </summary> /// <param name="c"></param> /// <param name="parent"></param> /// <param name="type"></param> /// <param name="entryName"></param> /// <param name="path"></param> /// <returns></returns> internal static Node CreateEntry(Collection c, Node parent, iFolderEntryType type, string entryName, out string path, bool DontCheckPolicies) { Node result = null; // NOTE: a new entry off the iFolder is not allowed, it must be off the root directory node or lower if ((parent == null) || (c.ID.Equals(parent.ID))) { throw new EntryDoesNotExistException(parent.ID); } // NOTE: only directories can have children if (!parent.IsBaseType(NodeTypes.DirNodeType)) { throw new DirectoryEntryRequiredException(parent.ID); } // check the name CheckName(entryName); // create new path DirNode parentDirNode = (DirNode)parent; path = parentDirNode.GetFullPath(c); path = System.IO.Path.Combine(path, entryName); // check for existing entry (case insensitive test) if (SyncFile.DoesNodeExist(c, parentDirNode, entryName)) { throw new EntryAlreadyExistException(entryName); } // directory if (type == iFolderEntryType.Directory) { result = new DirNode(c, parentDirNode, entryName); } // file else { if (DontCheckPolicies == false) { // check file type policy FileTypeFilter filter = FileTypeFilter.Get(c); if (!filter.Allowed(entryName)) { throw new FileTypeException(entryName); } } result = new FileNode(c, parentDirNode, entryName); } return(result); }
private static ReactiveCommand <Unit, Unit> RunScriptCommand(ScriptDeployer deployer, IFilePicker filePicker) { return(ReactiveCommand.CreateFromObservable(() => { var filter = new FileTypeFilter("Deployer Script", "*.ds", "*.txt"); return filePicker .Open("Select a script", new[] { filter }) .Where(x => x != null) .SelectMany(file => Observable.FromAsync(() => deployer.RunScript(file.Source.LocalPath))); })); }
private string[] GetMimeTypes() { if (FileTypeFilter.Contains("*")) { return(new[] { "*/*" }); } return(FileTypeFilter .Select(extension => MimeTypeService.GetFromExtension(extension)) .Distinct() .ToArray()); }
public async Task <List <FileType> > List(FileTypeFilter FileTypeFilter) { try { List <FileType> FileTypes = await UOW.FileTypeRepository.List(FileTypeFilter); return(FileTypes); } catch (Exception ex) { await Logging.CreateSystemLog(ex, nameof(FileTypeService)); } return(null); }
public async Task <int> Count(FileTypeFilter FileTypeFilter) { try { int result = await UOW.FileTypeRepository.Count(FileTypeFilter); return(result); } catch (Exception ex) { await Logging.CreateSystemLog(ex, nameof(FileTypeService)); } return(0); }
public async Task <List <FileType> > List(FileTypeFilter filter) { if (filter == null) { return(new List <FileType>()); } IQueryable <FileTypeDAO> FileTypeDAOs = DataContext.FileType.AsNoTracking(); FileTypeDAOs = DynamicFilter(FileTypeDAOs, filter); FileTypeDAOs = DynamicOrder(FileTypeDAOs, filter); List <FileType> FileTypes = await DynamicSelect(FileTypeDAOs, filter); return(FileTypes); }
/// <summary> /// Get the iFolder Policy /// </summary> /// <param name="ifolderID">The iFolder ID</param> /// <param name="accessID">The Access User ID</param> /// <param name="adminID">The logged in Admin ID</param> /// <returns>An iFolderPolicy Object</returns> public static iFolderPolicy GetPolicy(string ifolderID, string accessID, string adminID) { iFolderPolicy props = new iFolderPolicy(); props.iFolderID = ifolderID; Store store = Store.GetStore(); Collection c = store.GetCollectionByID(ifolderID); if (c == null) { throw new iFolderDoesNotExistException(ifolderID); } // impersonate iFolder.Impersonate(c, accessID); // disk space DiskSpaceQuota dsq = DiskSpaceQuota.Get(c); props.SpaceLimitEffective = dsq.Limit; props.SpaceAvailable = dsq.AvailableSpace; props.SpaceUsed = c.StorageSize; props.SpaceLimit = DiskSpaceQuota.GetLimit(c); // no syncing (locked) //props.Locked = IsLocked(c); props.Locked = c.Disabled; // sync interval props.SyncInterval = Simias.Policy.SyncInterval.GetInterval(c); props.SyncIntervalEffective = Simias.Policy.SyncInterval.Get(c).Interval; // to return the value of disable sharing policy for an iFolder props.SharingStatus = Simias.Policy.Sharing.GetStatus(c); // file types SystemPolicy.SplitFileTypes(FileTypeFilter.GetPatterns(c), out props.FileTypesIncludes, out props.FileTypesExcludes); SystemPolicy.SplitFileTypes(FileTypeFilter.Get(c, false).FilterList, out props.FileTypesIncludesEffective, out props.FileTypesExcludesEffective); // file size props.FileSizeLimit = Simias.Policy.FileSizeFilter.GetLimit(c); props.FileSizeLimitEffective = Simias.Policy.FileSizeFilter.Get(c).Limit; props.AdminGroupRights = iFolderUser.GetAdminRights(adminID, c.Owner.UserID); return(props); }
static void Main(string[] args) { //测试SubfolderClass List <string> temp = new List <string>(); temp.Add(@"F:\music\Mozart\Mozart - Violin Concertos"); temp.Add(@"F:\music\Mozart-Requiem-Bernstein (APE)"); SubfoldersClass ftc = new SubfoldersClass(temp); ftc.test(); //假设这是返回的被选择的文件夹路径List ftc.TargetFolderPaths = temp; //得到一个装着需要的文件格式的List<string> string fileTypeInput = "mp3, cue, ape"; InputFileTypes ift = new InputFileTypes(fileTypeInput); //用来装 被筛选过的文件信息 List <FileTypeFilter> ftfList = new List <FileTypeFilter>(); for (int i = 0; i < ftc.TargetFolderPaths.Count; i++) { FileTypeFilter ftf = new FileTypeFilter(ift.FileTypesList, ftc.TargetFolderPaths[i]); ftfList.Add(ftf); } //test for (int i = 0; i < ftc.TargetFolderPaths.Count; i++) { for (int j = 0; j < ftfList[i].Count; j++) { Console.WriteLine(ftfList[i].FileNames[j]); Console.WriteLine(ftfList[i].FilePaths[j]); Console.WriteLine(); } } string filePath = @"F:\music\Bach\Bach.-.[Goldberg.Variations(Walcha.EMI.Angle)].专辑.(Flac)\033 Aria.mp3"; Tools.MusicFile musicFileTest = new MusicFile(filePath); musicFileTest.test(); Console.WriteLine(musicFileTest.MusicDuration); }
public async Task <FileTypeFilter> ToFilter(FileTypeFilter filter) { if (filter.OrFilter == null) { filter.OrFilter = new List <FileTypeFilter>(); } if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0) { return(filter); } foreach (var currentFilter in CurrentContext.Filters) { FileTypeFilter subFilter = new FileTypeFilter(); filter.OrFilter.Add(subFilter); List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value; foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions) { if (FilterPermissionDefinition.Name == nameof(subFilter.Id)) { subFilter.Id = FilterBuilder.Merge(subFilter.Id, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.Code)) { subFilter.Code = FilterBuilder.Merge(subFilter.Code, FilterPermissionDefinition.StringFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.Name)) { subFilter.Name = FilterBuilder.Merge(subFilter.Name, FilterPermissionDefinition.StringFilter); } if (FilterPermissionDefinition.Name == nameof(CurrentContext.UserId) && FilterPermissionDefinition.IdFilter != null) { if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.IS.Id) { } if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.ISNT.Id) { } } } } return(filter); }
private NativeFilePickerAcceptType[] BuildFileTypesMap() { var acceptTypes = new List <NativeFilePickerAcceptType>(); var mimeTypeGroups = FileTypeFilter .Except(new[] { "*" }) .GroupBy(f => MimeTypeService.GetFromExtension(f)) .ToArray(); var allAccepts = new List <NativeFilePickerAcceptTypeItem>(); foreach (var mimeTypeGroup in mimeTypeGroups) { var extensions = mimeTypeGroup.ToArray(); var acceptType = new NativeFilePickerAcceptType(); acceptType.Description = extensions.Length > 1 ? string.Empty : extensions.First(); var acceptItem = new NativeFilePickerAcceptTypeItem() { MimeType = mimeTypeGroup.Key, Extensions = extensions }; allAccepts.Add(acceptItem); acceptType.Accept = new[] { acceptItem }; acceptTypes.Add(acceptType); } if (allAccepts.Count > 1) { var fullAcceptType = new NativeFilePickerAcceptType() { Description = "All", Accept = allAccepts.ToArray() }; acceptTypes.Insert(0, fullAcceptType); } return(acceptTypes.ToArray()); }
/// <summary> /// 打开多个文件 /// </summary> /// <param name="filter"></param> /// <param name="filesOk"></param> public static void OpenFile(FileTypeFilter filter, Action <List <string> > filesOk) { OpenFileDialog dialog = new OpenFileDialog { Filter = GetFilterStr(filter), InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop), Multiselect = true, }; if (dialog.ShowDialog() == DialogResult.OK) { var fileNames = dialog.FileNames; if (fileNames == null || fileNames.Length == 0) { return; } filesOk?.Invoke(fileNames.ToList()); } }
public async Task <bool> ValidateId(FileType FileType) { FileTypeFilter FileTypeFilter = new FileTypeFilter { Skip = 0, Take = 10, Id = new IdFilter { Equal = FileType.Id }, Selects = FileTypeSelect.Id }; int count = await UOW.FileTypeRepository.Count(FileTypeFilter); if (count == 0) { FileType.AddError(nameof(FileTypeValidator), nameof(FileType.Id), ErrorCode.IdNotExisted); } return(count == 1); }
/// <summary> /// 打开一个文件 /// </summary> /// <param name="filter"></param> /// <param name="fileOk"></param> public static void OpenFile(FileTypeFilter filter, Action <string> fileOk) { Debug.Assert(fileOk != null); OpenFileDialog ofd = new OpenFileDialog { Filter = GetFilterStr(filter), InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop), Multiselect = false, CheckFileExists = true, }; if (ofd.ShowDialog() == DialogResult.OK) { string fileName = ofd.FileName; if (string.IsNullOrEmpty(fileName)) { return; } fileOk.Invoke(fileName); } }
/// <summary> /// Set the iFolder System Policy /// </summary> /// <param name="props">The SystemPolicy Object</param> public static void SetPolicy(SystemPolicy props) { Store store = Store.GetStore(); string domain = store.DefaultDomain; // space limit if (props.SpaceLimitUser >= -1) { DiskSpaceQuota.Set(domain, props.SpaceLimitUser); } // ifolder limit iFolderLimit.Set(domain, props.NoiFoldersLimit); // sync interval if (props.SyncInterval >= 0) { Simias.Policy.SyncInterval.Set(domain, props.SyncInterval); } // Added by Ramesh //Encryption Status Simias.Policy.SecurityState.Create(domain, props.EncryptionStatus); // Setting the enumerator value for disabling sharing Simias.Policy.Sharing.Create(domain, props.SharingStatus); // file size if (props.FileSizeLimit >= 0) { FileSizeFilter.Set(domain, props.FileSizeLimit); } // file types if ((props.FileTypesExcludes != null) || (props.FileTypesIncludes != null)) { FileTypeFilter.Set(domain, SystemPolicy.CombineFileTypes( props.FileTypesIncludes, props.FileTypesExcludes)); } }
/// <summary> /// 保存文件 /// </summary> /// <param name="filter"></param> /// <param name="defaultName"></param> /// <param name="fileOk"></param> public static void SaveFile(FileTypeFilter filter, string defaultName, Action <string> fileOk) { Debug.Assert(fileOk != null); SaveFileDialog sfd = new SaveFileDialog() { Filter = GetFilterStr(filter), InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop), FileName = defaultName, AddExtension = true, }; if (sfd.ShowDialog() == DialogResult.OK) { string fileName = sfd.FileName; if (string.IsNullOrWhiteSpace(fileName)) { return; } fileOk.Invoke(fileName); } }
private async Task <FilePickerSelectedFilesArray> NativePickerPickFilesAsync(bool multiple, CancellationToken token) { var showAllEntryParameter = FileTypeFilter.Contains("*") ? "true" : "false"; var multipleParameter = multiple ? "true" : "false"; var fileTypeAcceptTypes = BuildFileTypesMap(); var fileTypeAcceptTypesJson = JsonHelper.Serialize(fileTypeAcceptTypes); var fileTypeMapParameter = WebAssemblyRuntime.EscapeJs(fileTypeAcceptTypesJson); var nativeStorageItemInfosJson = await WebAssemblyRuntime.InvokeAsync($"{JsType}.nativePickFilesAsync({multipleParameter},{showAllEntryParameter},'{fileTypeMapParameter}')"); var infos = JsonHelper.Deserialize <NativeStorageItemInfo[]>(nativeStorageItemInfosJson); var results = new List <StorageFile>(); foreach (var info in infos) { var storageFile = StorageFile.GetFromNativeInfo(info); results.Add(storageFile); } return(new FilePickerSelectedFilesArray(results.ToArray())); }
private void UserControl_Loaded(object sender, RoutedEventArgs e) { if (!isPopulated) { try { if (!Directory.Exists(RootPath)) { log.WriteToLog(LogMsgType.Error, "Root path not found: \"{0}\"", RootPath); RootPath = null; } if (FileTypeFilter.Count == 0) { FileTypeFilter.Add(".*"); } Refresh(); } catch (Exception ex) { log.WriteToLog(ex); } } }
private FilePickerSelectedFilesArray PickFiles(bool pickMultiple, CancellationToken token) { var openPanel = new NSOpenPanel { CanChooseFiles = true, CanChooseDirectories = false, AllowsMultipleSelection = pickMultiple, AllowsOtherFileTypes = FileTypeFilter.Contains("*") }; if (!openPanel.AllowsOtherFileTypes) { var fileTypes = GetFileTypes(); openPanel.AllowedFileTypes = fileTypes; } if (!string.IsNullOrEmpty(CommitButtonText)) { openPanel.Prompt = CommitButtonText; } var result = openPanel.RunModal(); if (result == ModalResponseOk) { if (openPanel.Urls != null) { var files = openPanel.Urls .Where(url => url?.Path != null) .Select(url => StorageFile.GetFileFromPath(url.Path)) .ToArray(); return(new FilePickerSelectedFilesArray(files)); } } return(FilePickerSelectedFilesArray.Empty); }
/// <summary> /// Set the User Policy /// </summary> /// <param name="props">The UserPolicy Object</param> public static void SetPolicy(UserPolicy props) { Store store = Store.GetStore(); Domain domain = store.GetDomain(store.DefaultDomain); Member member = domain.GetMemberByID(props.UserID); if (member == null) { throw new UserDoesNotExistException(props.UserID); } if (props.LoginEnabled == true) { domain.SetLoginDisabled(props.UserID, false); } else { domain.SetLoginDisabled(props.UserID, true); } // Added by Ramesh if (props.EncryptionStatus >= 0) { Simias.Policy.SecurityState.Create(member, props.EncryptionStatus); } // to set disable sharing policy value for an user if (props.SharingStatus >= 0) { Simias.Policy.Sharing.Create(member, props.SharingStatus); } // disk space if (props.SpaceLimit >= -1) { DiskSpaceQuota.Set(member, props.SpaceLimit); } //limiting no of ifolder per user policy. if (props.NoiFoldersLimit >= -2) { iFolderLimit.Set(member, props.NoiFoldersLimit); } // file size if (props.FileSizeLimit >= 0) { FileSizeFilter.Set(member, props.FileSizeLimit); } // sync interval if (props.SyncInterval >= 0) { Simias.Policy.SyncInterval.Set(member, props.SyncInterval); } // file types if ((props.FileTypesExcludes != null) || (props.FileTypesIncludes != null)) { FileTypeFilter.Set(member, SystemPolicy.CombineFileTypes( props.FileTypesIncludes, props.FileTypesExcludes)); } }
/// <summary> /// Create An iFolder Entry /// </summary> /// <param name="ifolderID">The iFolder ID</param> /// <param name="parentID">The Parent Entry ID</param> /// <param name="entryName">The New Entry Name</param> /// <param name="type">The iFolder Entry Type</param> /// <param name="accessID">The Access User ID</param> /// <returns>An iFolderEntry Object</returns> public static iFolderEntry CreateEntry(string ifolderID, string parentID, iFolderEntryType type, string entryName, string accessID, bool DontCheckPolicies) { Store store = Store.GetStore(); // collection Collection c = store.GetCollectionByID(ifolderID); if (c == null) { throw new iFolderDoesNotExistException(ifolderID); } // does member exist? Member member = c.GetMemberByID(accessID); if (member == null && Simias.Service.Manager.LdapServiceEnabled == true) { Domain domain = store.GetDomain(store.DefaultDomain); string[] IDs = domain.GetMemberFamilyList(accessID); foreach (string id in IDs) { member = c.GetMemberByID(id); if (member != null) { break; } } } if (member == null) { throw new MemberDoesNotExistException(accessID); } // impersonate iFolder.Impersonate(c, accessID); Node parent = c.GetNodeByID(parentID); string path; Node entry = CreateEntry(c, parent, type, entryName, out path, DontCheckPolicies); // directory if (type == iFolderEntryType.Directory) { try { // create directory and node DirectoryInfo info = Directory.CreateDirectory(path); // update (entry as DirNode).CreationTime = info.CreationTime; c.Commit(entry); } catch { if (Directory.Exists(path)) { Directory.Delete(path); } throw; } } // file else { if (DontCheckPolicies == false) { // check file type policy FileTypeFilter filter = FileTypeFilter.Get(c); if (!filter.Allowed(entryName)) { throw new FileTypeException(entryName); } } try { // create the file and node File.Create(path).Close(); // update (entry as FileNode).UpdateFileInfo(c); c.Commit(entry); } catch { if (File.Exists(path)) { File.Delete(path); } throw; } } // open the new node Node n = c.GetNodeByID(entry.ID); return(iFolderEntry.GetEntry(c, n)); }