public ChunkedUploaderHandlerService(
IOptionsMonitor <ILog> optionsMonitor,
TenantManager tenantManager,
FileUploader fileUploader,
FilesMessageService filesMessageService,
AuthManager authManager,
SecurityContext securityContext,
SetupInfo setupInfo,
EntryManager entryManager,
InstanceCrypto instanceCrypto,
ChunkedUploadSessionHolder chunkedUploadSessionHolder,
ChunkedUploadSessionHelper chunkedUploadSessionHelper)
{
TenantManager = tenantManager;
FileUploader = fileUploader;
FilesMessageService = filesMessageService;
AuthManager = authManager;
SecurityContext = securityContext;
SetupInfo = setupInfo;
EntryManager = entryManager;
InstanceCrypto = instanceCrypto;
ChunkedUploadSessionHolder = chunkedUploadSessionHolder;
ChunkedUploadSessionHelper = chunkedUploadSessionHelper;
Logger = optionsMonitor.CurrentValue;
}
public override void OnProcessRequest(HttpContext context)
{
try
{
var request = new ChunkedRequestHelper(context.Request);
if (!TryAuthorize(request))
{
WriteError(context, "Can't authorize given initiate session request or session with specified upload id already expired");
return;
}
if (CoreContext.TenantManager.GetCurrentTenant().Status != TenantStatus.Active)
{
WriteError(context, "Can't perform upload for deleted or transfering portals");
return;
}
switch (request.Type)
{
case ChunkedRequestType.Abort:
FileUploader.AbortUpload(request.UploadId);
WriteSuccess(context, null);
return;
case ChunkedRequestType.Initiate:
var createdSession = FileUploader.InitiateUpload(request.FolderId, request.FileId, request.FileName, request.FileSize, request.Encrypted);
WriteSuccess(context, ToResponseObject(createdSession, true));
return;
case ChunkedRequestType.Upload:
var resumedSession = FileUploader.UploadChunk(request.UploadId, request.ChunkStream, request.ChunkSize);
if (resumedSession.BytesUploaded == resumedSession.BytesTotal)
{
WriteSuccess(context, ToResponseObject(resumedSession.File), (int)HttpStatusCode.Created);
FilesMessageService.Send(resumedSession.File, context.Request, MessageAction.FileUploaded, resumedSession.File.Title);
}
else
{
WriteSuccess(context, ToResponseObject(resumedSession));
}
return;
default:
WriteError(context, "Unknown request type.");
return;
}
}
catch (FileNotFoundException error)
{
Global.Logger.Error(error);
WriteError(context, FilesCommonResource.ErrorMassage_FileNotFound);
}
catch (Exception error)
{
Global.Logger.Error(error);
WriteError(context, error.Message);
}
}
private void DeleteFiles(List <object> fileIds)
{
if (fileIds.Count == 0)
{
return;
}
foreach (var fileId in fileIds)
{
if (Canceled)
{
return;
}
var file = FileDao.GetFile(fileId);
if (file == null)
{
Error = FilesCommonResource.ErrorMassage_FileNotFound;
}
else if (!ignoreException && EntryManager.FileLockedForMe(file.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (!ignoreException && FileTracker.IsEditing(file.ID))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteEditingFile;
}
else if (!ignoreException && !FilesSecurity.CanDelete(file))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFile;
}
else
{
FileMarker.RemoveMarkAsNewForAll(file);
if (FileDao.UseTrashForRemove(file))
{
FileDao.MoveFile(file.ID, _trashId);
FilesMessageService.Send(file, httpRequestHeaders, MessageAction.FileMovedToTrash, file.Title);
ResultedFile(fileId);
}
else
{
try
{
FileDao.DeleteFile(file.ID);
FileDao.DeleteFolder(file.ID);
}
catch (Exception ex)
{
Error = ex.Message;
Logger.Error(Error, ex);
}
}
ProcessedFile(fileId);
}
ProgressStep();
}
}
public FileConverter(
FileUtility fileUtility,
FilesLinkUtility filesLinkUtility,
IDaoFactory daoFactory,
SetupInfo setupInfo,
PathProvider pathProvider,
FileSecurity fileSecurity,
FileMarker fileMarker,
TenantManager tenantManager,
AuthContext authContext,
EntryManager entryManager,
IOptionsMonitor <ILog> options,
FilesSettingsHelper filesSettingsHelper,
GlobalFolderHelper globalFolderHelper,
FilesMessageService filesMessageService,
FileShareLink fileShareLink,
DocumentServiceHelper documentServiceHelper,
DocumentServiceConnector documentServiceConnector,
IServiceProvider serviceProvider,
IHttpContextAccessor httpContextAccesor)
: this(fileUtility, filesLinkUtility, daoFactory, setupInfo, pathProvider, fileSecurity,
fileMarker, tenantManager, authContext, entryManager, options, filesSettingsHelper,
globalFolderHelper, filesMessageService, fileShareLink, documentServiceHelper, documentServiceConnector,
serviceProvider)
{
HttpContextAccesor = httpContextAccesor;
}
public FileDownloadOperationScope(GlobalStore globalStore, FilesLinkUtility filesLinkUtility, SetupInfo setupInfo, FileConverter fileConverter, FilesMessageService filesMessageService)
{
GlobalStore = globalStore;
FilesLinkUtility = filesLinkUtility;
SetupInfo = setupInfo;
FileConverter = fileConverter;
FilesMessageService = filesMessageService;
}
public void Deconstruct(out FilesMessageService filesMessageService, out FileMarker fileMarker, out FileUtility fileUtility, out Global global, out EntryManager entryManager)
{
filesMessageService = FilesMessageService;
fileMarker = FileMarker;
fileUtility = FileUtility;
global = Global;
entryManager = EntryManager;
}
public FileMoveCopyOperationScope(FilesMessageService filesMessageService, FileMarker fileMarker, FileUtility fileUtility, Global global, EntryManager entryManager)
{
FilesMessageService = filesMessageService;
FileMarker = fileMarker;
FileUtility = fileUtility;
Global = global;
EntryManager = entryManager;
}
private void DeleteFiles(IEnumerable <object> fileIds)
{
foreach (var fileId in fileIds)
{
CancellationToken.ThrowIfCancellationRequested();
var file = FileDao.GetFile(fileId);
string tmpError;
if (file == null)
{
Error = FilesCommonResource.ErrorMassage_FileNotFound;
}
else if (!_ignoreException && WithError(new[] { file }, false, out tmpError))
{
Error = tmpError;
}
else
{
FileMarker.RemoveMarkAsNewForAll(file);
if (!_immediately && FileDao.UseTrashForRemove(file))
{
FileDao.MoveFile(file.ID, _trashId);
FilesMessageService.Send(file, _headers, MessageAction.FileMovedToTrash, file.Title);
if (file.ThumbnailStatus == Thumbnail.Waiting)
{
file.ThumbnailStatus = Thumbnail.NotRequired;
FileDao.SaveThumbnail(file, null);
}
}
else
{
try
{
FileDao.DeleteFile(file.ID);
FilesMessageService.Send(file, _headers, MessageAction.FileDeleted, file.Title);
}
catch (Exception ex)
{
Error = ex.Message;
Logger.Error(Error, ex);
}
LinkDao.DeleteAllLink(file.ID);
}
ProcessedFile(fileId);
}
ProgressStep(fileId: FolderDao.CanCalculateSubitems(fileId) ? null : fileId);
}
}
private void DeleteFiles(List <object> fileIds)
{
foreach (var fileId in fileIds)
{
CancellationToken.ThrowIfCancellationRequested();
var file = FileDao.GetFile(fileId);
if (file == null)
{
Error = FilesCommonResource.ErrorMassage_FileNotFound;
}
else if (!ignoreException && EntryManager.FileLockedForMe(file.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (!ignoreException && FileTracker.IsEditing(file.ID))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteEditingFile;
}
else if (!ignoreException && !FilesSecurity.CanDelete(file))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFile;
}
else
{
FileMarker.RemoveMarkAsNewForAll(file);
if (FileDao.UseTrashForRemove(file))
{
FileDao.MoveFile(file.ID, trashId);
FilesMessageService.Send(file, headers, MessageAction.FileMovedToTrash, file.Title);
}
else
{
try
{
FileDao.DeleteFile(file.ID);
FileDao.DeleteFolder(file.ID);
}
catch (Exception ex)
{
Error = ex.Message;
Logger.Error(Error, ex);
}
}
ProcessedFile(fileId);
}
ProgressStep(fileId: FolderDao.CanCalculateSubitems(fileId) ? null : fileId);
}
}
private T GetFolderId <T>(T folderId, IList <string> relativePath)
{
var folderDao = DaoFactory.GetFolderDao <T>();
var folder = folderDao.GetFolder(folderId);
if (folder == null)
{
throw new DirectoryNotFoundException(FilesCommonResource.ErrorMassage_FolderNotFound);
}
if (!FileSecurity.CanCreate(folder))
{
throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException_Create);
}
if (relativePath != null && relativePath.Any())
{
var subFolderTitle = Global.ReplaceInvalidCharsAndTruncate(relativePath.FirstOrDefault());
if (!string.IsNullOrEmpty(subFolderTitle))
{
folder = folderDao.GetFolder(subFolderTitle, folder.ID);
if (folder == null)
{
var newFolder = ServiceProvider.GetService <Folder <T> >();
newFolder.Title = subFolderTitle;
newFolder.FolderID = folderId;
folderId = folderDao.SaveFolder(newFolder);
folder = folderDao.GetFolder(folderId);
FilesMessageService.Send(folder, MessageAction.FolderCreated, folder.Title);
}
folderId = folder.ID;
relativePath.RemoveAt(0);
folderId = GetFolderId(folderId, relativePath);
}
}
return(folderId);
}
private static string GetFolderId(object folderId, IList <string> relativePath)
{
using (var folderDao = Global.DaoFactory.GetFolderDao())
{
var folder = folderDao.GetFolder(folderId);
if (folder == null)
{
throw new DirectoryNotFoundException(FilesCommonResource.ErrorMassage_FolderNotFound);
}
if (!Global.GetFilesSecurity().CanCreate(folder))
{
throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException_Create);
}
if (relativePath != null && relativePath.Any())
{
var subFolderTitle = Global.ReplaceInvalidCharsAndTruncate(relativePath.FirstOrDefault());
if (!string.IsNullOrEmpty(subFolderTitle))
{
folder = folderDao.GetFolder(subFolderTitle, folder.ID);
if (folder == null)
{
folderId = folderDao.SaveFolder(new Folder {
Title = subFolderTitle, ParentFolderID = folderId
});
folder = folderDao.GetFolder(folderId);
FilesMessageService.Send(folder, HttpContext.Current.Request, MessageAction.FolderCreated, folder.Title);
}
folderId = folder.ID;
relativePath.RemoveAt(0);
folderId = GetFolderId(folderId, relativePath);
}
}
}
return(folderId.ToString());
}
public static string SendDocuSign(object fileId, DocuSignData docuSignData, Dictionary <string, string> requestHeaders)
{
if (docuSignData == null)
{
throw new ArgumentNullException("docuSignData");
}
var token = DocuSignToken.GetToken();
var account = GetDocuSignAccount(token);
var configuration = GetConfiguration(account, token);
File sourceFile;
var document = CreateDocument(fileId, docuSignData.Name, docuSignData.FolderId, out sourceFile);
var url = CreateEnvelope(account.AccountId, document, docuSignData, configuration);
FilesMessageService.Send(sourceFile, requestHeaders, MessageAction.DocumentSendToSign, "DocuSign", sourceFile.Title);
return(url);
}
public FileConverter(
FileUtility fileUtility,
FilesLinkUtility filesLinkUtility,
IDaoFactory daoFactory,
SetupInfo setupInfo,
PathProvider pathProvider,
FileSecurity fileSecurity,
FileMarker fileMarker,
TenantManager tenantManager,
AuthContext authContext,
EntryManager entryManager,
FilesSettingsHelper filesSettingsHelper,
GlobalFolderHelper globalFolderHelper,
FilesMessageService filesMessageService,
FileShareLink fileShareLink,
DocumentServiceHelper documentServiceHelper,
DocumentServiceConnector documentServiceConnector,
FileTrackerHelper fileTracker,
BaseCommonLinkUtility baseCommonLinkUtility,
EntryStatusManager entryStatusManager,
IServiceProvider serviceProvider)
{
FileUtility = fileUtility;
FilesLinkUtility = filesLinkUtility;
DaoFactory = daoFactory;
SetupInfo = setupInfo;
PathProvider = pathProvider;
FileSecurity = fileSecurity;
FileMarker = fileMarker;
TenantManager = tenantManager;
AuthContext = authContext;
EntryManager = entryManager;
FilesSettingsHelper = filesSettingsHelper;
GlobalFolderHelper = globalFolderHelper;
FilesMessageService = filesMessageService;
FileShareLink = fileShareLink;
DocumentServiceHelper = documentServiceHelper;
DocumentServiceConnector = documentServiceConnector;
FileTracker = fileTracker;
BaseCommonLinkUtility = baseCommonLinkUtility;
EntryStatusManager = entryStatusManager;
ServiceProvider = serviceProvider;
}
public FileUploader(
FilesSettingsHelper filesSettingsHelper,
FileUtility fileUtility,
UserManager userManager,
TenantManager tenantManager,
AuthContext authContext,
SetupInfo setupInfo,
TenantExtra tenantExtra,
TenantStatisticsProvider tenantStatisticsProvider,
FileMarker fileMarker,
FileConverter fileConverter,
IDaoFactory daoFactory,
Global global,
FilesLinkUtility filesLinkUtility,
FilesMessageService filesMessageService,
FileSecurity fileSecurity,
EntryManager entryManager,
IServiceProvider serviceProvider,
ChunkedUploadSessionHolder chunkedUploadSessionHolder,
FileTrackerHelper fileTracker)
{
FilesSettingsHelper = filesSettingsHelper;
FileUtility = fileUtility;
UserManager = userManager;
TenantManager = tenantManager;
AuthContext = authContext;
SetupInfo = setupInfo;
TenantExtra = tenantExtra;
TenantStatisticsProvider = tenantStatisticsProvider;
FileMarker = fileMarker;
FileConverter = fileConverter;
DaoFactory = daoFactory;
Global = global;
FilesLinkUtility = filesLinkUtility;
FilesMessageService = filesMessageService;
FileSecurity = fileSecurity;
EntryManager = entryManager;
ServiceProvider = serviceProvider;
ChunkedUploadSessionHolder = chunkedUploadSessionHolder;
FileTracker = fileTracker;
}
public DocumentServiceTrackerHelper(
SecurityContext securityContext,
UserManager userManager,
TenantManager tenantManager,
FilesLinkUtility filesLinkUtility,
EmailValidationKeyProvider emailValidationKeyProvider,
BaseCommonLinkUtility baseCommonLinkUtility,
SocketManager socketManager,
GlobalStore globalStore,
DisplayUserSettingsHelper displayUserSettingsHelper,
IDaoFactory daoFactory,
IOptionsMonitor <ILog> options,
DocumentServiceHelper documentServiceHelper,
EntryManager entryManager,
FileShareLink fileShareLink,
FilesMessageService filesMessageService,
DocumentServiceConnector documentServiceConnector,
NotifyClient notifyClient,
MailMergeTaskRunner mailMergeTaskRunner,
FileTrackerHelper fileTracker)
{
SecurityContext = securityContext;
UserManager = userManager;
TenantManager = tenantManager;
FilesLinkUtility = filesLinkUtility;
EmailValidationKeyProvider = emailValidationKeyProvider;
BaseCommonLinkUtility = baseCommonLinkUtility;
SocketManager = socketManager;
GlobalStore = globalStore;
DisplayUserSettingsHelper = displayUserSettingsHelper;
DaoFactory = daoFactory;
DocumentServiceHelper = documentServiceHelper;
EntryManager = entryManager;
FileShareLink = fileShareLink;
FilesMessageService = filesMessageService;
DocumentServiceConnector = documentServiceConnector;
NotifyClient = notifyClient;
MailMergeTaskRunner = mailMergeTaskRunner;
FileTracker = fileTracker;
Logger = options.CurrentValue;
}
public FileConverter(
FileUtility fileUtility,
FilesLinkUtility filesLinkUtility,
IDaoFactory daoFactory,
SetupInfo setupInfo,
PathProvider pathProvider,
FileSecurity fileSecurity,
FileMarker fileMarker,
TenantManager tenantManager,
AuthContext authContext,
EntryManager entryManager,
IOptionsMonitor <ILog> options,
FilesSettingsHelper filesSettingsHelper,
GlobalFolderHelper globalFolderHelper,
FilesMessageService filesMessageService,
FileShareLink fileShareLink,
DocumentServiceHelper documentServiceHelper,
DocumentServiceConnector documentServiceConnector,
IServiceProvider serviceProvider)
{
FileUtility = fileUtility;
FilesLinkUtility = filesLinkUtility;
DaoFactory = daoFactory;
SetupInfo = setupInfo;
PathProvider = pathProvider;
FileSecurity = fileSecurity;
FileMarker = fileMarker;
TenantManager = tenantManager;
AuthContext = authContext;
EntryManager = entryManager;
FilesSettingsHelper = filesSettingsHelper;
GlobalFolderHelper = globalFolderHelper;
FilesMessageService = filesMessageService;
FileShareLink = fileShareLink;
DocumentServiceHelper = documentServiceHelper;
DocumentServiceConnector = documentServiceConnector;
ServiceProvider = serviceProvider;
Logger = options.CurrentValue;
cache = AscCache.Memory;
}
protected override void Do()
{
var entries = new List <FileEntry>();
if (Folders.Any())
{
entries.AddRange(FolderDao.GetFolders(Folders));
}
if (Files.Any())
{
entries.AddRange(FileDao.GetFiles(Files));
}
entries.ForEach(entry =>
{
CancellationToken.ThrowIfCancellationRequested();
FileMarker.RemoveMarkAsNew(entry, ((IAccount)Thread.CurrentPrincipal.Identity).ID);
if (entry.FileEntryType == FileEntryType.File)
{
ProcessedFile(entry.ID.ToString());
FilesMessageService.Send(entry, headers, MessageAction.FileMarkedAsRead, entry.Title);
}
else
{
ProcessedFolder(entry.ID.ToString());
FilesMessageService.Send(entry, headers, MessageAction.FolderMarkedAsRead, entry.Title);
}
ProgressStep();
});
var newrootfolder = FileMarker
.GetRootFoldersIdMarkedAsNew()
.Select(item => string.Format("new_{{\"key\"? \"{0}\", \"value\"? \"{1}\"}}", item.Key, item.Value));
Status += string.Join(SPLIT_CHAR, newrootfolder.ToArray());
}
private Stream CompressToZip(ItemNameValueCollection entriesPathId)
{
var stream = TempStream.Create();
using (var zip = new ionic::Ionic.Zip.ZipOutputStream(stream, true))
{
zip.CompressionLevel = ionic::Ionic.Zlib.CompressionLevel.Level3;
zip.AlternateEncodingUsage = ionic::Ionic.Zip.ZipOption.AsNecessary;
zip.AlternateEncoding = Encoding.GetEncoding(Thread.CurrentThread.CurrentCulture.TextInfo.OEMCodePage);
foreach (var path in entriesPathId.AllKeys)
{
if (Canceled)
{
zip.Dispose();
stream.Dispose();
return(null);
}
var counter = 0;
foreach (var entryId in entriesPathId[path])
{
var newtitle = path;
File file = null;
var convertToExt = string.Empty;
if (!string.IsNullOrEmpty(entryId))
{
file = FileDao.GetFile(entryId);
if (file.ContentLength > SetupInfo.AvailableFileSize)
{
Error = string.Format(FilesCommonResource.ErrorMassage_FileSizeZip, FileSizeComment.FilesSizeToString(SetupInfo.AvailableFileSize));
continue;
}
if (_files.ContainsKey(file.ID.ToString()))
{
if (_quotaDocsEdition)
{
convertToExt = _files[file.ID.ToString()];
}
if (!string.IsNullOrEmpty(convertToExt))
{
newtitle = FileUtility.ReplaceFileExtension(path, convertToExt);
}
}
}
if (0 < counter)
{
var suffix = " (" + counter + ")";
if (!string.IsNullOrEmpty(entryId))
{
newtitle = 0 < newtitle.IndexOf('.')
? newtitle.Insert(newtitle.LastIndexOf('.'), suffix)
: newtitle + suffix;
}
else
{
break;
}
}
zip.PutNextEntry(newtitle);
if (!string.IsNullOrEmpty(entryId) && file != null)
{
if (file.ConvertedType != null || !string.IsNullOrEmpty(convertToExt))
{
//Take from converter
try
{
using (var readStream = !string.IsNullOrEmpty(convertToExt)
? FileConverter.Exec(file, convertToExt)
: FileConverter.Exec(file))
{
if (readStream != null)
{
readStream.StreamCopyTo(zip);
if (!string.IsNullOrEmpty(convertToExt))
{
FilesMessageService.Send(file, httpRequestHeaders, MessageAction.FileDownloadedAs, file.Title, convertToExt);
}
else
{
FilesMessageService.Send(file, httpRequestHeaders, MessageAction.FileDownloaded, file.Title);
}
}
}
}
catch (Exception ex)
{
Error = ex.Message;
Logger.Error(Error, ex);
}
}
else
{
using (var readStream = FileDao.GetFileStream(file))
{
readStream.StreamCopyTo(zip);
FilesMessageService.Send(file, httpRequestHeaders, MessageAction.FileDownloaded, file.Title);
}
}
}
counter++;
}
ProgressStep();
}
return(stream);
}
}
private static string ProcessSave(string fileId, TrackerData fileData)
{
Guid userId;
var comments = new List <string>();
if (fileData.Status == TrackerStatus.Corrupted)
{
comments.Add(FilesCommonResource.ErrorMassage_SaveCorrupted);
}
if (fileData.Users == null || fileData.Users.Count == 0 || !Guid.TryParse(fileData.Users[0], out userId))
{
userId = FileTracker.GetEditingBy(fileId).FirstOrDefault();
}
try
{
SecurityContext.AuthenticateMe(userId);
}
catch (Exception ex)
{
Global.Logger.Info("DocService save error: anonymous author - " + userId, ex);
if (!userId.Equals(ASC.Core.Configuration.Constants.Guest.ID))
{
comments.Add(FilesCommonResource.ErrorMassage_SaveAnonymous);
}
}
File file = null;
var saved = false;
FileTracker.Remove(fileId);
if (string.IsNullOrEmpty(fileData.Url))
{
try
{
comments.Add(FilesCommonResource.ErrorMassage_SaveUrlLost);
file = EntryManager.CompleteVersionFile(fileId, 0, false, false);
using (var fileDao = Global.DaoFactory.GetFileDao())
{
fileDao.UpdateComment(file.ID, file.Version, string.Join("; ", comments));
}
}
catch (Exception ex)
{
Global.Logger.Error(string.Format("DocService save error. Version update. File id: '{0}'. UserId: {1}. DocKey '{2}'", fileId, userId, fileData.Key), ex);
}
}
else
{
try
{
file = EntryManager.SaveEditing(fileId, null, DocumentServiceConnector.ReplaceDocumentAdress(fileData.Url), null, string.Empty, string.Join("; ", comments), false);
saved = fileData.Status == TrackerStatus.MustSave;
}
catch (Exception ex)
{
Global.Logger.Error(string.Format("DocService save error. File id: '{0}'. UserId: {1}. DocKey '{2}'. DownloadUri: {3}", fileId, userId, fileData.Key, fileData.Url), ex);
StoringFileAfterError(fileId, userId.ToString(), DocumentServiceConnector.ReplaceDocumentAdress(fileData.Url));
}
}
if (file != null)
{
var user = CoreContext.UserManager.GetUsers(userId);
if (user != null)
{
FilesMessageService.Send(file, MessageInitiator.DocsService, MessageAction.UserFileUpdated, user.DisplayUserName(false), file.Title);
}
SaveHistory(file, (fileData.History ?? "").ToString(), DocumentServiceConnector.ReplaceDocumentAdress(fileData.ChangesUrl));
}
Global.SocketManager.FilesChangeEditors(fileId, true);
return(saved
? "0" //error:0 - saved
: "1"); //error:1 - some error
}
private static TrackResponse ProcessSave(string fileId, TrackerData fileData)
{
Guid userId;
var comments = new List <string>();
if (fileData.Status == TrackerStatus.Corrupted ||
fileData.Status == TrackerStatus.CorruptedForceSave)
{
comments.Add(FilesCommonResource.ErrorMassage_SaveCorrupted);
}
var forcesave = fileData.Status == TrackerStatus.ForceSave || fileData.Status == TrackerStatus.CorruptedForceSave;
if (fileData.Users == null || fileData.Users.Count == 0 || !Guid.TryParse(fileData.Users[0], out userId))
{
userId = FileTracker.GetEditingBy(fileId).FirstOrDefault();
}
var app = ThirdPartySelector.GetAppByFileId(fileId);
if (app == null)
{
File fileStable;
using (var fileDao = Global.DaoFactory.GetFileDao())
{
fileStable = fileDao.GetFileStable(fileId);
}
var docKey = DocumentServiceHelper.GetDocKey(fileStable);
if (!fileData.Key.Equals(docKey))
{
Global.Logger.ErrorFormat("DocService saving file {0} ({1}) with key {2}", fileId, docKey, fileData.Key);
StoringFileAfterError(fileId, userId.ToString(), DocumentServiceConnector.ReplaceDocumentAdress(fileData.Url));
return(new TrackResponse {
Message = "Expected key " + docKey
});
}
}
UserInfo user = null;
try
{
SecurityContext.AuthenticateMe(userId);
user = CoreContext.UserManager.GetUsers(userId);
var culture = string.IsNullOrEmpty(user.CultureName) ? CoreContext.TenantManager.GetCurrentTenant().GetCulture() : CultureInfo.GetCultureInfo(user.CultureName);
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
}
catch (Exception ex)
{
Global.Logger.Info("DocService save error: anonymous author - " + userId, ex);
if (!userId.Equals(ASC.Core.Configuration.Constants.Guest.ID))
{
comments.Add(FilesCommonResource.ErrorMassage_SaveAnonymous);
}
}
File file = null;
var saveMessage = "Not saved";
if (string.IsNullOrEmpty(fileData.Url))
{
try
{
comments.Add(FilesCommonResource.ErrorMassage_SaveUrlLost);
file = EntryManager.CompleteVersionFile(fileId, 0, false, false);
using (var fileDao = Global.DaoFactory.GetFileDao())
{
fileDao.UpdateComment(file.ID, file.Version, string.Join("; ", comments));
}
file = null;
Global.Logger.ErrorFormat("DocService save error. Empty url. File id: '{0}'. UserId: {1}. DocKey '{2}'", fileId, userId, fileData.Key);
}
catch (Exception ex)
{
Global.Logger.Error(string.Format("DocService save error. Version update. File id: '{0}'. UserId: {1}. DocKey '{2}'", fileId, userId, fileData.Key), ex);
}
}
else
{
if (fileData.Encrypted)
{
comments.Add(FilesCommonResource.CommentEditEncrypt);
}
var forcesaveType = ForcesaveType.None;
if (forcesave)
{
switch (fileData.ForceSaveType)
{
case TrackerData.ForceSaveInitiator.Command:
forcesaveType = ForcesaveType.Command;
break;
case TrackerData.ForceSaveInitiator.Timer:
forcesaveType = ForcesaveType.Timer;
break;
case TrackerData.ForceSaveInitiator.User:
forcesaveType = ForcesaveType.User;
break;
}
comments.Add(fileData.ForceSaveType == TrackerData.ForceSaveInitiator.User
? FilesCommonResource.CommentForcesave
: FilesCommonResource.CommentAutosave);
}
try
{
file = EntryManager.SaveEditing(fileId, null, DocumentServiceConnector.ReplaceDocumentAdress(fileData.Url), null, string.Empty, string.Join("; ", comments), false, fileData.Encrypted, forcesaveType);
saveMessage = fileData.Status == TrackerStatus.MustSave || fileData.Status == TrackerStatus.ForceSave ? null : "Status " + fileData.Status;
}
catch (Exception ex)
{
Global.Logger.Error(string.Format("DocService save error. File id: '{0}'. UserId: {1}. DocKey '{2}'. DownloadUri: {3}", fileId, userId, fileData.Key, fileData.Url), ex);
saveMessage = ex.Message;
StoringFileAfterError(fileId, userId.ToString(), DocumentServiceConnector.ReplaceDocumentAdress(fileData.Url));
}
}
if (!forcesave)
{
FileTracker.Remove(fileId);
}
if (file != null)
{
if (user != null)
{
FilesMessageService.Send(file, MessageInitiator.DocsService, MessageAction.UserFileUpdated, user.DisplayUserName(false), file.Title);
}
if (!forcesave)
{
SaveHistory(file, (fileData.History ?? "").ToString(), DocumentServiceConnector.ReplaceDocumentAdress(fileData.ChangesUrl));
}
}
Global.SocketManager.FilesChangeEditors(fileId, !forcesave);
var result = new TrackResponse {
Message = saveMessage
};
if (string.IsNullOrEmpty(saveMessage) && file != null && file.Encrypted)
{
result.Addresses = EncryptionAddress.GetAddresses(file.ID.ToString()).ToArray();
}
return(result);
}
private static void DownloadFile(HttpContext context)
{
var flushed = false;
try
{
var id = context.Request[FilesLinkUtility.FileId];
var doc = context.Request[FilesLinkUtility.DocShareKey] ?? "";
using (var fileDao = Global.DaoFactory.GetFileDao())
{
File file;
var readLink = FileShareLink.Check(doc, true, fileDao, out file);
if (!readLink && file == null)
{
fileDao.InvalidateCache(id);
int version;
file = int.TryParse(context.Request[FilesLinkUtility.Version], out version) && version > 0
? fileDao.GetFile(id, version)
: fileDao.GetFile(id);
}
if (file == null)
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
if (!readLink && !Global.GetFilesSecurity().CanRead(file))
{
context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
return;
}
if (!string.IsNullOrEmpty(file.Error))
{
throw new Exception(file.Error);
}
if (!fileDao.IsExistOnStorage(file))
{
Global.Logger.ErrorFormat("Download file error. File is not exist on storage. File id: {0}.", file.ID);
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
FileMarker.RemoveMarkAsNew(file);
context.Response.Clear();
context.Response.ClearHeaders();
context.Response.Charset = "utf-8";
var title = file.Title.Replace(',', '_');
var ext = FileUtility.GetFileExtension(file.Title);
var outType = context.Request[FilesLinkUtility.OutType];
if (!string.IsNullOrEmpty(outType))
{
outType = outType.Trim();
if (FileUtility.ExtsConvertible[ext].Contains(outType))
{
ext = outType;
title = FileUtility.ReplaceFileExtension(title, ext);
}
}
context.Response.AddHeader("Content-Disposition", ContentDispositionUtil.GetHeaderValue(title));
context.Response.ContentType = MimeMapping.GetMimeMapping(title);
//// Download file via nginx
//if (CoreContext.Configuration.Standalone &&
// WorkContext.IsMono &&
// Global.GetStore() is DiscDataStore &&
// !file.ProviderEntry &&
// !FileConverter.EnableConvert(file, ext)
// )
//{
// var diskDataStore = (DiscDataStore)Global.GetStore();
// var pathToFile = diskDataStore.GetPhysicalPath(String.Empty, FileDao.GetUniqFilePath(file));
// context.Response.Headers.Add("X-Accel-Redirect", "/filesData" + pathToFile);
// FilesMessageService.Send(file, context.Request, MessageAction.FileDownloaded, file.Title);
// return;
//}
if (string.Equals(context.Request.Headers["If-None-Match"], GetEtag(file)))
{
//Its cached. Reply 304
context.Response.StatusCode = (int)HttpStatusCode.NotModified;
context.Response.Cache.SetETag(GetEtag(file));
}
else
{
context.Response.CacheControl = "public";
context.Response.Cache.SetETag(GetEtag(file));
context.Response.Cache.SetCacheability(HttpCacheability.Public);
Stream fileStream = null;
try
{
if (file.ContentLength <= SetupInfo.AvailableFileSize)
{
if (!FileConverter.EnableConvert(file, ext))
{
if (!readLink && fileDao.IsSupportedPreSignedUri(file))
{
context.Response.Redirect(fileDao.GetPreSignedUri(file, TimeSpan.FromHours(1)).ToString(), true);
return;
}
fileStream = fileDao.GetFileStream(file);
context.Response.AddHeader("Content-Length", file.ContentLength.ToString(CultureInfo.InvariantCulture));
}
else
{
fileStream = FileConverter.Exec(file, ext);
context.Response.AddHeader("Content-Length", fileStream.Length.ToString(CultureInfo.InvariantCulture));
}
fileStream.StreamCopyTo(context.Response.OutputStream);
if (!context.Response.IsClientConnected)
{
Global.Logger.Warn(String.Format("Download file error {0} {1} Connection is lost. Too long to buffer the file", file.Title, file.ID));
}
FilesMessageService.Send(file, context.Request, MessageAction.FileDownloaded, file.Title);
context.Response.Flush();
flushed = true;
}
else
{
context.Response.Buffer = false;
context.Response.ContentType = "application/octet-stream";
long offset = 0;
if (context.Request.Headers["Range"] != null)
{
context.Response.StatusCode = 206;
var range = context.Request.Headers["Range"].Split(new[] { '=', '-' });
offset = Convert.ToInt64(range[1]);
}
if (offset > 0)
{
Global.Logger.Info("Starting file download offset is " + offset);
}
context.Response.AddHeader("Connection", "Keep-Alive");
context.Response.AddHeader("Accept-Ranges", "bytes");
if (offset > 0)
{
context.Response.AddHeader("Content-Range", String.Format(" bytes {0}-{1}/{2}", offset, file.ContentLength - 1, file.ContentLength));
}
var dataToRead = file.ContentLength;
const int bufferSize = 8 * 1024; // 8KB
var buffer = new Byte[bufferSize];
if (!FileConverter.EnableConvert(file, ext))
{
if (!readLink && fileDao.IsSupportedPreSignedUri(file))
{
context.Response.Redirect(fileDao.GetPreSignedUri(file, TimeSpan.FromHours(1)).ToString(), true);
return;
}
fileStream = fileDao.GetFileStream(file, offset);
context.Response.AddHeader("Content-Length", (file.ContentLength - offset).ToString(CultureInfo.InvariantCulture));
}
else
{
fileStream = FileConverter.Exec(file, ext);
if (offset > 0)
{
var startBytes = offset;
while (startBytes > 0)
{
long readCount;
if (bufferSize >= startBytes)
{
readCount = startBytes;
}
else
{
readCount = bufferSize;
}
var length = fileStream.Read(buffer, 0, (int)readCount);
startBytes -= length;
}
}
}
while (dataToRead > 0)
{
int length;
try
{
length = fileStream.Read(buffer, 0, bufferSize);
}
catch (HttpException exception)
{
Global.Logger.Error(
String.Format("Read from stream is error. Download file {0} {1}. Maybe Connection is lost.?? Error is {2} ",
file.Title,
file.ID,
exception
));
throw;
}
if (context.Response.IsClientConnected)
{
context.Response.OutputStream.Write(buffer, 0, length);
context.Response.Flush();
flushed = true;
dataToRead = dataToRead - length;
}
else
{
dataToRead = -1;
Global.Logger.Warn(String.Format("IsClientConnected is false. Why? Download file {0} {1} Connection is lost. ", file.Title, file.ID));
}
}
}
}
catch (ThreadAbortException)
{
}
catch (HttpException e)
{
throw new HttpException((int)HttpStatusCode.BadRequest, e.Message);
}
finally
{
if (fileStream != null)
{
fileStream.Close();
fileStream.Dispose();
}
}
try
{
context.Response.End();
flushed = true;
}
catch (HttpException)
{
}
}
}
}
catch (ThreadAbortException)
{
}
catch (Exception ex)
{
// Get stack trace for the exception with source file information
var st = new StackTrace(ex, true);
// Get the top stack frame
var frame = st.GetFrame(0);
// Get the line number from the stack frame
var line = frame.GetFileLineNumber();
Global.Logger.ErrorFormat("Url: {0} {1} IsClientConnected:{2}, line number:{3} frame:{4}", context.Request.Url, ex, context.Response.IsClientConnected, line, frame);
if (!flushed && context.Response.IsClientConnected)
{
context.Response.StatusCode = 400;
context.Response.Write(HttpUtility.HtmlEncode(ex.Message));
}
}
}
private void PageLoad()
{
var editPossible = !RequestEmbedded;
var isExtenral = false;
File file;
var fileUri = string.Empty;
try
{
if (string.IsNullOrEmpty(RequestFileUrl))
{
var app = ThirdPartySelector.GetAppByFileId(RequestFileId);
if (app == null)
{
file = DocumentServiceHelper.GetParams(RequestFileId, RequestVersion, RequestShareLinkKey, editPossible, !RequestView, true, out _configuration);
if (_valideShareLink)
{
_configuration.Document.SharedLinkKey += RequestShareLinkKey;
_configuration.Document.Info.Favorite = null;
if (CoreContext.Configuration.Personal && !SecurityContext.IsAuthenticated)
{
var user = CoreContext.UserManager.GetUsers(file.CreateBy);
var culture = CultureInfo.GetCultureInfo(user.CultureName);
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
}
}
}
else
{
isExtenral = true;
bool editable;
_thirdPartyApp = true;
file = app.GetFile(RequestFileId, out editable);
file = DocumentServiceHelper.GetParams(file, true, editPossible ? FileShare.ReadWrite : FileShare.Read, false, editable, editable, editable, true, out _configuration);
_configuration.Document.Url = app.GetFileStreamUrl(file);
_configuration.EditorConfig.Customization.GobackUrl = string.Empty;
_configuration.Document.Info.Favorite = null;
}
}
else
{
isExtenral = true;
fileUri = RequestFileUrl;
var fileTitle = Request[FilesLinkUtility.FileTitle];
if (string.IsNullOrEmpty(fileTitle))
{
fileTitle = Path.GetFileName(HttpUtility.UrlDecode(fileUri)) ?? "";
}
file = new File
{
ID = RequestFileUrl,
Title = Global.ReplaceInvalidCharsAndTruncate(fileTitle)
};
file = DocumentServiceHelper.GetParams(file, true, FileShare.Read, false, false, false, false, false, out _configuration);
_configuration.Document.Permissions.Edit = editPossible && !CoreContext.Configuration.Standalone;
_configuration.Document.Permissions.Rename = false;
_configuration.Document.Permissions.Review = false;
_configuration.Document.Permissions.FillForms = false;
_configuration.Document.Permissions.ChangeHistory = false;
_configuration.Document.Permissions.ModifyFilter = false;
_editByUrl = true;
_configuration.Document.Url = fileUri;
_configuration.Document.Info.Favorite = null;
}
ErrorMessage = _configuration.ErrorMessage;
}
catch (Exception ex)
{
Global.Logger.Warn("DocEditor", ex);
ErrorMessage = ex.Message;
return;
}
var userAgent = Request.UserAgent.ToString().ToLower();
HttpCookie deeplinkCookie = Request.Cookies.Get("deeplink");
var deepLink = ConfigurationManagerExtension.AppSettings["deeplink.documents.url"];
if (!_valideShareLink &&
deepLink != null && MobileDetector.IsMobile &&
((!userAgent.Contains("version/") && userAgent.Contains("android")) || !userAgent.Contains("android")) && //check webkit
((Request[DeepLinking.WithoutDeeplinkRedirect] == null && deeplinkCookie == null) ||
Request[DeepLinking.WithoutDeeplinkRedirect] == null && deeplinkCookie != null && deeplinkCookie.Value == "app"))
{
var currentUser = CoreContext.UserManager.GetUsers(SecurityContext.CurrentAccount.ID);
DeepLinkData deepLinkData = new DeepLinkData
{
Email = currentUser.Email,
Portal = CoreContext.TenantManager.GetCurrentTenant().TenantDomain,
File = new DeepLinkDataFile
{
Id = file.ID.ToString(),
Title = file.Title,
Extension = file.ConvertedExtension
},
Folder = new DeepLinkDataFolder
{
Id = file.FolderID.ToString(),
ParentId = file.RootFolderId.ToString(),
RootFolderType = (int)file.RootFolderType
},
OriginalUrl = Request.GetUrlRewriter().ToString()
};
var jsonDeeplinkData = JsonConvert.SerializeObject(deepLinkData);
string base64DeeplinkData = Convert.ToBase64String(Encoding.UTF8.GetBytes(jsonDeeplinkData));
Response.Redirect("~/DeepLink.aspx?data=" + HttpUtility.UrlEncode(base64DeeplinkData));
}
if (_configuration.EditorConfig.ModeWrite && FileConverter.MustConvert(file))
{
try
{
file = FileConverter.ExecSync(file, RequestShareLinkKey);
}
catch (Exception ex)
{
_configuration = null;
Global.Logger.Error("DocEditor", ex);
ErrorMessage = ex.Message;
return;
}
var comment = "#message/" + HttpUtility.UrlEncode(string.Format(FilesCommonResource.ConvertForEdit, file.Title));
Response.Redirect(FilesLinkUtility.GetFileWebEditorUrl(file.ID) + comment);
return;
}
var fileSecurity = Global.GetFilesSecurity();
if (_configuration.EditorConfig.ModeWrite &&
FileUtility.CanWebRestrictedEditing(file.Title) &&
fileSecurity.CanFillForms(file) &&
!fileSecurity.CanEdit(file))
{
if (!file.IsFillFormDraft)
{
FileMarker.RemoveMarkAsNew(file);
Folder folderIfNew;
try
{
file = EntryManager.GetFillFormDraft(file, out folderIfNew);
}
catch (Exception ex)
{
_configuration = null;
Global.Logger.Error("DocEditor", ex);
ErrorMessage = ex.Message;
return;
}
var comment = folderIfNew == null
? string.Empty
: "#message/" + HttpUtility.UrlEncode(string.Format(FilesCommonResource.MessageFillFormDraftCreated, folderIfNew.Title));
Response.Redirect(FilesLinkUtility.GetFileWebEditorUrl(file.ID) + comment);
return;
}
else if (!EntryManager.CheckFillFormDraft(file))
{
var comment = "#message/" + HttpUtility.UrlEncode(FilesCommonResource.MessageFillFormDraftDiscard);
Response.Redirect(FilesLinkUtility.GetFileWebEditorUrl(file.ID) + comment);
return;
}
}
Title = file.Title + GetPageTitlePostfix();
if (_configuration.EditorConfig.Customization.Goback == null || string.IsNullOrEmpty(_configuration.EditorConfig.Customization.Goback.Url))
{
_configuration.EditorConfig.Customization.GobackUrl = Request[FilesLinkUtility.FolderUrl] ?? "";
}
_configuration.EditorConfig.Customization.IsRetina = TenantLogoManager.IsRetina(Request);
if (RequestEmbedded)
{
_configuration.Type = Services.DocumentService.Configuration.EditorType.Embedded;
_configuration.EditorConfig.Embedded.ShareLinkParam = string.IsNullOrEmpty(RequestShareLinkKey) ? string.Empty : "&" + FilesLinkUtility.DocShareKey + "=" + RequestShareLinkKey;
}
else
{
_configuration.Type = IsMobile ? Services.DocumentService.Configuration.EditorType.Mobile : Services.DocumentService.Configuration.EditorType.Desktop;
if (FileSharing.CanSetAccess(file) &&
!(file.Encrypted &&
(!Request.DesktopApp() ||
CoreContext.Configuration.Personal)))
{
_configuration.EditorConfig.SharingSettingsUrl = CommonLinkUtility.GetFullAbsolutePath(
Share.Location
+ "?" + FilesLinkUtility.FileId + "=" + HttpUtility.UrlEncode(file.ID.ToString())
+ (Request.DesktopApp() ? "&desktop=true" : string.Empty));
}
if (file.RootFolderType == FolderType.Privacy)
{
if (!PrivacyRoomSettings.Enabled)
{
_configuration = null;
ErrorMessage = FilesCommonResource.ErrorMassage_FileNotFound;
return;
}
else
{
if (Request.DesktopApp())
{
var keyPair = EncryptionKeyPair.GetKeyPair();
if (keyPair != null)
{
_configuration.EditorConfig.EncryptionKeys = new Services.DocumentService.Configuration.EditorConfiguration.EncryptionKeysConfig
{
PrivateKeyEnc = keyPair.PrivateKeyEnc,
PublicKey = keyPair.PublicKey,
};
}
}
}
}
}
if (!isExtenral)
{
_docKeyForTrack = DocumentServiceHelper.GetDocKey(file.ID, -1, DateTime.MinValue);
FileMarker.RemoveMarkAsNew(file);
if (!file.Encrypted && !file.ProviderEntry)
{
EntryManager.MarkAsRecent(file);
}
if (RequestView)
{
FilesMessageService.Send(file, MessageInitiator.DocsService, MessageAction.FileReaded, file.Title);
}
else
{
FilesMessageService.Send(file, MessageInitiator.DocsService, MessageAction.FileOpenedForChange, file.Title);
}
}
if (SecurityContext.IsAuthenticated)
{
var saveAsUrl = SaveAs.GetUrl;
using (var folderDao = Global.DaoFactory.GetFolderDao())
{
var folder = folderDao.GetFolder(file.FolderID);
if (folder != null && Global.GetFilesSecurity().CanCreate(folder))
{
saveAsUrl = SaveAs.GetUrlToFolder(file.FolderID);
}
}
_configuration.EditorConfig.SaveAsUrl = CommonLinkUtility.GetFullAbsolutePath(saveAsUrl);
}
if (_configuration.EditorConfig.ModeWrite)
{
_tabId = FileTracker.Add(file.ID);
Global.SocketManager.FilesChangeEditors(file.ID);
if (SecurityContext.IsAuthenticated)
{
_configuration.EditorConfig.FileChoiceUrl = CommonLinkUtility.GetFullAbsolutePath(FileChoice.GetUrlForEditor);
}
}
else
{
_linkToEdit = _editByUrl
? CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.GetFileWebEditorExternalUrl(fileUri, file.Title))
: CommonLinkUtility.GetFullAbsolutePath(FilesLinkUtility.GetFileWebEditorUrl(file.ID));
if (Request.DesktopApp())
{
_linkToEdit += "&desktop=true";
}
if (FileConverter.MustConvert(_configuration.Document.Info.File))
{
_editByUrl = true;
}
}
var actionAnchor = Request[FilesLinkUtility.Anchor];
if (!string.IsNullOrEmpty(actionAnchor))
{
_configuration.EditorConfig.ActionLinkString = actionAnchor;
}
}
private void MoveOrCopyFiles(ICollection fileIds, Folder toFolder, bool copy)
{
if (fileIds.Count == 0)
{
return;
}
var toFolderId = toFolder.ID;
foreach (var fileId in fileIds)
{
CancellationToken.ThrowIfCancellationRequested();
var file = FileDao.GetFile(fileId);
if (file == null)
{
Error = FilesCommonResource.ErrorMassage_FileNotFound;
}
else if (!FilesSecurity.CanRead(file))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_ReadFile;
}
else if (Global.EnableUploadFilter &&
!FileUtility.ExtsUploadable.Contains(FileUtility.GetFileExtension(file.Title)))
{
Error = FilesCommonResource.ErrorMassage_NotSupportedFormat;
}
else if (file.ContentLength > SetupInfo.AvailableFileSize &&
file.ProviderId != toFolder.ProviderId)
{
Error = string.Format(copy ? FilesCommonResource.ErrorMassage_FileSizeCopy : FilesCommonResource.ErrorMassage_FileSizeMove,
FileSizeComment.FilesSizeToString(SetupInfo.AvailableFileSize));
}
else
{
var parentFolder = FolderDao.GetFolder(file.FolderID);
try
{
var conflict = resolveType == FileConflictResolveType.Duplicate
? null
: FileDao.GetFile(toFolderId, file.Title);
if (conflict != null && !FilesSecurity.CanEdit(conflict))
{
Error = FilesCommonResource.ErrorMassage_SecurityException;
}
else if (conflict != null && EntryManager.FileLockedForMe(conflict.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (conflict == null)
{
if (copy)
{
File newFile = null;
try
{
newFile = FileDao.CopyFile(file.ID, toFolderId); //Stream copy will occur inside dao
FilesMessageService.Send(file, toFolder, headers, MessageAction.FileCopied, file.Title, parentFolder.Title, toFolder.Title);
if (Equals(newFile.FolderID.ToString(), this.toFolderId))
{
needToMark.Add(newFile);
}
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", newFile.ID, SPLIT_CHAR);
}
}
catch
{
if (newFile != null)
{
FileDao.DeleteFile(newFile.ID);
}
throw;
}
}
else
{
if (EntryManager.FileLockedForMe(file.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (FileTracker.IsEditing(file.ID))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_UpdateEditingFile;
}
else if (FilesSecurity.CanDelete(file))
{
FileMarker.RemoveMarkAsNewForAll(file);
var newFileId = FileDao.MoveFile(file.ID, toFolderId);
FilesMessageService.Send(file, toFolder, headers, MessageAction.FileMoved, file.Title, parentFolder.Title, toFolder.Title);
if (Equals(toFolderId.ToString(), this.toFolderId))
{
needToMark.Add(FileDao.GetFile(newFileId));
}
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", newFileId, SPLIT_CHAR);
}
}
else
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFile;
}
}
}
else
{
if (resolveType == FileConflictResolveType.Overwrite)
{
if (EntryManager.FileLockedForMe(conflict.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (FileTracker.IsEditing(conflict.ID))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_UpdateEditingFile;
}
else
{
var newFile = conflict;
newFile.Version++;
newFile.ContentLength = conflict.ContentLength;
using (var stream = FileDao.GetFileStream(file))
{
newFile = FileDao.SaveFile(newFile, stream);
}
needToMark.Add(newFile);
if (copy)
{
FilesMessageService.Send(file, toFolder, headers, MessageAction.FileCopiedWithOverwriting, file.Title, parentFolder.Title, toFolder.Title);
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", newFile.ID, SPLIT_CHAR);
}
}
else
{
if (Equals(file.FolderID.ToString(), toFolderId.ToString()))
{
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", newFile.ID, SPLIT_CHAR);
}
}
else
{
if (EntryManager.FileLockedForMe(file.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (FileTracker.IsEditing(file.ID))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_UpdateEditingFile;
}
else if (FilesSecurity.CanDelete(file))
{
FileDao.DeleteFile(file.ID);
FileDao.DeleteFolder(file.ID);
FilesMessageService.Send(file, toFolder, headers, MessageAction.FileMovedWithOverwriting, file.Title, parentFolder.Title, toFolder.Title);
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", newFile.ID, SPLIT_CHAR);
}
}
else
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFile;
}
}
}
}
}
else if (resolveType == FileConflictResolveType.Skip)
{
//nothing
}
}
}
catch (Exception ex)
{
Error = ex.Message;
Logger.Error(Error, ex);
}
}
ProgressStep(fileId: FolderDao.CanCalculateSubitems(fileId) ? null : fileId);
}
}
private void MoveOrCopyFolders(ICollection folderIds, Folder toFolder, bool copy)
{
if (folderIds.Count == 0)
{
return;
}
var toFolderId = toFolder.ID;
var isToFolder = Equals(toFolderId.ToString(), this.toFolderId);
foreach (var folderId in folderIds)
{
CancellationToken.ThrowIfCancellationRequested();
var folder = FolderDao.GetFolder(folderId);
if (folder == null)
{
Error = FilesCommonResource.ErrorMassage_FolderNotFound;
}
else if (!FilesSecurity.CanRead(folder))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_ReadFolder;
}
else if (!Equals((folder.ParentFolderID ?? string.Empty).ToString(), toFolderId.ToString()) || resolveType == FileConflictResolveType.Duplicate)
{
try
{
//if destination folder contains folder with same name then merge folders
var conflictFolder = FolderDao.GetFolder(folder.Title, toFolderId);
if (copy || conflictFolder != null)
{
Folder newFolder;
if (conflictFolder != null)
{
newFolder = conflictFolder;
if (isToFolder)
{
needToMark.Add(conflictFolder);
}
}
else
{
newFolder = FolderDao.CopyFolder(folder.ID, toFolderId);
FilesMessageService.Send(folder, toFolder, headers, MessageAction.FolderCopied, folder.Title, toFolder.Title);
if (isToFolder)
{
needToMark.Add(newFolder);
}
if (ProcessedFolder(folderId))
{
Status += string.Format("folder_{0}{1}", newFolder.ID, SPLIT_CHAR);
}
}
if (FolderDao.UseRecursiveOperation(folder.ID, toFolderId))
{
MoveOrCopyFiles(FileDao.GetFiles(folder.ID), newFolder, copy);
MoveOrCopyFolders(FolderDao.GetFolders(folder.ID).Select(f => f.ID).ToList(), newFolder, copy);
if (!copy)
{
if (FolderDao.IsEmpty(folder.ID) && FilesSecurity.CanDelete(folder))
{
FolderDao.DeleteFolder(folder.ID);
if (ProcessedFolder(folderId))
{
Status += string.Format("folder_{0}{1}", newFolder.ID, SPLIT_CHAR);
}
}
}
}
else
{
if (conflictFolder != null)
{
object newFolderId;
if (copy)
{
newFolder = FolderDao.CopyFolder(folder.ID, toFolderId);
newFolderId = newFolder.ID;
FilesMessageService.Send(folder, toFolder, headers, MessageAction.FolderCopiedWithOverwriting, folder.Title, toFolder.Title);
if (isToFolder)
{
needToMark.Add(newFolder);
}
}
else
{
newFolderId = FolderDao.MoveFolder(folder.ID, toFolderId);
FilesMessageService.Send(folder, toFolder, headers, MessageAction.FolderMovedWithOverwriting, folder.Title, toFolder.Title);
if (isToFolder)
{
needToMark.Add(FolderDao.GetFolder(newFolderId));
}
}
if (ProcessedFolder(folderId))
{
Status += string.Format("folder_{0}{1}", newFolderId, SPLIT_CHAR);
}
}
}
}
else
{
if (FilesSecurity.CanDelete(folder))
{
FileMarker.RemoveMarkAsNewForAll(folder);
var newFolderId = FolderDao.MoveFolder(folder.ID, toFolderId);
FilesMessageService.Send(folder, toFolder, headers, MessageAction.FolderMoved, folder.Title, toFolder.Title);
if (isToFolder)
{
needToMark.Add(FolderDao.GetFolder(newFolderId));
}
if (ProcessedFolder(folderId))
{
Status += string.Format("folder_{0}{1}", newFolderId, SPLIT_CHAR);
}
}
else
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFolder;
}
}
}
catch (Exception ex)
{
Error = ex.Message;
Logger.Error(Error, ex);
}
}
ProgressStep(FolderDao.CanCalculateSubitems(folderId) ? null : folderId);
}
}
public async Task Invoke <T>(HttpContext context)
{
try
{
if (context.Request.Method == "OPTIONS")
{
context.Response.StatusCode = 200;
return;
}
var request = new ChunkedRequestHelper <T>(context.Request);
if (!TryAuthorize(request))
{
await WriteError(context, "Can't authorize given initiate session request or session with specified upload id already expired");
return;
}
if (TenantManager.GetCurrentTenant().Status != TenantStatus.Active)
{
await WriteError(context, "Can't perform upload for deleted or transfering portals");
return;
}
switch (request.Type(InstanceCrypto))
{
case ChunkedRequestType.Abort:
FileUploader.AbortUpload <T>(request.UploadId);
await WriteSuccess(context, null);
return;
case ChunkedRequestType.Initiate:
var createdSession = FileUploader.InitiateUpload(request.FolderId, request.FileId, request.FileName, request.FileSize, request.Encrypted);
await WriteSuccess(context, ChunkedUploadSessionHelper.ToResponseObject(createdSession, true));
return;
case ChunkedRequestType.Upload:
var resumedSession = FileUploader.UploadChunk <T>(request.UploadId, request.ChunkStream, request.ChunkSize);
if (resumedSession.BytesUploaded == resumedSession.BytesTotal)
{
await WriteSuccess(context, ToResponseObject(resumedSession.File), (int)HttpStatusCode.Created);
FilesMessageService.Send(resumedSession.File, MessageAction.FileUploaded, resumedSession.File.Title);
}
else
{
await WriteSuccess(context, ChunkedUploadSessionHelper.ToResponseObject(resumedSession));
}
return;
default:
await WriteError(context, "Unknown request type.");
return;
}
}
catch (FileNotFoundException error)
{
Logger.Error(error);
await WriteError(context, FilesCommonResource.ErrorMassage_FileNotFound);
}
catch (Exception error)
{
Logger.Error(error);
await WriteError(context, error.Message);
}
}
private void DeleteFolders(List <object> folderIds)
{
foreach (var folderId in folderIds)
{
CancellationToken.ThrowIfCancellationRequested();
var folder = FolderDao.GetFolder(folderId);
if (folder == null)
{
Error = FilesCommonResource.ErrorMassage_FolderNotFound;
}
else if (!ignoreException && !FilesSecurity.CanDelete(folder))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFolder;
}
else
{
FileMarker.RemoveMarkAsNewForAll(folder);
if (FolderDao.UseTrashForRemove(folder))
{
var files = FileDao.GetFiles(folder.ID, true);
if (!ignoreException && files.Exists(FileTracker.IsEditing))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteEditingFolder;
}
else
{
FolderDao.MoveFolder(folder.ID, trashId);
FilesMessageService.Send(folder, headers, MessageAction.FolderMovedToTrash, folder.Title);
ProcessedFolder(folderId);
}
}
else
{
if (FolderDao.UseRecursiveOperation(folder.ID, null))
{
DeleteFiles(FileDao.GetFiles(folder.ID, false));
DeleteFolders(FolderDao.GetFolders(folder.ID).Select(f => f.ID).ToList());
if (FolderDao.GetItemsCount(folder.ID, true) == 0)
{
FolderDao.DeleteFolder(folder.ID);
ProcessedFolder(folderId);
}
}
else
{
if (folder.ProviderEntry && folder.ID.Equals(folder.RootFolderId))
{
ProviderDao.RemoveProviderInfo(folder.ProviderId);
}
else
{
FolderDao.DeleteFolder(folder.ID);
}
ProcessedFolder(folderId);
}
}
}
ProgressStep();
}
}
private void MoveOrCopyFiles(ICollection fileIds, Folder toFolder, bool copy)
{
if (fileIds.Count == 0)
{
return;
}
var toFolderId = toFolder.ID;
foreach (var fileId in fileIds)
{
if (Canceled)
{
return;
}
var file = FileDao.GetFile(fileId);
if (file == null)
{
Error = FilesCommonResource.ErrorMassage_FileNotFound;
}
else if (!FilesSecurity.CanRead(file))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_ReadFile;
}
else if (Global.EnableUploadFilter &&
!FileUtility.ExtsUploadable.Contains(FileUtility.GetFileExtension(file.Title)))
{
Error = FilesCommonResource.ErrorMassage_NotSupportedFormat;
}
else // if (!Equals(file.FolderID.ToString(), toFolderId.ToString()) || _resolveType == FileConflictResolveType.Duplicate)
{
var parentFolder = FolderDao.GetFolder(file.FolderID);
try
{
var conflict = _resolveType == FileConflictResolveType.Duplicate
? null
: FileDao.GetFile(toFolderId, file.Title);
if (conflict != null && !FilesSecurity.CanEdit(conflict))
{
Error = FilesCommonResource.ErrorMassage_SecurityException;
}
else if (conflict != null && EntryManager.FileLockedForMe(conflict.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (conflict == null)
{
if (copy)
{
File newFile = null;
try
{
newFile = FileDao.CopyFile(file.ID, toFolderId); //Stream copy will occur inside dao
FilesMessageService.Send(file, toFolder, httpRequestHeaders, MessageAction.FileCopied, file.Title, parentFolder.Title, toFolder.Title);
if (Equals(newFile.FolderID.ToString(), _toFolderId))
{
_needToMarkAsNew.Add(newFile);
}
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", newFile.ID, SplitCharacter);
ResultedFile(newFile.ID);
}
}
catch
{
if (newFile != null)
{
FileDao.DeleteFile(newFile.ID);
}
throw;
}
}
else
{
if (EntryManager.FileLockedForMe(file.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (FileTracker.IsEditing(file.ID))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_UpdateEditingFile;
}
else if (FilesSecurity.CanDelete(file))
{
FileMarker.RemoveMarkAsNewForAll(file);
var newFileId = FileDao.MoveFile(file.ID, toFolderId);
FilesMessageService.Send(file, toFolder, httpRequestHeaders, MessageAction.FileMoved, file.Title, parentFolder.Title, toFolder.Title);
if (Equals(toFolderId.ToString(), _toFolderId))
{
_needToMarkAsNew.Add(FileDao.GetFile(newFileId));
}
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", newFileId, SplitCharacter);
ResultedFile(newFileId);
}
}
else
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFile;
}
}
}
else
{
if (_resolveType == FileConflictResolveType.Overwrite)
{
if (EntryManager.FileLockedForMe(conflict.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (FileTracker.IsEditing(conflict.ID))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_UpdateEditingFile;
}
else
{
conflict.Version++;
using (var stream = FileDao.GetFileStream(file))
{
conflict.ContentLength = stream.Length;
conflict.Comment = string.Empty;
conflict = FileDao.SaveFile(conflict, stream);
_needToMarkAsNew.Add(conflict);
}
if (copy)
{
FilesMessageService.Send(file, toFolder, httpRequestHeaders, MessageAction.FileCopiedWithOverwriting, file.Title, parentFolder.Title, toFolder.Title);
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", conflict.ID, SplitCharacter);
ResultedFile(conflict.ID);
}
}
else
{
if (Equals(file.FolderID.ToString(), toFolderId.ToString()))
{
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", conflict.ID, SplitCharacter);
ResultedFile(conflict.ID);
}
}
else
{
if (EntryManager.FileLockedForMe(file.ID))
{
Error = FilesCommonResource.ErrorMassage_LockedFile;
}
else if (FileTracker.IsEditing(file.ID))
{
Error = FilesCommonResource.ErrorMassage_SecurityException_UpdateEditingFile;
}
else if (FilesSecurity.CanDelete(file))
{
FileDao.DeleteFile(file.ID);
FileDao.DeleteFolder(file.ID);
FilesMessageService.Send(file, toFolder, httpRequestHeaders, MessageAction.FileMovedWithOverwriting, file.Title, parentFolder.Title, toFolder.Title);
if (ProcessedFile(fileId))
{
Status += string.Format("file_{0}{1}", conflict.ID, SplitCharacter);
ResultedFile(conflict.ID);
}
}
else
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFile;
}
}
}
}
}
else if (_resolveType == FileConflictResolveType.Skip)
{
//nothing
}
}
}
catch (Exception ex)
{
Error = ex.Message;
Logger.Error(Error, ex);
}
}
ProgressStep();
}
}
public static void ProcessData(string fileId, bool isNew, string trackDataString)
{
if (string.IsNullOrEmpty(trackDataString))
{
throw new ArgumentException("DocService return null");
}
var data = JObject.Parse(trackDataString);
if (data == null)
{
throw new ArgumentException("DocService response is incorrect");
}
var fileData = data.ToObject <TrackerData>();
Guid userId;
switch (fileData.Status)
{
case TrackerStatus.NotFound:
case TrackerStatus.Closed:
FileTracker.Remove(fileId);
break;
case TrackerStatus.Editing:
if (ThirdPartySelector.GetAppByFileId(fileId) != null)
{
break;
}
var users = FileTracker.GetEditingBy(fileId);
var usersDrop = new List <string>();
foreach (var user in fileData.Users)
{
if (!Guid.TryParse(user, out userId))
{
Global.Logger.Error("DocService userId is not Guid: " + user);
continue;
}
users.Remove(userId);
try
{
var shareLinkKey = FileShareLink.CreateKey(fileId);
EntryManager.TrackEditing(fileId, userId, userId, isNew, shareLinkKey);
}
catch (Exception e)
{
Global.Logger.DebugFormat("Drop command: fileId '{0}' docKey '{1}' for user {2} : {3}", fileId, fileData.Key, user, e.Message);
usersDrop.Add(user);
}
}
if (usersDrop.Any())
{
var dropString = "[\"" + string.Join("\",\"", usersDrop) + "\"]";
if (!Drop(fileData.Key, dropString, fileId))
{
Global.Logger.Error("DocService drop failed for users " + dropString);
}
}
foreach (var removeUserId in users)
{
FileTracker.Remove(fileId, userId: removeUserId);
}
break;
case TrackerStatus.MustSave:
case TrackerStatus.Corrupted:
var comments = new List <string>();
if (fileData.Status == TrackerStatus.Corrupted)
{
comments.Add(FilesCommonResource.ErrorMassage_SaveCorrupted);
}
if (fileData.Users == null || fileData.Users.Count == 0 || !Guid.TryParse(fileData.Users[0], out userId))
{
userId = FileTracker.GetEditingBy(fileId).FirstOrDefault();
}
try
{
SecurityContext.AuthenticateMe(userId);
}
catch (Exception ex)
{
Global.Logger.Warn("DocService save error: anonymous author - " + userId, ex);
if (!userId.Equals(ASC.Core.Configuration.Constants.Guest.ID))
{
comments.Add(FilesCommonResource.ErrorMassage_SaveAnonymous);
}
}
File file = null;
var saved = false;
if (string.IsNullOrEmpty(fileData.Url))
{
try
{
comments.Add(FilesCommonResource.ErrorMassage_SaveUrlLost);
FileTracker.Remove(fileId);
file = EntryManager.CompleteVersionFile(fileId, 0, false, false);
using (var fileDao = Global.DaoFactory.GetFileDao())
{
fileDao.UpdateComment(file.ID, file.Version, string.Join("; ", comments));
}
}
catch (Exception ex)
{
Global.Logger.Error(string.Format("DocService save error. Version update. File id: '{0}'. UserId: {1}. DocKey '{2}'", fileId, userId, fileData.Key), ex);
}
}
else
{
try
{
file = EntryManager.SaveEditing(fileId, -1, userId, fileData.Url, isNew, string.Empty, string.Join("; ", comments), false);
saved = fileData.Status == TrackerStatus.MustSave;
}
catch (Exception ex)
{
Global.Logger.Error(string.Format("DocService save error. File id: '{0}'. UserId: {1}. DocKey '{2}'. DownloadUri: {3}", fileId, userId, fileData.Key, fileData.Url), ex);
StoringFileAfterError(fileId, userId.ToString(), fileData.Url);
}
}
if (file != null)
{
var user = CoreContext.UserManager.GetUsers(userId);
if (user != null)
{
FilesMessageService.Send(file, MessageInitiator.DocsService, MessageAction.UserFileUpdated, user.DisplayUserName(false), file.Title);
}
SaveHistory(file, fileData.ChangesHistory, fileData.ChangesUrl);
}
FileTracker.Remove(fileId);
Command(TrackMethod.Saved, fileData.Key, fileId, null, userId.ToString(), saved ? "1" : "0");
break;
}
}
public void Deconstruct(out GlobalStore globalStore, out FilesLinkUtility filesLinkUtility, out SetupInfo setupInfo, out FileConverter fileConverter, out FilesMessageService filesMessageService)
{
globalStore = GlobalStore;
filesLinkUtility = FilesLinkUtility;
setupInfo = SetupInfo;
fileConverter = FileConverter;
filesMessageService = FilesMessageService;
}
private void DeleteFolders(IEnumerable <object> folderIds)
{
foreach (var folderId in folderIds)
{
CancellationToken.ThrowIfCancellationRequested();
var folder = FolderDao.GetFolder(folderId);
object canCalculate = null;
if (folder == null)
{
Error = FilesCommonResource.ErrorMassage_FolderNotFound;
}
else if (folder.FolderType != FolderType.DEFAULT && folder.FolderType != FolderType.BUNCH)
{
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFolder;
}
else if (!_ignoreException && !FilesSecurity.CanDelete(folder))
{
canCalculate = FolderDao.CanCalculateSubitems(folderId) ? null : folderId;
Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFolder;
}
else
{
canCalculate = FolderDao.CanCalculateSubitems(folderId) ? null : folderId;
FileMarker.RemoveMarkAsNewForAll(folder);
if (folder.ProviderEntry && folder.ID.Equals(folder.RootFolderId))
{
if (ProviderDao != null)
{
ProviderDao.RemoveProviderInfo(folder.ProviderId);
FilesMessageService.Send(folder, _headers, MessageAction.ThirdPartyDeleted, folder.ID.ToString(), folder.ProviderKey);
}
ProcessedFolder(folderId);
}
else
{
var immediately = _immediately || !FolderDao.UseTrashForRemove(folder);
if (immediately && FolderDao.UseRecursiveOperation(folder.ID, null))
{
DeleteFiles(FileDao.GetFiles(folder.ID));
DeleteFolders(FolderDao.GetFolders(folder.ID).Select(f => f.ID).ToList());
if (FolderDao.IsEmpty(folder.ID))
{
FolderDao.DeleteFolder(folder.ID);
FilesMessageService.Send(folder, _headers, MessageAction.FolderDeleted, folder.Title);
ProcessedFolder(folderId);
}
}
else
{
var files = FileDao.GetFiles(folder.ID, new OrderBy(SortedByType.AZ, true), FilterType.FilesOnly, false, Guid.Empty, string.Empty, false, true);
string tmpError;
if (!_ignoreException && WithError(files, true, out tmpError))
{
Error = tmpError;
}
else
{
if (immediately)
{
FolderDao.DeleteFolder(folder.ID);
FilesMessageService.Send(folder, _headers, MessageAction.FolderDeleted, folder.Title);
}
else
{
FolderDao.MoveFolder(folder.ID, _trashId, CancellationToken);
FilesMessageService.Send(folder, _headers, MessageAction.FolderMovedToTrash, folder.Title);
}
ProcessedFolder(folderId);
}
}
}
}
ProgressStep(canCalculate);
}
}
