public async Task DownloadZip(
string fileName,
IEnumerable <FileIdentifier> fileIdentifiers,
HttpResponse response,
Func <FileModel, PathIdentifier> pathGenerator = null,
CancellationToken cancellationToken = default(CancellationToken)
)
{
if (pathGenerator == null)
{
pathGenerator = APIModelExtensions.MetaPathIdentifierRead;
}
response.StatusCode = 200;
response.ContentType = "application/zip";
var contentDisposition = new ContentDispositionHeaderValue("attachment");
contentDisposition.SetHttpFileName(fileName);
response.Headers[HeaderNames.ContentDisposition] = contentDisposition.ToString();
var isEDiscoveryUser = EDiscoveryUtility.IsUserEDiscovery(Connection.UserAccessIdentifiers);
OrganizationModel organization = null;
using (var archive = new ZipArchive(response.Body, ZipArchiveMode.Create))
{
foreach (var fileIdentifier in fileIdentifiers)
{
if (organization == null || organization.Identifier.OrganizationKey != fileIdentifier.OrganizationKey)
{
organization = await Connection.Organization.GetAsync(fileIdentifier as OrganizationIdentifier);
}
var fileModel = await Connection.File.GetAsync(fileIdentifier);
var views = ViewSetService.DetectFileViews(organization, fileModel);
var newFileExtension = null as string;
var contentsFileIdentifier = fileIdentifier;
if (views.Any())
{
var first = views.First();
switch (first.ViewerType)
{
case ManagerFileView.ViewerTypeEnum.Video:
var mediaSet = await viewSetService.LoadSet <MediaSet>(fileIdentifier);
var mp4 = mediaSet.Sources.FirstOrDefault(s => s.Type == "video/mp4");
if (mp4 != null)
{
newFileExtension = "mp4";
contentsFileIdentifier = mp4.FileIdentifier;
}
break;
case ManagerFileView.ViewerTypeEnum.Document:
if (fileModel.Extension == "docx")
{
var documentSet = await viewSetService.LoadSet <DocumentSet>(fileIdentifier);
var pdf = documentSet.FileIdentifier;
if (pdf != null)
{
newFileExtension = "pdf";
contentsFileIdentifier = pdf;
}
}
break;
}
}
var path = pathGenerator(fileModel);
string name = fileModel.Name;
if (newFileExtension != null)
{
name = $"{Path.GetFileNameWithoutExtension(name)}.{newFileExtension}";
}
else
{
newFileExtension = fileModel.Extension;
}
name = MakeFilenameSafe(name);
var filename = path != null
? Path.Combine(path.PathKey, name)
: name;
var entry = archive.CreateEntry(filename);
using (var fileStream = entry.Open())
{
await Connection.File.DownloadAsync(
contentsFileIdentifier,
onStreamAvailable : async(stream, cancel) =>
{
if (isEDiscoveryUser && WatermarkFilter.IsSupportedFileType(newFileExtension))
{
var packageName = fileModel.Read <string>(
MetadataKeyConstants.E_DISCOVERY_SHARE_PACKGAGE);
var watermarkUser = await Connection.User.GetAsync(Connection.UserIdentifier);
// this code is redundant with FileService.ExecuteDownload
await WatermarkFilter.Execute(stream,
fileStream,
newFileExtension,
$"Defense {packageName} {watermarkUser.EmailAddress}"
);
}
else
{
await stream.CopyToAsync(fileStream);
}
},
cancellationToken : cancellationToken
);
}
}
}
}
public async Task <T> LoadSet <T>(FileIdentifier fileIdentifier)
where T : BaseSet
{
var file = await api.File.GetAsync(fileIdentifier);
var fileStatus = await api.File.GetOnlineStatusAsync(fileIdentifier);
var organization = await api.Organization.GetAsync(fileIdentifier as OrganizationIdentifier);
BaseSet set = null;
// this is awful, but no clear security check to perform
bool isPrivileged = !EDiscoveryUtility.IsUserEDiscovery(this.api.UserAccessIdentifiers) &&
!LEOUploadUtility.IsUserLeo(this.api.UserAccessIdentifiers);
if (typeof(T).Equals(typeof(TextSet)))
{
set = TextService.TextSetGet(file, true);
}
if (typeof(T).Equals(typeof(DocumentSet)))
{
set = DocumentSetService.DocumentSetGet(file);
}
if (typeof(T).Equals(typeof(MediaSet)))
{
set = MediaService.MediaSetGet(organization, file, isPrivileged);
}
if (typeof(T).Equals(typeof(TranscriptSet)))
{
var transcriptSet = TranscriptService.TranscriptSetGet(organization, file);
transcriptSet.Segments = await TranscriptService.LoadSegments(api, transcriptSet.Subtitles?.FirstOrDefault()?.FileIdentifier);
set = transcriptSet;
}
if (typeof(T).Equals(typeof(ClipSet)))
{
var clipSet = ClipService.ClipSetGet(organization, file);
set = clipSet;
}
if (typeof(T).Equals(typeof(ImageSet)))
{
set = ImageService.ImageSetGet(file);
}
if (typeof(T).Equals(typeof(UnknownSet)))
{
set = UnknownService.UnknownSetGet(file);
}
if (set.AllowedOperations == null)
{
set.AllowedOperations = new[]
{
AllowedOperation.GetAllowedOperationDownload(fileIdentifier, false)
}
}
;
set.RootFileIdentifier = file.Read(MetadataKeyConstants.CHILDOF, defaultValue: file.Identifier);
if (set.RootFileIdentifier.Equals(fileIdentifier))
{
set.Views = DetectFileViews(organization, file);
}
else
{
set.Views = DetectFileViews(organization, await api.File.GetAsync(set.RootFileIdentifier));
}
// some wierd logic for eDiscovery
// if eDiscovery, then no subtitles
if (set is MediaSet && EDiscoveryUtility.IsUserEDiscovery(api.UserAccessIdentifiers))
{
var media = set as MediaSet;
media.Subtitles = null;
}
if (fileStatus != FileModel.OnlineStatus.Online)
{
set.Views = new ManagerFileView[] { new ManagerFileView {
ViewerType = ManagerFileView.ViewerTypeEnum.Offline,
Identifier = set.RootFileIdentifier
} };
set.AllowedOperations = new AllowedOperation[]
{
AllowedOperation.GetAllowedOperationRequestOnlineFolder(set.RootFileIdentifier)
};
set.RootFileIdentifier = null;
}
return(set as T);
}
public override void BuildDynamicFolders(PathIdentifier identifier, ItemQueryResponse page, FolderModel folder, bool isRestrictedView)
{
if (!page?.PathTree?.Paths?.Any(p => p.Identifier.PathKey == EDiscoveryUtility.E_DISCOVERY_PATH_KEY) ?? false)
{
if (page.PathTree.Paths == null)
{
page.PathTree.Paths = new List <ManagerPathModel>();
}
var managerPathModels = new List <ManagerPathModel>();
// we have to build up the children first.
// First we get all the dated package dynamic paths.
var datedPackagePaths = BuildDatedPackagesDynamicFolder(folder);
var eDiscoveryIdentifier = new PathIdentifier(identifier)
{
PathKey = EDiscoveryUtility.E_DISCOVERY_PATH_KEY
};
// Last the parent / root node of 'eDiscovery'
var eDiscoveryPath = new ManagerPathModel
{
Identifier = eDiscoveryIdentifier,
Icons = new string[] { EDiscoveryUtility.EDISCOVERY_FOLDER_COLOR_STYLE },
Name = EDiscoveryUtility.E_DISCOVERY_PATH_NAME,
FullPath = EDiscoveryUtility.E_DISCOVERY_PATH_KEY,
AllowedOperations = null,
Paths = new List <ManagerPathModel>(),
IsExpanded = datedPackagePaths.Count > 0 || EDiscoveryUtility.GetStagedCount(folder) > 0,
};
if (datedPackagePaths.Any())
{
var allPackagesIdentifier = new PathIdentifier(identifier as FolderIdentifier, EDiscoveryUtility.E_DISCOVERY_ALL_PACKAGE_PATH_KEY);
var packageName = "All";
var processor = new PathProcessor(folder.Identifier);
processor.Read(folder, skipFolderPaths: true, pathReader: f => {
var sharePath = f.MetaEDiscoveryPathIdentifierRead();
if (sharePath != null)
{
return(allPackagesIdentifier.CreateChild(sharePath.PathKey));
}
else
{
return(sharePath);
}
});
datedPackagePaths.Insert(0, new EDiscoveryManagerPathModel()
{
Identifier = allPackagesIdentifier,
Icons = new string[] { EDiscoveryUtility.EDISCOVERY_FOLDER_COLOR_STYLE },
Name = packageName,
FullPath = allPackagesIdentifier.FullName,
Paths = processor[allPackagesIdentifier]?.Paths
});
}
eDiscoveryPath.Paths = eDiscoveryPath.Paths.Concat(datedPackagePaths).ToList();
if (!isRestrictedView)
{
eDiscoveryPath.Paths.Add(GetNotSharedYetPath(folder));
}
page.PathTree.Paths.Add(eDiscoveryPath);
}
}
