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));
}
