public FolderWrapper <T> Get <T>(Folder <T> folder)
{
var result = Get <FolderWrapper <T>, T>(folder);
result.ParentId = folder.ParentFolderID;
if (folder.RootFolderType == FolderType.USER &&
!Equals(folder.RootFolderCreator, AuthContext.CurrentAccount.ID))
{
result.RootFolderType = FolderType.SHARE;
var folderDao = DaoFactory.GetFolderDao <T>();
var parentFolder = folderDao.GetFolder(folder.ParentFolderID);
if (!FileSecurity.CanRead(parentFolder))
{
result.ParentId = GlobalFolderHelper.GetFolderShare <T>();
}
}
result.FilesCount = folder.TotalFiles;
result.FoldersCount = folder.TotalSubFolders;
result.IsShareable = folder.Shareable.NullIfDefault();
result.New = folder.NewForMe;
return(result);
}
public FolderWrapper <T> Get <T>(Folder <T> folder, List <Tuple <FileEntry <T>, bool> > folders = null)
{
var result = GetFolderWrapper(folder);
result.ParentId = folder.FolderID;
if (folder.RootFolderType == FolderType.USER &&
!Equals(folder.RootFolderCreator, AuthContext.CurrentAccount.ID))
{
result.RootFolderType = FolderType.SHARE;
var folderDao = DaoFactory.GetFolderDao <T>();
FileEntry <T> parentFolder;
if (folders != null)
{
var folderWithRight = folders.FirstOrDefault(f => f.Item1.ID.Equals(folder.FolderID));
if (folderWithRight == null || !folderWithRight.Item2)
{
result.ParentId = GlobalFolderHelper.GetFolderShare <T>();
}
}
else
{
parentFolder = folderDao.GetFolder(folder.FolderID);
if (!FileSecurity.CanRead(parentFolder))
{
result.ParentId = GlobalFolderHelper.GetFolderShare <T>();
}
}
}
return(result);
}
public override bool VisibleFor(Feed.Aggregator.Feed feed, object data, Guid userId)
{
if (!WebItemSecurity.IsAvailableForUser(ProductID, userId))
{
return(false);
}
var tuple = (Tuple <Folder <int>, SmallShareRecord>)data;
var folder = tuple.Item1;
var shareRecord = tuple.Item2;
bool targetCond;
if (feed.Target != null)
{
if (shareRecord != null && shareRecord.ShareBy == userId)
{
return(false);
}
var owner = (Guid)feed.Target;
var groupUsers = UserManager.GetUsersByGroup(owner).Select(x => x.ID).ToList();
if (!groupUsers.Any())
{
groupUsers.Add(owner);
}
targetCond = groupUsers.Contains(userId);
}
else
{
targetCond = true;
}
return(targetCond && FileSecurity.CanRead(folder, userId));
}
private Document CreateDocument <T>(T fileId, string documentName, string folderId, out File <T> file)
{
var fileDao = DaoFactory.GetFileDao <T>();
file = fileDao.GetFile(fileId);
if (file == null)
{
throw new Exception(FilesCommonResource.ErrorMassage_FileNotFound);
}
if (!FileSecurity.CanRead(file))
{
throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException_ReadFile);
}
if (!SupportedFormats.Contains(FileUtility.GetFileExtension(file.Title)))
{
throw new ArgumentException(FilesCommonResource.ErrorMassage_NotSupportedFormat);
}
if (file.ContentLength > MaxFileSize)
{
throw new Exception(FileSizeComment.GetFileSizeExceptionString(MaxFileSize));
}
byte[] fileBytes;
using (var stream = fileDao.GetFileStream(file))
{
var buffer = new byte[16 * 1024];
using var ms = new MemoryStream();
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
fileBytes = ms.ToArray();
}
if (string.IsNullOrEmpty(documentName))
{
documentName = file.Title;
}
var document = new Document
{
DocumentBase64 = Convert.ToBase64String(fileBytes),
DocumentFields = new List <NameValue>
{
new NameValue {
Name = FilesLinkUtility.FolderId, Value = folderId
},
new NameValue {
Name = FilesLinkUtility.FileTitle, Value = file.Title
},
},
DocumentId = "1", //file.ID.ToString(),
FileExtension = FileUtility.GetFileExtension(file.Title),
Name = documentName,
};
return(document);
}
public FileWrapper <T> Get <T>(File <T> file)
{
var result = Get <FileWrapper <T>, T>(file);
result.FolderId = file.FolderID;
if (file.RootFolderType == FolderType.USER &&
!Equals(file.RootFolderCreator, AuthContext.CurrentAccount.ID))
{
result.RootFolderType = FolderType.SHARE;
var folderDao = DaoFactory.GetFolderDao <T>();
var parentFolder = folderDao.GetFolder(file.FolderID);
if (!FileSecurity.CanRead(parentFolder))
{
result.FolderId = GlobalFolderHelper.GetFolderShare <T>();
}
}
result.FileExst = FileUtility.GetFileExtension(file.Title);
result.FileType = FileUtility.GetFileTypeByExtention(result.FileExst);
result.Version = file.Version;
result.VersionGroup = file.VersionGroup;
result.ContentLength = file.ContentLengthString;
result.FileStatus = file.FileStatus;
result.PureContentLength = file.ContentLength.NullIfDefault();
result.Comment = file.Comment;
result.Encrypted = file.Encrypted.NullIfDefault();
result.Locked = file.Locked.NullIfDefault();
result.LockedBy = file.LockedBy;
try
{
result.ViewUrl = CommonLinkUtility.GetFullAbsolutePath(file.DownloadUrl);
result.WebUrl = CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.GetFileWebPreviewUrl(FileUtility, file.Title, file.ID));
}
catch (Exception)
{
//Don't catch anything here because of httpcontext
}
return(result);
}
public ConvertFileOperationResult GetStatus(KeyValuePair <File <T>, bool> pair, FileSecurity fileSecurity)
{
var file = pair.Key;
var key = GetKey(file);
var operation = cache.Get <ConvertFileOperationResult>(key);
if (operation != null && (pair.Value || fileSecurity.CanRead(file)))
{
lock (locker)
{
if (operation.Progress == 100)
{
conversionQueue.Remove(file);
cache.Remove(key);
}
return(operation);
}
}
return(null);
}
public override void VisibleFor(List <Tuple <FeedRow, object> > feed, Guid userId)
{
if (!WebItemSecurity.IsAvailableForUser(ProductID, userId))
{
return;
}
var fileSecurity = new FileSecurity(new DaoFactory());
var feed1 = feed.Select(r =>
{
var tuple = (Tuple <File, SmallShareRecord>)r.Item2;
return(new Tuple <FeedRow, File, SmallShareRecord>(r.Item1, tuple.Item1, tuple.Item2));
})
.ToList();
var files = feed1.Where(r => r.Item1.Feed.Target == null).Select(r => r.Item2).ToList();
foreach (var f in feed1.Where(r => r.Item1.Feed.Target != null && !(r.Item3 != null && r.Item3.ShareBy == userId)))
{
var file = f.Item2;
if (IsTarget(f.Item1.Feed.Target, userId) && !files.Any(r => r.UniqID.Equals(file.UniqID)))
{
files.Add(file);
}
}
var canRead = fileSecurity.CanRead(files, userId).Where(r => r.Item2).ToList();
foreach (var f in feed1)
{
if (IsTarget(f.Item1.Feed.Target, userId) && canRead.Any(r => r.Item1.ID.Equals(f.Item2.ID)))
{
f.Item1.Users.Add(userId);
}
}
}
public FolderContentWrapper <T> Get <T>(DataWrapper <T> folderItems, int startIndex)
{
var foldersIntWithRights = GetFoldersIntWithRights <int>();
var foldersStringWithRights = GetFoldersIntWithRights <string>();
var result = new FolderContentWrapper <T>
{
Files = folderItems.Entries
.Where(r => r.FileEntryType == FileEntryType.File)
.Select(r =>
{
FileEntryWrapper wrapper = null;
if (r is File <int> fol1)
{
wrapper = FileWrapperHelper.Get(fol1, foldersIntWithRights);
}
if (r is File <string> fol2)
{
wrapper = FileWrapperHelper.Get(fol2, foldersStringWithRights);
}
return(wrapper);
}
)
.ToList(),
Folders = folderItems.Entries
.Where(r => r.FileEntryType == FileEntryType.Folder)
.Select(r =>
{
FileEntryWrapper wrapper = null;
if (r is Folder <int> fol1)
{
wrapper = FolderWrapperHelper.Get(fol1, foldersIntWithRights);
}
if (r is Folder <string> fol2)
{
wrapper = FolderWrapperHelper.Get(fol2, foldersStringWithRights);
}
return(wrapper);
}
).ToList(),
PathParts = folderItems.FolderPathParts,
StartIndex = startIndex
};
result.Current = FolderWrapperHelper.Get(folderItems.FolderInfo);
result.Count = result.Files.Count + result.Folders.Count;
result.Total = folderItems.Total;
result.New = folderItems.New;
return(result);
List <Tuple <FileEntry <T1>, bool> > GetFoldersIntWithRights <T1>()
{
var folderDao = DaoFactory.GetFolderDao <T1>();
var folders = folderDao.GetFolders(folderItems.Entries.OfType <FileEntry <T1> >().Select(r => r.FolderID).Distinct().ToList());
return(FileSecurity.CanRead(folders));
}
}
