public TextFileReaderStrategy(bool useEncryptionSystem = false, IDataEncryptor dataEncryptor = null,
bool useRoleBasedSecurity = false, string roleName = null, IFileSecurity fileSecurity = null)
{
this.useEncryptionSystem = useEncryptionSystem;
this.dataEncryptor = dataEncryptor;
this.useRoleBasedSecurity = useRoleBasedSecurity;
this.roleName = roleName;
this.fileSecurity = fileSecurity;
}
public static FileSecurity Unwrap(IFileSecurity fileSecurity)
{
if (fileSecurity == null)
{
return(null);
}
var adapter = fileSecurity as FileSecurityAdapter;
if (adapter == null)
{
throw new InvalidOperationException("Adapter can only accept DirectorySecurityAdaper (provided " + fileSecurity.GetType().Name + ").");
}
return(adapter.Security);
}
public IFileReaderStrategy CreateFileReader(bool useEncryptionSystem = false, bool useRoleBasedSecurity = false, string roleName = null)
{
IDataEncryptor dataEncryptor = null;
if (useEncryptionSystem)
{
dataEncryptor = new DataEncryptorAdapter();
}
IFileSecurity fileSecurity = null;
if (useRoleBasedSecurity)
{
fileSecurity = new FileSecurityAdapter();
}
return(new XmlFileReaderStrategy(useEncryptionSystem, dataEncryptor, useRoleBasedSecurity, roleName, fileSecurity));
}
public FilesIntegration(IDaoFactory daoFactory, IFileSecurity fileSecurity, GlobalStore globalStore)
{
DaoFactory = daoFactory;
FileSecurity = fileSecurity;
GlobalStore = globalStore;
}
public JsonFileReader(IFileEncryption fileEncryption, IFileSecurity fileSecurity)
{
_fileEncryption = fileEncryption;
_fileSecurity = fileSecurity;
}
public void SetAccessControl(IFileSecurity fileSecurity)
{
FileInfoInstance.SetAccessControl(fileSecurity.FileSecurityInstance);
}
public FileStreamBase Create(string path, int bufferSize, FileOptions options, IFileSecurity fileSecurity)
{
return(new FileStreamWrap(File.Create(path, bufferSize, options, ((IWrap <FileSecurity>)fileSecurity).UnderlyingObject)));
}
public FileStreamBase Create(string path, int bufferSize, FileOptions options, IFileSecurity fileSecurity)
{
return new FileStreamWrap(File.Create(path, bufferSize, options, fileSecurity.FileSecurityInstance));
}
public override void SetAccessControl(IFileSecurity fileSecurity)
{
}
// [SecuritySafeCritical]
public abstract void SetAccessControl(IFileSecurity fileSecurity);
public IFileStream Create(string path, int bufferSize, FileOptions options, IFileSecurity fileSecurity)
{
throw new System.NotImplementedException();
}
public void SetAccessControl(string path, IFileSecurity fileSecurity)
{
throw new System.NotImplementedException();
}
public virtual void SetAccessControl(IFileSecurity fileSecurity)
{
_fileInfo.SetAccessControl(AdapterHelper.Unwrap(fileSecurity));
}
public void SetAccessControl(IFileSecurity fileSecurity)
{
_underlyingObject.SetAccessControl(((IWrap <FileSecurity>)fileSecurity).UnderlyingObject);
}
// [SecuritySafeCritical] public abstract void SetAccessControl(IFileSecurity fileSecurity);
/// <inheritdoc />
public void SetAccessControl(IFileSecurity fileSecurity)
{
FileInfoInstance.SetAccessControl(fileSecurity.FileSecurityInstance);
}
public void SetAccessControl(string path, IFileSecurity fileSecurity)
{
File.SetAccessControl(path, ((IWrap<FileSecurity>)fileSecurity).UnderlyingObject);
}
public void SetAccessControl(string path, IFileSecurity fileSecurity)
{
File.SetAccessControl(path, fileSecurity.FileSecurityInstance);
}
public FileStreamBase Create(string path, int bufferSize, FileOptions options, IFileSecurity fileSecurity)
{
return new FileStreamWrap(File.Create(path, bufferSize, options, ((IWrap<FileSecurity>)fileSecurity).UnderlyingObject));
}
public void SetAccessControl(string path, IFileSecurity fileSecurity)
{
File.SetAccessControl(path, ((IWrap <FileSecurity>)fileSecurity).UnderlyingObject);
}
public void SetAccessControl(IFileSecurity fileSecurity)
{
throw new NotImplementedException();
}
//[SecuritySafeCritical]
public override void SetAccessControl(IFileSecurity fileSecurity)
{
_underlyingObject.SetAccessControl(fileSecurity.FileSecurityInstance);
}
public void SetAccessControl(string path, IFileSecurity fileSecurity)
{
File.SetAccessControl(path, fileSecurity.FileSecurityInstance);
}
private IEnumerable <FileEntry> Filter(IEnumerable <FileEntry> entries, FilesSecurityActions action, Guid userId)
{
if (entries == null || !entries.Any())
{
return(Enumerable.Empty <FileEntry>());
}
var user = CoreContext.UserManager.GetUsers(userId);
var isOutsider = user.IsOutsider();
if (isOutsider && action != FilesSecurityActions.Read)
{
return(Enumerable.Empty <FileEntry>());
}
entries = entries.Where(f => f != null);
var result = new List <FileEntry>(entries.Count());
// save entries order
var order = entries.Select((f, i) => new { Id = f.UniqID, Pos = i }).ToDictionary(e => e.Id, e => e.Pos);
// common or my files
Func <FileEntry, bool> filter =
f => f.RootFolderType == FolderType.COMMON ||
f.RootFolderType == FolderType.USER ||
f.RootFolderType == FolderType.SHARE ||
f.RootFolderType == FolderType.Projects;
var isVisitor = user.IsVisitor();
if (entries.Any(filter))
{
var subjects = GetUserSubjects(userId);
List <FileShareRecord> shares = null;
foreach (var e in entries.Where(filter))
{
if (!CoreContext.Authentication.GetAccountByID(userId).IsAuthenticated&& userId != FileConstant.ShareLinkId)
{
continue;
}
if (isOutsider && (e.RootFolderType == FolderType.USER ||
e.RootFolderType == FolderType.SHARE ||
e.RootFolderType == FolderType.TRASH))
{
continue;
}
if (action != FilesSecurityActions.Read && e is Folder && ((Folder)e).FolderType == FolderType.Projects)
{
// Root Projects folder read-only
continue;
}
if (action != FilesSecurityActions.Read && e is Folder && ((Folder)e).FolderType == FolderType.SHARE)
{
// Root Share folder read-only
continue;
}
if (isVisitor && e.ProviderEntry)
{
continue;
}
if (e.RootFolderType == FolderType.USER && e.RootFolderCreator == userId && !isVisitor)
{
// user has all right in his folder
result.Add(e);
continue;
}
if (DefaultCommonShare == FileShare.Read && action == FilesSecurityActions.Read && e is Folder &&
((Folder)e).FolderType == FolderType.COMMON)
{
// all can read Common folder
result.Add(e);
continue;
}
if (action == FilesSecurityActions.Read && e is Folder &&
((Folder)e).FolderType == FolderType.SHARE)
{
// all can read Share folder
result.Add(e);
continue;
}
if (e.RootFolderType == FolderType.COMMON && IsAdministrator(userId))
{
// administrator in Common has all right
result.Add(e);
continue;
}
if (shares == null)
{
shares = GetShares(entries.ToArray()).Join(subjects, r => r.Subject, s => s, (r, s) => r).ToList();
// shares ordered by level
}
FileShareRecord ace;
if (e is File)
{
ace = shares
.OrderBy(r => r, new SubjectComparer(subjects))
.ThenByDescending(r => r.Share)
.FirstOrDefault(r => Equals(r.EntryId, e.ID) && r.EntryType == FileEntryType.File);
if (ace == null)
{
// share on parent folders
ace = shares.Where(r => Equals(r.EntryId, ((File)e).FolderID) && r.EntryType == FileEntryType.Folder)
.OrderBy(r => r, new SubjectComparer(subjects))
.ThenBy(r => r.Level)
.ThenByDescending(r => r.Share)
.FirstOrDefault();
}
}
else
{
ace = shares.Where(r => Equals(r.EntryId, e.ID) && r.EntryType == FileEntryType.Folder)
.OrderBy(r => r, new SubjectComparer(subjects))
.ThenBy(r => r.Level)
.ThenByDescending(r => r.Share)
.FirstOrDefault();
}
var defaultShare = e.RootFolderType == FolderType.USER ? DefaultMyShare : DefaultCommonShare;
e.Access = ace != null ? ace.Share : defaultShare;
if (action == FilesSecurityActions.Read && e.Access != FileShare.Restrict)
{
result.Add(e);
}
else if (action == FilesSecurityActions.Review && (e.Access == FileShare.Review || e.Access == FileShare.ReadWrite))
{
result.Add(e);
}
else if (action == FilesSecurityActions.Edit && e.Access == FileShare.ReadWrite)
{
result.Add(e);
}
else if (action == FilesSecurityActions.Create && e.Access == FileShare.ReadWrite)
{
result.Add(e);
}
else if (e.Access != FileShare.Restrict && e.CreateBy == userId && (e is File || ((Folder)e).FolderType != FolderType.COMMON))
{
result.Add(e);
}
if (e.CreateBy == userId)
{
e.Access = FileShare.None; //HACK: for client
}
}
}
// files in bunch
filter = f => f.RootFolderType == FolderType.BUNCH;
if (entries.Any(filter))
{
using (var folderDao = daoFactory.GetFolderDao())
{
var findedAdapters = new Dictionary <object, IFileSecurity>();
foreach (var e in entries.Where(filter))
{
IFileSecurity adapter = null;
if (!findedAdapters.ContainsKey(e.RootFolderId))
{
var root = folderDao.GetFolder(e.RootFolderId);
if (root != null)
{
var path = folderDao.GetBunchObjectID(root.ID);
adapter = FilesIntegration.GetFileSecurity(path);
}
findedAdapters[e.RootFolderId] = adapter;
}
adapter = findedAdapters[e.RootFolderId];
if (adapter == null)
{
continue;
}
if (adapter.CanRead(e, userId) &&
adapter.CanCreate(e, userId) &&
adapter.CanEdit(e, userId) &&
adapter.CanDelete(e, userId))
{
e.Access = FileShare.None;
result.Add(e);
}
else if (action == FilesSecurityActions.Create && adapter.CanCreate(e, userId))
{
e.Access = FileShare.ReadWrite;
result.Add(e);
}
else if (action == FilesSecurityActions.Delete && adapter.CanDelete(e, userId))
{
e.Access = FileShare.ReadWrite;
result.Add(e);
}
else if (action == FilesSecurityActions.Read && adapter.CanRead(e, userId))
{
if (adapter.CanCreate(e, userId) ||
adapter.CanDelete(e, userId) ||
adapter.CanEdit(e, userId))
{
e.Access = FileShare.ReadWrite;
}
else
{
e.Access = FileShare.Read;
}
result.Add(e);
}
else if (action == FilesSecurityActions.Edit && adapter.CanEdit(e, userId))
{
e.Access = FileShare.ReadWrite;
result.Add(e);
}
}
}
}
// files in trash
filter = f => f.RootFolderType == FolderType.TRASH;
if (entries.Any(filter))
{
using (var folderDao = daoFactory.GetFolderDao())
{
var mytrashId = folderDao.GetFolderID(FileConstant.ModuleId, "trash", userId.ToString(), false);
foreach (var e in entries.Where(filter))
{
// only in my trash
if (Equals(e.RootFolderId, mytrashId))
{
result.Add(e);
}
}
}
}
if (IsAdministrator(userId))
{
// administrator can work with crashed entries (crash in files_folder_tree)
filter = f => f.RootFolderType == FolderType.DEFAULT;
result.AddRange(entries.Where(filter));
}
// restore entries order
result.Sort((x, y) => order[x.UniqID].CompareTo(order[y.UniqID]));
return(result);
}
public FileStreamBase Create(string path, int bufferSize, FileOptions options, IFileSecurity fileSecurity)
{
return(new FileStreamWrap(File.Create(path, bufferSize, options, fileSecurity.FileSecurityInstance)));
}
