public async Task <HttpResponseMessage> PutFile(string file_id)
{
var putFileRequest = new PutFileRequest(this.Request, file_id);
WopiResponse wopiResponse = null;
try
{
if (await Authorize(putFileRequest))
{
if (await WopiProof.Validate(putFileRequest))
{
wopiResponse = await PutFile(putFileRequest);
}
else
{
wopiResponse = putFileRequest.ResponseServerError("Proof validation failed");
}
}
else
{
wopiResponse = putFileRequest.ResponseUnauthorized();
}
}
catch (Exception ex)
{
wopiResponse = putFileRequest.ResponseServerError(ex.Message);
}
return(wopiResponse.ToHttpResponse());
}
public async Task <PutFileResponse> PutFileEx(string filespaceId, string path, string filename, Stream contents,
long sizeOfContents)
{
Log.LogDebug("PutFileEx: filespaceId={0}, fullName={1} {2}", filespaceId, path, filename);
//NOTE: for this to work in TCC the path must exist otherwise TCC either gives an error or creates the file as the folder name
var sendFileParams = new PutFileRequest
{
filespaceid = filespaceId,
path = path,
replace = true,
commitUpload = true,
filename = filename
};
if (string.IsNullOrEmpty(tccBaseUrl))
{
throw new Exception("Configuration Error - no TCC url specified");
}
var gracefulClient = new GracefulWebRequest(logFactory, configStore, _httpClientFactory);
var(requestString, headers) = FormRequest(sendFileParams, "PutFile");
headers.Add("X-File-Name", WebUtility.UrlEncode(filename));
headers.Add("X-File-Size", sizeOfContents.ToString());
headers.Add("X-FileType", "");
headers.Add("Content-Type", ContentTypeConstants.ApplicationOctetStream);
var result = default(PutFileResponse);
try
{
result = await gracefulClient.ExecuteRequest <PutFileResponse>(requestString, contents, headers, HttpMethod.Put);
}
catch (WebException webException)
{
using (var response = webException.Response)
{
Log.LogWarning(
$"Can not execute request TCC request with error {webException.Status} and {webException.Message}. {GetStringFromResponseStream(response)}");
}
}
catch (Exception exception)
{
Log.LogWarning($"TCC request failed: {exception.Message}");
}
return(result);
}
/// <summary>
/// Implements a put file request.
/// </summary>
private async Task <PutFileResponse> PutFileAsync(PutFileRequest request, CancellationToken token)
{
LogRequestHandling();
DateTime startTime = DateTime.UtcNow;
var cacheContext = new Context(new Guid(request.Header.TraceId), _logger);
return(await RunFuncAndReportAsync(
request.Header.SessionId,
async session =>
{
PutResult putResult;
if (request.ContentHash == ByteString.Empty)
{
putResult = await session.PutFileAsync(
cacheContext,
(HashType)request.HashType,
new AbsolutePath(request.Path),
(FileRealizationMode)request.FileRealizationMode,
token);
}
else
{
putResult = await session.PutFileAsync(
cacheContext,
request.ContentHash.ToContentHash((HashType)request.HashType),
new AbsolutePath(request.Path),
(FileRealizationMode)request.FileRealizationMode,
token);
}
return new PutFileResponse
{
Header =
new ResponseHeader(
startTime,
putResult.Succeeded,
putResult.Succeeded ? 0 : 1,
putResult.ErrorMessage,
putResult.Diagnostics),
ContentSize = putResult.ContentSize,
ContentHash = putResult.ContentHash.ToByteString(),
HashType = (int)putResult.ContentHash.HashType
};
},
errorMessage => new PutFileResponse {
Header = ResponseHeader.Failure(startTime, errorMessage)
}));
}
private Task <PutFileResponse> PutFileAsync(PutFileRequest request, CancellationToken token)
{
return(RunFuncAsync(
request.Header,
async(context, session) =>
{
PutResult putResult;
if (request.ContentHash == ByteString.Empty)
{
putResult = await session.PutFileAsync(
context.OperationContext,
(HashType)request.HashType,
new AbsolutePath(request.Path),
(FileRealizationMode)request.FileRealizationMode,
context.Token);
}
else
{
putResult = await session.PutFileAsync(
context.OperationContext,
request.ContentHash.ToContentHash((HashType)request.HashType),
new AbsolutePath(request.Path),
(FileRealizationMode)request.FileRealizationMode,
context.Token);
}
return new PutFileResponse
{
Header =
new ResponseHeader(
context.StartTime,
putResult.Succeeded,
putResult.Succeeded ? 0 : 1,
putResult.ErrorMessage,
putResult.Diagnostics),
ContentSize = putResult.ContentSize,
ContentHash = putResult.ContentHash.ToByteString(),
HashType = (int)putResult.ContentHash.HashType
};
},
(context, errorMessage) => new PutFileResponse {
Header = ResponseHeader.Failure(context.StartTime, errorMessage)
},
token: token));
}
public override async Task <WopiResponse> PutFile(PutFileRequest putFileRequest)
{
var userId = WopiSecurity.GetIdentityNameFromToken(putFileRequest.AccessToken);
var wopiFileRespository = new WopiFileRepository();
var response = await wopiFileRespository.UpdateFileContent(putFileRequest.ResourceId, userId, putFileRequest.Lock, await putFileRequest.Content.ReadAsStreamAsync());
if (response.Item1 == HttpStatusCode.NotFound)
{
return(putFileRequest.ResponseNotFound());
}
else if (response.Item1 == HttpStatusCode.Conflict)
{
return(putFileRequest.ResponseLockConflict(response.Item2));
}
else if (response.Item1 == HttpStatusCode.OK)
{
return(putFileRequest.ResponseOK(response.Item3));
}
else
{
return(putFileRequest.ResponseServerError(string.Format("Unknown HTTPStatusCode from WopiFileRepository.UpdateFileContent: {0}", response.Item1)));
}
}
/// <summary>
/// Replaces the file or if it doesn't exist, creates it.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>PutFileResponse</c> with a file id.
/// </returns>
public PutFileResponse Put(PutFileRequest request)
{
IEnumerable <MediaFolder> parentFolderFuture = null;
if (request.Data.FolderId.HasValue)
{
parentFolderFuture = repository.AsQueryable <MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.ToFuture();
}
var mediaFile = repository.AsQueryable <MediaFile>()
.Where(file => file.Id == request.Id)
.FetchMany(f => f.AccessRules)
.ToFuture()
.FirstOrDefault();
MediaFolder parentFolder = null;
if (parentFolderFuture != null)
{
parentFolder = parentFolderFuture.First();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.File)
{
throw new CmsApiValidationException("Folder must be type of an file.");
}
}
var createFile = mediaFile == null;
if (createFile)
{
mediaFile = new MediaFile
{
Id = request.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.File,
AccessRules = new List <AccessRule>()
};
}
else if (request.Data.Version > 0)
{
mediaFile.Version = request.Data.Version;
}
unitOfWork.BeginTransaction();
if (!createFile)
{
repository.Save(mediaFile.CreateHistoryItem());
}
mediaFile.Title = request.Data.Title;
mediaFile.Description = request.Data.Description;
mediaFile.Size = request.Data.FileSize;
mediaFile.PublicUrl = request.Data.PublicUrl;
mediaFile.Folder = parentFolder;
mediaFile.PublishedOn = request.Data.PublishedOn;
mediaFile.OriginalFileName = request.Data.OriginalFileName;
mediaFile.OriginalFileExtension = request.Data.OriginalFileExtension;
mediaFile.Image = request.Data.ThumbnailId.GetValueOrDefault() != default(Guid)
? repository.AsProxy <MediaImage>(request.Data.ThumbnailId.Value)
: null;
mediaFile.FileUri = new Uri(request.Data.FileUri);
mediaFile.IsUploaded = request.Data.IsUploaded;
mediaFile.IsTemporary = request.Data.IsTemporary;
mediaFile.IsCanceled = request.Data.IsCanceled;
var archivedMedias = new List <Media>();
var unarchivedMedias = new List <Media>();
if (mediaFile.IsArchived != request.Data.IsArchived)
{
if (request.Data.IsArchived)
{
archivedMedias.Add(mediaFile);
mediaService.ArchiveSubMedias(mediaFile, archivedMedias);
}
else
{
unarchivedMedias.Add(mediaFile);
mediaService.UnarchiveSubMedias(mediaFile, unarchivedMedias);
}
}
mediaFile.IsArchived = request.Data.IsArchived;
IList <Tag> newTags = null;
if (request.Data.Tags != null)
{
tagService.SaveMediaTags(mediaFile, request.Data.Tags, out newTags);
}
if (request.Data.AccessRules != null)
{
mediaFile.AccessRules.RemoveDuplicateEntities();
var accessRules =
request.Data.AccessRules.Select(
r => (IAccessRule) new AccessRule {
AccessLevel = (Core.Security.AccessLevel)(int) r.AccessLevel, Identity = r.Identity, IsForRole = r.IsForRole
})
.ToList();
accessControlService.UpdateAccessControl(mediaFile, accessRules);
}
if (request.Data.Categories != null)
{
categoryService.CombineEntityCategories <Media, MediaCategory>(mediaFile, request.Data.Categories);
}
repository.Save(mediaFile);
unitOfWork.Commit();
// Fire events.
Events.RootEvents.Instance.OnTagCreated(newTags);
if (createFile)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(mediaFile);
}
else
{
Events.MediaManagerEvents.Instance.OnMediaFileUpdated(mediaFile);
}
foreach (var archivedMedia in archivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaArchived(archivedMedia);
}
foreach (var archivedMedia in unarchivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaUnarchived(archivedMedia);
}
return(new PutFileResponse
{
Data = mediaFile.Id
});
}
/// <summary>
/// Replaces the file or if it doesn't exist, creates it.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>PutFileResponse</c> with a file id.
/// </returns>
public PutFileResponse Put(PutFileRequest request)
{
IEnumerable<MediaFolder> parentFolderFuture = null;
if (request.Data.FolderId.HasValue)
{
parentFolderFuture = repository.AsQueryable<MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.ToFuture();
}
var mediaFile = repository.AsQueryable<MediaFile>()
.Where(file => file.Id == request.Id)
.FetchMany(f => f.AccessRules)
.ToFuture()
.FirstOrDefault();
MediaFolder parentFolder = null;
if (parentFolderFuture != null)
{
parentFolder = parentFolderFuture.First();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.File)
{
throw new CmsApiValidationException("Folder must be type of an file.");
}
}
var createFile = mediaFile == null;
if (createFile)
{
mediaFile = new MediaFile
{
Id = request.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.File,
AccessRules = new List<AccessRule>()
};
}
else if (request.Data.Version > 0)
{
mediaFile.Version = request.Data.Version;
}
unitOfWork.BeginTransaction();
if (!createFile)
{
repository.Save(mediaFile.CreateHistoryItem());
}
mediaFile.Title = request.Data.Title;
mediaFile.Description = request.Data.Description;
mediaFile.Size = request.Data.FileSize;
mediaFile.PublicUrl = request.Data.PublicUrl;
mediaFile.Folder = parentFolder;
mediaFile.PublishedOn = request.Data.PublishedOn;
mediaFile.OriginalFileName = request.Data.OriginalFileName;
mediaFile.OriginalFileExtension = request.Data.OriginalFileExtension;
mediaFile.Image = request.Data.ThumbnailId.GetValueOrDefault() != default(Guid)
? repository.AsProxy<MediaImage>(request.Data.ThumbnailId.Value)
: null;
mediaFile.FileUri = new Uri(request.Data.FileUri);
mediaFile.IsUploaded = request.Data.IsUploaded;
mediaFile.IsTemporary = request.Data.IsTemporary;
mediaFile.IsCanceled = request.Data.IsCanceled;
var archivedMedias = new List<Media>();
var unarchivedMedias = new List<Media>();
if (mediaFile.IsArchived != request.Data.IsArchived)
{
if (request.Data.IsArchived)
{
archivedMedias.Add(mediaFile);
mediaService.ArchiveSubMedias(mediaFile, archivedMedias);
}
else
{
unarchivedMedias.Add(mediaFile);
mediaService.UnarchiveSubMedias(mediaFile, unarchivedMedias);
}
}
mediaFile.IsArchived = request.Data.IsArchived;
IList<Tag> newTags = null;
if (request.Data.Tags != null)
{
tagService.SaveMediaTags(mediaFile, request.Data.Tags, out newTags);
}
if (request.Data.AccessRules != null)
{
mediaFile.AccessRules.RemoveDuplicateEntities();
var accessRules =
request.Data.AccessRules.Select(
r => (IAccessRule)new AccessRule { AccessLevel = (Core.Security.AccessLevel)(int)r.AccessLevel, Identity = r.Identity, IsForRole = r.IsForRole })
.ToList();
accessControlService.UpdateAccessControl(mediaFile, accessRules);
}
if (request.Data.Categories != null)
{
categoryService.CombineEntityCategories<Media, MediaCategory>(mediaFile, request.Data.Categories);
}
repository.Save(mediaFile);
unitOfWork.Commit();
// Fire events.
Events.RootEvents.Instance.OnTagCreated(newTags);
if (createFile)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(mediaFile);
}
else
{
Events.MediaManagerEvents.Instance.OnMediaFileUpdated(mediaFile);
}
foreach (var archivedMedia in archivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaArchived(archivedMedia);
}
foreach (var archivedMedia in unarchivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaUnarchived(archivedMedia);
}
return new PutFileResponse
{
Data = mediaFile.Id
};
}
/// <inheritdoc /> public override Task <PutFileResponse> PutFile(PutFileRequest request, ServerCallContext context) => _contentServer.PutFileAsync(request, context.CancellationToken);
public abstract Task <WopiResponse> PutFile(PutFileRequest putFileRequest);
public bool SendRequest(WebSocketRequest request, bool isAsync = false)
{
request.ClientGuid = _applianceGuid;
if (Status == WebSessionStatus.Logging)
{
_waitConnectionOpenedEvent.WaitOne(TimeSpan.FromSeconds(20));
}
if (Status != WebSessionStatus.Active)
{
Console.WriteLine("Inactive connection. Refuse this request " + request);
if (isAsync)
{
WebSocketNotificationHandler.ReceiveResponse(request.RequestId, false);
}
return false;
}
if (request.RequestType == WebSocketRequestType.PutFileProxyRequest)
{
PutFileProxyRequest putFileProxyRequest = (PutFileProxyRequest)request;
foreach (NeedSendData needSendData in NeedSendDataManager.Instance.NeedSendDatas)
{
PutFileRequest putFileRequest = new PutFileRequest
{
RequestId = RequestHelper.NextRequestId(),
FilePath = putFileProxyRequest.FilePath,
FileData = needSendData.FileData,
Position = needSendData.Position
};
bool isSuccess = (bool)WebSocketHandler.SendRequestReturnResult(this, putFileRequest);
Interlocked.Add(ref _sendDataLengthCount, needSendData.FileData.Length);
if (!isSuccess)
{
WebSocketNotificationHandler.ReceiveResponse(putFileProxyRequest.RequestId, false);
return false;
}
}
WebSocketNotificationHandler.ReceiveResponse(putFileProxyRequest.RequestId, true);
return true;
}
//Send file bytes directly to ESS Server without Json because frequent Json deserialization costs high
// CPU in ESS Server.
if (request.RequestType == WebSocketRequestType.PutFileRequest)
{
Interlocked.Increment(ref _getPutRequestCnt);
PutFileRequest putFileRequest = (PutFileRequest)request;
var data = WebSocketBlockWrite.PutFileRequestToByte(putFileRequest);
var arrayList = new List<ArraySegment<byte>>();
var array = new ArraySegment<byte>(data);
arrayList.Add(array);
_webSocket.Send(arrayList);
}
return true;
}
public override async Task <WopiResponse> PutFile(PutFileRequest putFileRequest)
{
WopiResponse wopiResponse = null;
var file = DocumentDBRepository <DetailedFileModel> .GetItem("Files", i => i.id.ToString() == putFileRequest.ResourceId);
// Check for null file
if (file != null)
{
var inputStream = await putFileRequest.Content.ReadAsStreamAsync();
// Ensure the file has a valid lock
if (String.IsNullOrEmpty(file.LockValue))
{
// If the file is 0 bytes, this is document creation
if (inputStream.Length == 0)
{
// Update the file in blob storage
var bytes = new byte[inputStream.Length];
inputStream.Read(bytes, 0, bytes.Length);
file.Size = bytes.Length;
await AzureStorageUtil.UploadFile(file.id.ToString(), file.Container, bytes);
// Update version
file.Version++;
await DocumentDBRepository <FileModel> .UpdateItemAsync("Files", file.id.ToString(), file);
// Return success 200
wopiResponse = putFileRequest.ResponseOK();
}
else
{
// File isn't locked...pass empty Lock in mismatch response
wopiResponse = putFileRequest.ResponseLockConflict(String.Empty, "File isn't locked");
}
}
else if (file.LockExpires != null && file.LockExpires < DateTime.Now)
{
// File lock expired, so clear it out
file.LockValue = null;
file.LockExpires = null;
await DocumentDBRepository <FileModel> .UpdateItemAsync("Files", file.id.ToString(), file);
// File isn't locked...pass empty Lock in mismatch response
wopiResponse = putFileRequest.ResponseLockConflict(String.Empty, "File isn't locked");
}
else if (putFileRequest.Lock != file.LockValue)
{
// File lock mismatch...pass Lock in mismatch response
wopiResponse = putFileRequest.ResponseLockConflict(file.LockValue, "Lock mismatch");
}
else
{
// Update the file in blob storage
var bytes = new byte[inputStream.Length];
inputStream.Read(bytes, 0, bytes.Length);
file.Size = bytes.Length;
await AzureStorageUtil.UploadFile(file.id.ToString(), file.Container, bytes);
// Update version
file.Version++;
await DocumentDBRepository <FileModel> .UpdateItemAsync("Files", file.id.ToString(), (FileModel)file);
// Return success 200
wopiResponse = putFileRequest.ResponseOK();
}
}
else
{
wopiResponse = putFileRequest.ResponseNotFound();
}
return(wopiResponse);
}
public HttpResponseMessage PutFile(int id, PutFileRequest request)
{
try
{
if (request.FileType == FileType.JavaScriptLib)
{
this.repository.UpdateLibrary(
new JackrabbitLibrary(request.FileType, request.LibraryName, request.Version, request.Specificity));
return this.Request.CreateResponse(HttpStatusCode.OK, this.GetAllItems(this.ActiveModule.ModuleID));
}
else
{
this.repository.UpdateFile(
new JackrabbitFile(request.FileType, id, request.PathPrefixName, request.FilePath, request.Provider, request.Priority));
return this.Request.CreateResponse(HttpStatusCode.OK, this.GetAllItems(this.ActiveModule.ModuleID));
}
}
catch (Exception exc)
{
return this.HandleException(exc);
}
}
