public async Task <HttpResponseMessage> GetFile(string file_id)
{
var getFileRequest = new GetFileRequest(this.Request, file_id);
WopiResponse wopiResponse = null;
try
{
if (await Authorize(getFileRequest))
{
if (await WopiProof.Validate(getFileRequest))
{
wopiResponse = await GetFile(getFileRequest);
}
else
{
getFileRequest.ResponseServerError("Proof validation failed");
}
}
else
{
wopiResponse = getFileRequest.ResponseUnauthorized();
}
}
catch (Exception ex)
{
wopiResponse = getFileRequest.ResponseServerError(ex.Message);
}
return(wopiResponse.ToHttpResponse());
}
public Task <Result> GetFileAsync(
ServerInfo remoteServerInfo,
string fileName,
long fileSizeInBytes,
string remoteFolderPath,
string localFolderPath)
{
var fileTransfer = FileTransferHandler.InitializeFileTransfer(
TransferDirection.Inbound,
FileTransferInitiator.Self,
remoteServerInfo,
fileName,
fileSizeInBytes,
localFolderPath,
remoteFolderPath,
0,
0,
0);
var getFileRequest = new GetFileRequest()
{
LocalServerInfo = MyInfo,
RemoteServerInfo = fileTransfer.RemoteServerInfo,
FileName = fileTransfer.FileName,
RemoteFolderPath = fileTransfer.RemoteFolderPath,
LocalFolderPath = fileTransfer.LocalFolderPath,
RemoteServerTransferId = fileTransfer.Id,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
return(_requestHandler.SendRequestAsync(getFileRequest));
}
public Result <FileTransfer> HandleOutboundFileTransferRequest(GetFileRequest getFileRequest)
{
var requestedFilePath = Path.Combine(getFileRequest.LocalFolderPath, getFileRequest.FileName);
if (!File.Exists(requestedFilePath))
{
ReportError("Requested file does not exist");
RequestedFileDoesNotExist?.Invoke(this, getFileRequest);
return(Result.Fail <FileTransfer>("Requested file does not exist"));
}
var fileSizeInBytes = new FileInfo(requestedFilePath).Length;
var outboundFileTransfer =
InitializeFileTransfer(
TransferDirection.Outbound,
FileTransferInitiator.RemoteServer,
getFileRequest.RemoteServerInfo,
getFileRequest.FileName,
fileSizeInBytes,
getFileRequest.LocalFolderPath,
getFileRequest.RemoteFolderPath,
DateTime.Now.Ticks,
Settings.TransferRetryLimit,
getFileRequest.RemoteServerTransferId);
return(Result.Ok(outboundFileTransfer));
}
public async Task TestUploadUpdateDownloadAndDeleteFile( )
{
var fileInfo = new System.IO.FileInfo(Path.Join(".", "testFiles", "test.png"));
var fileDescription = "File Description";
var uploadFileResponse = await SkyManager.MediaClient.UploadFile(fileInfo, "File Title", fileDescription);
var fileId = uploadFileResponse.FileId;
var updateFileBody = new FileUpdate();
updateFileBody.Filename = "File.png";
updateFileBody.Title = "Updated File Title";
updateFileBody.Description = "Updated File Description";
updateFileBody.Tags = new List <string>();
updateFileBody.Properties = new Properties();
var updateFileRequest = new UpdateFileRequest(updateFileBody, fileId);
updateFileRequest.AdditionalRequestHeaders.Add(new KeyValuePair <string, string>("If-Match", uploadFileResponse.ETag));
await SkyManager.ApiClient.ExecuteRequestAsync(updateFileRequest);
await SkyManager.MediaClient.DownloadFile(fileId);
var getFileRequest = new GetFileRequest(fileId);
var getFileResponse = await SkyManager.ApiClient.ExecuteRequestAsync(getFileRequest);
Assert.Equal("Updated File Description", getFileResponse.Content.Description);
await SkyManager.ApiClient.ExecuteRequestAsync(new DeleteFileRequest(fileId));
}
public async Task <FileStreamResult> GetFile([FromBody] GetFileRequest request)
{
var stream = await _gitLabService.GetFileStream(request.HttpUrlToRepo, request.Ref, request.Path);
var fileName = UriHelper.GetFileNameFromUrl(request.Path);
var contentType = _mimeMappingService.Map(fileName);
return(new FileStreamResult(stream, contentType));
}
public async Task <Tuple <storage_FileType, byte[]> > GetFile(long volume_id, int local_id, long secret, int offset, int limit)
{
var request = new GetFileRequest(new InputFileLocationConstructor(volume_id, local_id, secret), offset, limit);
await _sender.Send(request);
await _sender.Receive(request);
return(Tuple.Create(request.type, request.bytes));
}
// upload.getFile#e3a6cfb5 location:InputFileLocation offset:int limit:int = upload.File;
public async Task <UploadFileConstructor> GetFile(FileLocationConstructor fileLocation, int offset, int limit)
{
var request = new GetFileRequest(new InputFileLocationConstructor(fileLocation.volumeId, fileLocation.localId, fileLocation.secret), offset, limit);
await SendRpcRequestInSeparateSession(fileLocation.dcId, request);
// only single implementation available
return((UploadFileConstructor)request.file);
}
public async Task <UploadFileConstructor> GetFile(int dcId, InputFileLocation inputFileLocation, int offset, int limit)
{
var request = new GetFileRequest(inputFileLocation, offset, limit);
await SendRpcRequestInSeparateSession(dcId, request);
// only single implementation available
return((UploadFileConstructor)request.file);
}
public async Task <Upload_fileConstructor> GetFile(InputFileLocation location)
{
var request = new GetFileRequest(location, 0, int.MaxValue);
await _sender.Send(request);
await _sender.Recieve(request);
return(new Upload_fileConstructor(request.type, request.mtime, request.bytes));
}
public IActionResult GetFile([FromQuery] GetFileRequest request)
{
var getFile = UploadFileService.GetFile(request.FileFullName).Result;
if (getFile.data is null)
{
return(ResponseBadRequest(getFile.message));
}
new FileExtensionContentTypeProvider().TryGetContentType(request.FileFullName, out string contentType);
return(File((byte[])getFile.data, contentType ?? "application/octet-stream"));
}
public async Task When_GetFileUsecase_Execute_method_is_called_it_calls_the_gateway()
{
//arrange
var request = new GetFileRequest();
//act
await _getFileUsecase.Execute(request);
//assert
_mockGateway.Verify(g => g.DownloadFile(It.IsAny <GetFileRequest>()), Times.Once);
}
public async Task <ActionResult <File> > GetFile()
{
var assetClient = _mindSphereSdkService.GetAssetManagementClient();
var request = new GetFileRequest()
{
Id = "fe81d2c22a9448eea41d0f460e5a5731"
};
var file = await assetClient.GetFileAsync(request);
return(StatusCode(200, file));
}
public Stream GetFile(GetFileRequest request)
{
try
{
var saucerMultimedia = _saucerMultimediaRepository.FindBy(request.Id);
saucerMultimedia.ThrowExceptionIfRecordIsNull();
var stream = _storageProvider.Retrieve(saucerMultimedia.Path);
return(stream);
}
catch (DataAccessException)
{
throw new ApplicationException();
}
}
public ActionResult Upload(TestUploadViewModel model)
{
if (model != null && model.File != null)
{
using (var api = ApiFactory.Create())
{
if (model.Type == "file")
{
var uploadRequest = new UploadFileRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Files.Upload.Post(uploadRequest);
var getRequest = new GetFileRequest {
FileId = uploadResponse.Data.Value
};
var getResponse = api.Media.File.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>File upload successful!</h2> File can be downloaded here: <div><a href='{0}' />{1}</a></div>",
getResponse.Data.FileUrl,
getResponse.Data.Title);
}
else
{
var uploadRequest = new UploadImageRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Images.Upload.Post(uploadRequest);
var getRequest = new GetImageRequest {
ImageId = uploadResponse.Data.Value
};
var getResponse = api.Media.Image.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>Image upload successful!</h2> <div><img src='{0}' alt='{1}' /></div>",
getResponse.Data.ImageUrl,
getResponse.Data.Title);
}
}
}
return(View(model));
}
public async Task Given_a_valid_request_when_The_Execute_method_is_called_it_calls_the_gateway_with_the_correct_data()
{
//arrange
var request = new GetFileRequest
{
bucketName = "testbucket",
fileName = "Test.pdf"
};
//act
await _getFileUsecase.Execute(request);
//assert
_mockGateway.Verify(g => g.DownloadFile(It.Is <GetFileRequest>(obj =>
obj.bucketName == request.bucketName &&
obj.fileName == request.fileName)), Times.Once);
}
async void HandleOutboundFileTransferRequest(object sender, GetFileRequest getFileRequest)
{
// TODO: Create logic to check file transfers that are under lockout and if this request matches remoteserver info + localfilepath, send a new filetranserresponse = rejected_retrylimitexceeded. maybe we should penalize them for trying to subvert our lockout policy?
_eventLog.Add(new ServerEvent
{
EventType = EventType.ReceivedOutboundFileTransferRequest,
RemoteFolder = getFileRequest.RemoteFolderPath,
LocalFolder = getFileRequest.LocalFolderPath,
FileName = getFileRequest.FileName,
RemoteServerIpAddress = getFileRequest.RemoteServerInfo.SessionIpAddress,
RemoteServerPortNumber = getFileRequest.RemoteServerInfo.PortNumber
});
EventOccurred?.Invoke(this, _eventLog.Last());
var handleTransferRequest =
FileTransferHandler.HandleOutboundFileTransferRequest(getFileRequest);
if (handleTransferRequest.Failure)
{
return;
}
var fileTransfer = handleTransferRequest.Value;
var sendFileRequest = new SendFileRequest
{
LocalServerInfo = MyInfo,
RemoteServerInfo = fileTransfer.RemoteServerInfo,
FileName = fileTransfer.FileName,
FileSizeInBytes = fileTransfer.FileSizeInBytes,
RemoteFolderPath = fileTransfer.RemoteFolderPath,
LocalFolderPath = fileTransfer.LocalFolderPath,
FileTransferResponseCode = fileTransfer.TransferResponseCode,
RemoteServerTransferId = fileTransfer.RemoteServerTransferId,
RetryLimit = fileTransfer.RemoteServerRetryLimit,
RetryCounter = fileTransfer.RetryCounter,
Status = RequestStatus.InProgress,
Direction = TransferDirection.Outbound
};
await _requestHandler.SendRequestAsync(sendFileRequest);
SuccessfullyProcessedRequest?.Invoke(this, getFileRequest);
}
void GetFileTest()
{
SearchFileRequest searchFileRequest = new SearchFileRequest()
{
ChannelNo = 0, Beg = new SystemTimeInfo(2017, 7, 4, 8, 0, 0), End = new SystemTimeInfo(2017, 7, 4, 13, 0, 0), Type = 0
};
SearchFileResponse searchFileResponse = m_howell5198client.SearchFile(searchFileRequest);
if (searchFileResponse == null)
{
Console.WriteLine("SearchFile error");
return;
}
Console.WriteLine("searchFileResponse: filecount:{0}", searchFileResponse.FileInfos.Length);
if (searchFileResponse.FileInfos.Length > 0)//搜索到录像文件的话
{
GetFileInfoRequest getFileInfoRequest = new GetFileInfoRequest();
getFileInfoRequest.ChannelNo = searchFileResponse.FileInfos[0].ChannelNo;
getFileInfoRequest.Beg = searchFileResponse.FileInfos[0].Beg;
getFileInfoRequest.End = searchFileResponse.FileInfos[0].End;
GetFileInfoResponse getFileInfoResponse = m_howell5198client.GetFileInfo(getFileInfoRequest);
if (getFileInfoResponse == null)
{
Console.WriteLine("GetFileInfo error");
return;
}
Console.WriteLine("getFileInfoResponse: FileFormatType:{0}", getFileInfoResponse.FileFormatType);
//构建HW头
HW_MediaInfo media = new HW_MediaInfo();
media.Dvr_version = getFileInfoResponse.FileFormatType;
media.Adec_code = getFileInfoResponse.Audio_dec;
media.Vdec_code = getFileInfoResponse.Video_dec;
media.Reserved[0] = (8 << 24) + (8 << 16) + (1 << 8) + 0;//au_bits+au_sampleau_sample+au_channel+reserve
GetFileRequest getFileRequest = new GetFileRequest();
getFileRequest.ChannelNo = searchFileResponse.FileInfos[0].ChannelNo;
getFileRequest.Beg = searchFileResponse.FileInfos[0].Beg;
getFileRequest.End = searchFileResponse.FileInfos[0].End;
getFileRequest.Type = searchFileResponse.FileInfos[0].Type;
Howell5198FileStream filestream = m_howell5198client.GetFile(getFileRequest);
filestream.FileDataReceived += howell5198client_FileDataReceived;
filestream.StartReceive();
Thread.Sleep(1000);
filestream.StopReceive();
}
}
public ActionResult Upload(TestUploadViewModel model)
{
if (model != null && model.File != null)
{
using (var api = ApiFactory.Create())
{
if (model.Type == "file")
{
var uploadRequest = new UploadFileRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Files.Upload.Post(uploadRequest);
var getRequest = new GetFileRequest { FileId = uploadResponse.Data.Value };
var getResponse = api.Media.File.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>File upload successful!</h2> File can be downloaded here: <div><a href='{0}' />{1}</a></div>",
getResponse.Data.FileUrl,
getResponse.Data.Title);
}
else
{
var uploadRequest = new UploadImageRequest();
uploadRequest.Data.FileStream = model.File.InputStream;
uploadRequest.Data.FileName = model.File.FileName;
uploadRequest.Data.WaitForUploadResult = model.Method == "sync";
var uploadResponse = api.Media.Images.Upload.Post(uploadRequest);
var getRequest = new GetImageRequest { ImageId = uploadResponse.Data.Value };
var getResponse = api.Media.Image.Get(getRequest);
model.Result = string.Format(
"<h2 style='color; green'>Image upload successful!</h2> <div><img src='{0}' alt='{1}' /></div>",
getResponse.Data.ImageUrl,
getResponse.Data.Title);
}
}
}
return View(model);
}
public override async Task <WopiResponse> GetFile(GetFileRequest getFileRequest)
{
var userId = WopiSecurity.GetIdentityNameFromToken(getFileRequest.AccessToken);
// Lookup the file in the database
var wopiFileRepository = new WopiFileRepository();
var response = await wopiFileRepository.GetFileContent(getFileRequest.ResourceId, userId);
// Check for null file
if (response.Item1 == HttpStatusCode.NotFound)
{
return(getFileRequest.ResponseNotFound());
}
else
{
// Write the response and return success 200
return(getFileRequest.ResponseOK(new StreamContent(response.Item2), response.Item3));
}
}
public static async Task <File> GetFileAsync(this Telegram telegram, GetFileRequest sendRequest)
{
var result = new File();
var url = telegram.GetFullPathUrl("getFile");
var request = new ExternalRequest <ResponseAnswer <File>, GetFileRequest>()
{
Method = POST_METHOD,
PostContentType = "application/json",
PostContent = sendRequest
};
var response = await RequestSender.Execute(DataAccessMode.Server, request, url).ConfigureAwait(false);
result = response.Result.Result;
return(result);
}
static async Task Main(string[] args)
{
var enrollmentNumber = ConfigurationManager.AppSettings["enrollment"];
var accessToken = ConfigurationManager.AppSettings["token"];
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("text/csv"));
_httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer " + accessToken);
// var responseStream = await _httpClient.GetStreamAsync($"enrollments/{enrollmentNumber}/usagedetails/download?billingPeriod=201902");
// var responseMessage = await _httpClient.GetAsync($"enrollments/{enrollmentNumber}/usagedetails/download?billingPeriod=201902");
// var pipeHttpClient = new PipeHttpClient( );
IPHostEntry ipHostInfo = Dns.GetHostEntry("consumption.azure.com");
using (var clientSocketPipe = await SocketPipe.ConnectAsync(ipHostInfo.HostName, 443, false))
{
var pipeHttpClient = new PipeHttpClient(clientSocketPipe);
// var request = new GetFileRequest($"v3/enrollments/{enrollmentNumber}/usagedetails/download?billingPeriod=201902", accessToken);
var request = new GetFileRequest($"v3/enrollments/{enrollmentNumber}/billingPeriods", accessToken);
try
{
StorageResponse response =
await pipeHttpClient.SendRequest <GetFileRequest, StorageResponse>(request);
if (response.StatusCode != 200)
{
}
}
catch (Exception ex)
{
var msg = ex.Message;
}
//ulong bytesToRead = response.ContentLength;
//using (var file = new FileStream(localFilePath, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.Asynchronous))
//{
// await file.WriteAsync(response.Body, bytesToRead);
//}
}
}
static async ValueTask <bool> CopyStorageFileToLocalFile(StorageClient client, string storagePath, string localFilePath)
{
var request = new GetFileRequest(storagePath);
StorageResponse response = await client.SendRequest(request).ConfigureAwait(false);
if (response.StatusCode != 200)
{
Log.TraceEvent(TraceEventType.Error, 0, "Response Status Code {0}", response.StatusCode);
return(false);
}
ulong bytesToRead = response.ContentLength;
using (var file = new FileStream(localFilePath, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.Asynchronous))
{
await file.WriteAsync(response.Body, bytesToRead);
}
return(true);
}
public GetFileResponse GetFile(GetFileRequest request)
{
var securityContext = OperationContext.Current.ServiceSecurityContext;
if (securityContext != null)
{
s_log.InfoFormat("Request for {0} is served. Requestor identity is {1} ({2})", request.Guid, securityContext.IsAnonymous ? "Anonymous" : securityContext.PrimaryIdentity?.Name, securityContext.PrimaryIdentity?.AuthenticationType);
}
else
{
s_log.InfoFormat("Request for {0} is served. No security context is available", request.Guid);
}
return(new GetFileResponse
{
Content = new MemoryStream(Data.FileContent, false),
FileName = Data.FileName,
MimeType = Data.MimeType,
ModificationTimeStamp = DateTime.Now,
});
}
public override async Task <WopiResponse> GetFile(GetFileRequest getFileRequest)
{
// Lookup the file in the database
var itemId = new Guid(getFileRequest.ResourceId);
var wopiFile = DocumentDBRepository <DetailedFileModel> .GetItem("Files", file => file.id == itemId);
// Check for null file
if (wopiFile != null)
{
// Get discovery information
var fileExt = wopiFile.BaseFileName.Substring(wopiFile.BaseFileName.LastIndexOf('.') + 1).ToLower();
var actions = await WopiDiscovery.GetActions();
// Augments the file with additional properties CloseUrl, HostViewUrl, HostEditUrl
wopiFile.CloseUrl = String.Format("https://{0}", getFileRequest.RequestUri.Authority);
var view = actions.FirstOrDefault(i => i.ext == fileExt && i.name == "view");
if (view != null)
{
wopiFile.HostViewUrl = WopiDiscovery.GetActionUrl(view, wopiFile.id.ToString(), getFileRequest.RequestUri.Authority);
}
var edit = actions.FirstOrDefault(i => i.ext == fileExt && i.name == "edit");
if (edit != null)
{
wopiFile.HostEditUrl = WopiDiscovery.GetActionUrl(edit, wopiFile.id.ToString(), getFileRequest.RequestUri.Authority);
}
// Get the user from the token (token is already validated)
wopiFile.UserId = WopiSecurity.GetUserFromToken(getFileRequest.AccessToken);
// Call the appropriate handler for the WOPI request we received
// Get the file from blob storage
var bytes = await AzureStorageUtil.GetFile(wopiFile.id.ToString(), wopiFile.Container);
// Write the response and return success 200
return(getFileRequest.ResponseOK(new ByteArrayContent(bytes)));
}
else
{
return(getFileRequest.ResponseNotFound());
}
}
//Limit req: value % 1024
public async Task <Upload_fileConstructor> GetFile(InputFileLocation ifl, int size, int limit = 1024)
{
var result = new Upload_fileConstructor();
result.bytes = new byte[size];
GetFileRequest req;
for (int recieved = 0; recieved < size; recieved += req.bytes.Length)
{
req = new GetFileRequest(ifl, recieved, limit);
await _sender.Send(req);
await _sender.Recieve(req);
result.type = req.type;
result.mtime = req.mtime;
req.bytes.CopyTo(result.bytes, recieved);
}
return(result);
}
public ActionResult File(string id)
{
try
{
logger.Info("begin");
GetFileRequest request = new GetFileRequest();
request.UserInfo = NavigationHandler.CurrentUser;
request.IdDoc = id;
request.IdGruppo = NavigationHandler.RuoloInfo.IdGruppo;
request.IdCorrGlobali = NavigationHandler.RuoloInfo.Id;
GetFileResponse response = WSStub.getFile(request);
if (response.Code == GetFileResponseCode.OK)
{
//forza il content-type ad octet-stream se vuoto
if (response.File.ContentType == "")
{
if (response.File.FullName.ToUpper().Contains(".PDF"))
{
response.File.ContentType = "Content-type: application/pdf";
}
else
{
response.File.ContentType = "Content-type: application/octet-stream";
}
}
logger.Info("return doc");
return(File(response.File.Content, response.File.ContentType, response.File.OriginalFileName));
}
else
{
logger.Info("doc not found");
return(View("DocNotFound"));
}
}
catch (Exception e)
{
logger.Error("eccezione: " + e);
return(View("DocNotFound"));
}
}
public IHttpActionResult Get([FromUri] GetFileRequest query)
{
const string downloadKey = "download";
if (query?.Path == null)
{
ModelState.AddModelError("Path", "A value for path is not provided.");
return(BadRequest(ModelState));
}
if (!File.Exists(query.Path))
{
return(NotFound());
}
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StreamContent(File.OpenRead(query.Path))
};
if (Request.QueryString().ContainsKey(downloadKey))
{
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = Path.GetFileName(query.Path)
};
}
else
{
var mediaType = MimeMapping.GetMimeMapping(Path.GetFileName(query.Path) ?? "");
response.Content.Headers.ContentType = new MediaTypeHeaderValue(mediaType);
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("inline")
{
FileName = Path.GetFileName(query.Path)
};
}
return(ResponseMessage(response));
}
public async Task <ServiceResponse <IFile> > GetFile(GetFileRequest request)
{
try
{
var options = (request.IncludeContent.HasValue && request.IncludeContent.Value)
? GetFileOptions.IncludeFileContents
: GetFileOptions.IgnoreFileContents;
if (request.ExcludeTags.HasValue && request.ExcludeTags.Value)
{
options |= GetFileOptions.ExcludeTags;
}
var file = await _fileSystem.GetFile(request.Path, options);
return(new ServiceResponse <IFile>(file));
}
catch (Exception exception)
{
_logger.LogWarning(exception, $"Could not get file: {request.Path}");
return(new ServiceResponse <IFile>(exception));
}
}
public GetFileResponse GetFile([FromBody] GetFileRequest req)
{
if (req == null)
{
throw CreateErrorResponse(1, "empty req");
}
if (req.Size < 1 || req.Size > 1000)
{
throw CreateErrorResponse(2, "invalid size");
}
var body = new byte[req.Size];
new Random().NextBytes(body);
return(new GetFileResponse
{
Name = req.FileName,
Body = body,
MD5 = MD5.Create().ComputeHash(body),
DT = DateTime.UtcNow
});
}
public async Task <ActionResult <GetFileResponse> > GetFile([FromRoute] GetFileRequest request)
{
try
{
if (request == null)
{
return(BadRequest());
}
var response = await _getFile.Execute(request);
return(Ok(response));
}
catch (AmazonS3Exception ex)
{
if (ex.ErrorCode == "NoSuchKey" || ex.ErrorCode == "NoSuchBucket")
{
return(NotFound(new ErrorsResponse(ex.Message)));
}
return(StatusCode(500, new ErrorsResponse(ex.Message)));
}
}
public async Task <WorkspaceFile> GetFileAsync(
GetFileRequest request,
CancellationToken cancellationToken)
{
var file = new FileInfo(request.FileName);
string contentType;
if (!_contentTypeProvider.TryGetContentType(file.Name, out contentType))
{
contentType = "application/octet-stream";
}
FileEditorInfo meta = GetEditorInfo(file);
var wsFile = new WorkspaceFile(
file.Name,
file.FullName,
contentType)
{
Meta = meta
};
var options = new HandleFileOptions(request.Converter);
foreach (IFileContentTypeHandler handler in _fileHandlers)
{
if (handler.CanHandle(wsFile, options))
{
await handler.HandleAsync(wsFile, options, cancellationToken);
break;
}
}
return(wsFile);
}
// execute get file request
static async Task GetFile(string fname, NetworkStream stream)
{
// create the request message
GetFileRequest request = new GetFileRequest(fname);
// send the message to the server
await MessageUtils.SendMsg(request, stream);
// wait for and read the response
GetFileResponse response = await MessageUtils.RecvMsg(stream) as GetFileResponse;
if (response == null)
{
Console.WriteLine("+++ Client: wrong response from server: {0}", response);
return;
}
if (response.IsOK)
{
try
{
var file = new FileStream(@"tmp\" + fname, FileMode.OpenOrCreate);
await MessageUtils.ReceiveFile(stream, file, cts.Token);
Console.WriteLine("+++ Client: file written to: {0}", @"tmp\" + fname);
}
catch (IOException ex)
{
Console.WriteLine("+++ Client: I/O exception: {0}", ex.Message);
}
catch (OperationCanceledException)
{
Console.WriteLine("+++ Client: File Copy Cancelled");
}
}
else
{
Console.WriteLine("+++ Client: receive file error: {0}", response.ResultMsg);
}
}
public GetFileResponse Get(GetFileRequest request)
{
var model = repository
.AsQueryable<MediaFile>()
.Where(media => media.Id == request.FileId && media.Type == MediaType.File)
.Select(media => new FileModel
{
Id = media.Id,
Version = media.Version,
CreatedBy = media.CreatedByUser,
CreatedOn = media.CreatedOn,
LastModifiedBy = media.ModifiedByUser,
LastModifiedOn = media.ModifiedOn,
Title = media.Title,
Description = media.Description,
FileExtension = media.OriginalFileExtension,
FileSize = media.Size,
FileUrl = fileUrlResolver.EnsureFullPathUrl(media.PublicUrl),
IsArchived = media.IsArchived,
FolderId = media.Folder != null && !media.Folder.IsDeleted ? media.Folder.Id : (Guid?)null,
FolderName = media.Folder != null && !media.Folder.IsDeleted ? media.Folder.Title : null,
PublishedOn = media.PublishedOn,
OriginalFileName = media.OriginalFileName,
OriginalFileExtension = media.OriginalFileExtension,
ThumbnailId = media.Image != null && !media.Image.IsDeleted ? media.Image.Id : (Guid?)null,
ThumbnailCaption = media.Image != null && !media.Image.IsDeleted ? media.Image.Caption : null,
ThumbnailUrl = media.Image != null && !media.Image.IsDeleted ? media.Image.PublicThumbnailUrl : null
})
.FirstOne();
model.FileUrl = fileService.GetDownloadFileUrl(MediaType.File, model.Id, model.FileUrl);
model.ThumbnailUrl = fileUrlResolver.EnsureFullPathUrl(model.ThumbnailUrl);
IList<TagModel> tags;
if (request.Data.IncludeTags)
{
tags =
repository.AsQueryable<MediaTag>(mediaTag => mediaTag.Media.Id == request.FileId && !mediaTag.Tag.IsDeleted)
.OrderBy(mediaTag => mediaTag.Tag.Name)
.Select(media => new TagModel
{
Id = media.Tag.Id,
Version = media.Tag.Version,
CreatedBy = media.Tag.CreatedByUser,
CreatedOn = media.Tag.CreatedOn,
LastModifiedBy = media.Tag.ModifiedByUser,
LastModifiedOn = media.Tag.ModifiedOn,
Name = media.Tag.Name
})
.ToList();
}
else
{
tags = null;
}
return new GetFileResponse
{
Data = model,
Tags = tags
};
}
public GetFileResponse GetFile(GetFileRequest getFileRequest)
{
return GetFileResponse.Parse(ExecuteAction(getFileRequest));
}
/// <summary>
/// Gets the specified file.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>GetFileRequest</c> with an file.
/// </returns>
public GetFileResponse Get(GetFileRequest request)
{
var model = repository
.AsQueryable<MediaFile>()
.Where(media => media.Id == request.FileId && media.Type == Module.MediaManager.Models.MediaType.File)
.Select(media => new
{
Model = new FileModel
{
Id = media.Id,
Version = media.Version,
CreatedBy = media.CreatedByUser,
CreatedOn = media.CreatedOn,
LastModifiedBy = media.ModifiedByUser,
LastModifiedOn = media.ModifiedOn,
Title = media.Title,
Description = media.Description,
FileExtension = media.OriginalFileExtension,
FileSize = media.Size,
IsArchived = media.IsArchived,
FolderId = media.Folder != null && !media.Folder.IsDeleted ? media.Folder.Id : (Guid?)null,
FolderName = media.Folder != null && !media.Folder.IsDeleted ? media.Folder.Title : null,
PublishedOn = media.PublishedOn,
OriginalFileName = media.OriginalFileName,
OriginalFileExtension = media.OriginalFileExtension,
ThumbnailId = media.Image != null && !media.Image.IsDeleted ? media.Image.Id : (Guid?)null,
ThumbnailCaption = media.Image != null && !media.Image.IsDeleted ? media.Image.Caption : null,
ThumbnailUrl = media.Image != null && !media.Image.IsDeleted ? media.Image.PublicThumbnailUrl : null,
FileUrl = media.PublicUrl,
IsUploaded = media.IsUploaded,
IsTemporary = media.IsTemporary,
IsCanceled = media.IsCanceled
},
FileUri = media.FileUri,
})
.FirstOne();
model.Model.FileUrl = fileService.GetDownloadFileUrl(Module.MediaManager.Models.MediaType.File, model.Model.Id, model.Model.FileUrl);
model.Model.ThumbnailUrl = fileUrlResolver.EnsureFullPathUrl(model.Model.ThumbnailUrl);
model.Model.FileUrl = fileUrlResolver.EnsureFullPathUrl(model.Model.FileUrl);
model.Model.FileUri = model.FileUri.ToString();
IEnumerable<TagModel> tagsFuture;
if (request.Data.IncludeTags)
{
tagsFuture =
repository.AsQueryable<MediaTag>(mediaTag => mediaTag.Media.Id == request.FileId && !mediaTag.Tag.IsDeleted)
.OrderBy(mediaTag => mediaTag.Tag.Name)
.Select(media => new TagModel
{
Id = media.Tag.Id,
Version = media.Tag.Version,
CreatedBy = media.Tag.CreatedByUser,
CreatedOn = media.Tag.CreatedOn,
LastModifiedBy = media.Tag.ModifiedByUser,
LastModifiedOn = media.Tag.ModifiedOn,
Name = media.Tag.Name
})
.ToFuture();
}
else
{
tagsFuture = null;
}
IEnumerable<AccessRuleModel> accessRulesFuture;
if (request.Data.IncludeAccessRules)
{
accessRulesFuture = (from file in repository.AsQueryable<MediaFile>()
from accessRule in file.AccessRules
where file.Id == request.FileId
orderby accessRule.IsForRole, accessRule.Identity
select
new AccessRuleModel
{
AccessLevel = (AccessLevel)(int)accessRule.AccessLevel,
Identity = accessRule.Identity,
IsForRole = accessRule.IsForRole
})
.ToList();
}
else
{
accessRulesFuture = null;
}
if (request.Data.IncludeCategories)
{
model.Model.Categories = (from media in repository.AsQueryable<MediaFile>()
from category in media.Categories
where media.Id == model.Model.Id && !category.IsDeleted
select new CategoryNodeModel
{
Id = category.Category.Id,
Version = category.Version,
CreatedBy = category.CreatedByUser,
CreatedOn = category.CreatedOn,
LastModifiedBy = category.ModifiedByUser,
LastModifiedOn = category.ModifiedOn,
Name = category.Category.Name,
CategoryTreeId = category.Category.CategoryTree.Id
}).ToList();
}
return new GetFileResponse
{
Data = model.Model,
Tags = tagsFuture != null ? tagsFuture.ToList() : null,
AccessRules = accessRulesFuture != null ? accessRulesFuture.ToList() : null
};
}
