public void UploadFile(UploadFileRequest request)
{
using (ClientContext context = SignIn(request.ServerProperties))
{
using (WebClient client = new WebClient())
{
using (Stream uriStream = client.OpenRead(request.FileUri))
{
try
{
Microsoft.SharePoint.Client.List root = context.Web.Lists.GetByTitle(SharedDocumentsList);
string name = request.Name;
if (request.FolderUri != null && !string.IsNullOrWhiteSpace(request.FolderUri.ToString()))
{
name = request.FolderUri.ToString() + "/" + request.Name;
}
string uploadUri = GetCombinedPath(context, root, name);
Microsoft.SharePoint.Client.File.SaveBinaryDirect(context, uploadUri, uriStream, true);
context.ExecuteQuery();
}
catch
{
throw;
}
}
}
}
}
public async Task <IActionResult> UploadFile(Resources resources)
{
UploadFileRequest request = new UploadFileRequest();
request.FileName = resources.FileName;
string fileName = Path.GetFileNameWithoutExtension(resources.ImagePath.FileName);
string extension = Path.GetExtension(resources.ImagePath.FileName);
// fileName = fileName + DateTime.Now.ToString("yymmssfff") + extension;
fileName = fileName + extension;
Console.WriteLine(fileName);
var currentuser = context.User.SingleOrDefault(x => x.Email == User.Identity.Name);
request.FilePath = "D:\\00\\" + fileName;
resources.SubjectId = 1;
resources.UserId = currentuser.Id;
//upload file on azure
await service.UploadFileBlobAsync(request.FilePath, request.FileName);
//save file data in db
context.Add(resources);
await context.SaveChangesAsync();
return(RedirectToAction("ListResources", "Resources"));
}
public ActionResult Post([FromForm] UploadFileRequest model)
{
var folder = Path.GetTempPath();
var totalSize = 0L;
var resultFiles = new Dictionary <string, string>(model.Files.Count());
foreach (var file in model.Files)
{
if (file.Length <= 0)
{
continue;
}
var code = $"{DateTime.UtcNow:yyyyMMddhhmmss}-{Guid.NewGuid():N}";
var(path, meta) = BuildFilePaths(folder, code);
SaveFile(file, path);
SaveMetadataFile(meta, new FileMetadata
{
ContentType = file.ContentType,
FileName = file.FileName,
Length = file.Length,
Tag = model.Tag
});
resultFiles.Add(code, file.FileName);
totalSize += file.Length;
}
return(Ok(new UploadFileResponse {
TotalSize = totalSize,
Files = resultFiles
}));
}
public bool Upload([FromForm] UploadFileRequest request)
{
try
{
logger.LogInformation($"Got request to upload file, {request.Path}, saving to {contentPath + Path.GetDirectoryName(request.Path)}");
request.Path = request.Path.Replace('\\', '/');
Directory.CreateDirectory(contentPath + Path.GetDirectoryName(request.Path));
using (var fs = new FileStream(contentPath + request.Path, FileMode.Create))
{
request.file.CopyTo(fs);
}
return(true);
}
catch
{
logger.LogError($"Someone failed to upload a file. Path was: {request.Path}");
if (System.IO.File.Exists(contentPath + request.Path))
{
System.IO.File.Delete(contentPath + request.Path);
}
return(false);
}
}
public async Task <IActionResult> UploadFile([FromForm] UploadFileRequest request,
[FromForm] IFormCollection formCollection,
CancellationToken cancellationToken)
{
IFormFile file = formCollection.Files.First();
String temporaryFileLocation = ConfigurationReader.GetValue("AppSettings", "TemporaryFileLocation");
String fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
String fullPath = Path.Combine(temporaryFileLocation, fileName);
using (FileStream stream = new FileStream(fullPath, FileMode.Create))
{
await file.CopyToAsync(stream, cancellationToken);
}
if (request.UploadDateTime == DateTime.MinValue)
{
request.UploadDateTime = DateTime.Now;
}
// Create a command with the file in it
BusinessLogic.Requests.UploadFileRequest uploadFileRequest =
new BusinessLogic.Requests.UploadFileRequest(request.EstateId, request.MerchantId, request.UserId, fullPath, request.FileProfileId, request.UploadDateTime);
Guid fileId = await this.Mediator.Send(uploadFileRequest, cancellationToken);
Shared.Logger.Logger.LogDebug($"Day is {request.UploadDateTime.Day}");
Shared.Logger.Logger.LogDebug($"Month is {request.UploadDateTime.Month}");
Shared.Logger.Logger.LogDebug($"Year is {request.UploadDateTime.Year}");
return(this.Accepted(fileId));
}
/// <summary>载入上传的第一个文件流</summary>
protected async Task <UploadFileRequest> LoadFileStreamFirstOrDefault(string uploadPath)
{
var request = new UploadFileRequest();
var httpContent = this.Request.Content;
if (httpContent.IsMimeMultipartContent())
{
var provider = await httpContent.ReadAsMultipartAsync(new MultipartFormDataStreamProvider(uploadPath));
var fileData = provider.FileData.First();
request.FileName = fileData.Headers.ContentDisposition.FileName.Divest();
request.ServerFile = fileData.LocalFileName;
var formData = provider.FormData;
if (request.FileName.IsNullOrEmpty())
{
request.FileName = formData[nameof(request.FileName)];
}
var formDataValue = formData[nameof(request.EnablePattern)];
if (formDataValue != null)
{
request.EnablePattern = bool.Parse(formDataValue);
}
}
return(request);
}
public ActionResult UploadMedia(HttpPostedFileBase file)
{
var rootFolderId = Request.Form["rootFolderId"].ToGuidOrDefault();
var rootFolderType = (MediaType)Enum.Parse(typeof(MediaType), Request.Form["rootFolderType"]);
if (file != null && FileFormatIsValid(rootFolderType, file.ContentType))
{
UploadFileRequest request = new UploadFileRequest
{
RootFolderId = rootFolderId,
Type = rootFolderType,
FileLength = file.ContentLength,
FileName = file.FileName,
FileStream = file.InputStream
};
var media = GetCommand <UploadCommand>().ExecuteCommand(request);
if (media != null)
{
return(WireJson(true, new
{
FileId = media.Id,
Version = media.Version,
Type = (int)rootFolderType,
IsProcessing = !media.IsUploaded.HasValue,
IsFailed = media.IsUploaded == false,
}));
}
}
return(Json(new WireJson(false)));
}
public async Task <IActionResult> UploadFile([FromForm] UploadFileRequest request)
{
if (request.file.Length > 1024 * 1024 * MaxFileLengthMB)
{
return(BadRequest(new ResponseApiModel <MessageAttachment>
{
ErrorMessage = $"File was larger than {MaxFileLengthMB} Mb",
IsSuccessfull = false
}));
}
var thisUserId = ClaimsExtractor.GetUserIdClaim(User.Claims);
try
{
var savedFile = await filesService.SaveMessageFile(request.file, request.file.FileName,
request.ChatId, thisUserId);
return(Ok(new ResponseApiModel <MessageAttachment>
{
IsSuccessfull = true,
Response = savedFile
}));
}
catch (Exception ex)
{
return(BadRequest(new ResponseApiModel <MessageAttachment>
{
IsSuccessfull = false,
ErrorMessage = "Failed to upload. Exception type: " + ex.GetType().Name
}));
}
}
public async Task UploadLeftRightAndThenCompare_WithKnownDifference_ExpectedDifferenceIsReported()
{
// Prepare data
var binaryLeft = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
var binaryRight = new byte[] { 11, 2, 3, 14, 15, 6, 7, 8, 9, 0 };
// Upload
var requestLeft = new UploadFileRequest {
Data = Convert.ToBase64String(binaryLeft)
};
var requestRight = new UploadFileRequest {
Data = Convert.ToBase64String(binaryRight)
};
await PutAsync($"{baseUrl}/diff/{id}/left", requestLeft);
await PutAsync($"{baseUrl}/diff/{id}/right", requestRight);
// Query for difference
var diff = await GetAsync($"{baseUrl}/diff/{id}");
// Assert
diff.Result.Should().Be("different");
diff.Differences.ShouldBeEquivalentTo(new[]
{
new Difference(startIndex: 0, length: 1),
new Difference(startIndex: 3, length: 2)
});
}
public Stream Convert(Stream file, string fileName, string toFormat)
{
UploadFileRequest uploadFileRequest = new UploadFileRequest()
{
Path = fileName,
File = file
};
CadCloudApi.UploadFile(uploadFileRequest);
GetDrawingSaveAsRequest getDrawingSaveAsRequest = new GetDrawingSaveAsRequest()
{
Name = fileName,
OutputFormat = toFormat
};
var convertResult = CadCloudApi.GetDrawingSaveAs(getDrawingSaveAsRequest);
DeleteFileRequest deleteFileRequest = new DeleteFileRequest()
{
Path = fileName
};
CadCloudApi.DeleteFile(deleteFileRequest);
return(convertResult);
}
public static void UploadPdf(this FileManagerClient _fileManagerClient, ILogger _logger, string entityName, string entityId, string folderName, string filename, byte[] data)
{
Contract.Requires(_fileManagerClient != null);
// call the web service
var uploadRequest = new UploadFileRequest
{
ContentType = "application/pdf",
Data = ByteString.CopyFrom(data),
EntityName = entityName,
FileName = filename,
FolderName = folderName
};
var uploadResult = _fileManagerClient.UploadFile(uploadRequest);
// Do not save full file names to the logs (for privacy)
var logFolderName = WordSanitizer.Sanitize(folderName);
var logFileName = WordSanitizer.Sanitize(filename);
if (uploadResult.ResultStatus == ResultStatus.Success)
{
_logger.LogInformation($"SUCCESS in uploading PDF file {logFileName} to folder {logFolderName}");
}
else
{
_logger.LogError($"ERROR in uploading PDF file {logFileName} to folder {logFolderName}");
throw new Exception($"ERROR in uploading PDF file {logFileName} to folder {logFolderName}");
}
}
public async Task UploadFile_When_Success_Using_Another_User_Returns_PathFile(string pathFile)
{
var fixture = new Fixture();
var idUser = fixture.Create <string>();
var url = $"http://localhost/{idUser}";
_httpClient.DefaultRequestHeaders.Add("Authorization",
$"Bearer {TestsHelper.GetAnotherUserAuthenticationToken(idUser)}");
var uploadFileRequest = new UploadFileRequest
{
PathFile = pathFile,
Content = fixture.Create <byte[]>()
};
_amazonS3.Setup(s => s.PutObjectAsync(It.IsAny <PutObjectRequest>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new PutObjectResponse {
});
var result = await _httpClient.PostAsync(url, CreateUploadFileRequestContent(uploadFileRequest));
Assert.NotNull(result);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
var resultContent = await result.Content.ReadAsStringAsync();
Assert.Equal($"/{ROOT_FOLDER}/{idUser}{uploadFileRequest.PathFile}", resultContent);
}
public override Task <UploadFileReply> UploadFile(UploadFileRequest request, ServerCallContext context)
{
var result = new UploadFileReply();
string logFileName = WordSanitizer.Sanitize(request.FileName);
string logFolderName = WordSanitizer.Sanitize(request.FolderName);
SharePointFileManager _sharePointFileManager = new SharePointFileManager(_configuration);
CreateDocumentLibraryIfMissing(GetDocumentListTitle(request.EntityName), GetDocumentTemplateUrlPart(request.EntityName));
try
{
string fileName = _sharePointFileManager.AddFile(GetDocumentTemplateUrlPart(request.EntityName),
request.FolderName,
request.FileName,
request.Data.ToByteArray(), request.ContentType).GetAwaiter().GetResult();
result.FileName = fileName;
result.ResultStatus = ResultStatus.Success;
}
catch (SharePointRestException ex)
{
result.ResultStatus = ResultStatus.Fail;
result.ErrorDetail = $"ERROR in uploading file {logFileName} to folder {logFolderName}";
_logger.LogError(ex, result.ErrorDetail);
}
catch (Exception e)
{
result.ResultStatus = ResultStatus.Fail;
result.ErrorDetail = $"ERROR in uploading file {logFileName} to folder {logFolderName}";
_logger.LogError(e, result.ErrorDetail);
}
return(Task.FromResult(result));
}
public async Task <IActionResult> Upload(UploadFileRequest request)
{
// upload pbix
await _workspaceService.Upload(request.GroupId, request.DatasetName, request.FilePath, request.Overwrite);
return(Ok());
}
/// <summary>
/// Upload file from the stream.
/// </summary>
/// <param name="request">The upload file request.</param>
/// <returns>The upload file response.</returns>
public UploadFileResponse Post(UploadFileRequest 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();
}
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 savedFile = mediaFileService.UploadFile(
Module.MediaManager.Models.MediaType.File,
parentFolder != null ? parentFolder.Id : Guid.Empty,
request.Data.FileName,
request.Data.FileStream.Length,
request.Data.FileStream,
false);
return(new UploadFileResponse
{
Data = savedFile.Id
});
}
public async Task UploadFile_When_File_Already_Exist_And_Not_Override_Returns_BadRequest_With_Error_Message()
{
var fixture = new Fixture();
var url = $"http://localhost";
_httpClient.DefaultRequestHeaders.Add("Authorization",
$"Bearer {TestsHelper.GetSuperUserAuthenticationToken()}");
var uploadFileRequest = new UploadFileRequest
{
PathFile = $"/{fixture.Create<string>()}.png",
Override = false,
Content = fixture.Create <byte[]>()
};
_amazonS3.Setup(s => s.GetObjectAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetObjectResponse
{
Key = $"/{ROOT_FOLDER}{uploadFileRequest.PathFile}"
});
var result = await _httpClient.PostAsync(url, CreateUploadFileRequestContent(uploadFileRequest));
Assert.NotNull(result);
Assert.Equal(HttpStatusCode.BadRequest, result.StatusCode);
var resultContent = await result.Content.ReadAsStringAsync();
Assert.Equal(StorageProviderError.FileAlreadyExist.ToString(), resultContent.Replace("\"", string.Empty));
}
public UploadFileResponse SendUploadFileRequest(UploadFileRequest request)
{
UploadFileResponse response = new UploadFileResponse();
var rpcClient = new XmlRpcRestClient(config.RequestUrl);
var rpcRequest = new XmlRpcRestRequest(request.RequestUrl)
{
Method = Method.POST
};
// Add request parameters
//rpcRequest.XmlSerializer = new XmlRpcSerializer("",false);
rpcRequest.AddXmlRpcBody(config.BlogID, config.Username, config.Password, request.FileRequestStruct, "true", "false");
try
{
// Get response
var rpcResponse = rpcClient.Execute <RpcResponseValue <string> >(rpcRequest);
// Find and fill members in
XmlMemberSearcher searcher = new XmlMemberSearcher(rpcResponse.Content);
response.FileResponseStruct.Id = Convert.ToInt32(searcher.GetValueOfMember("id"));
response.FileResponseStruct.Url = searcher.GetValueOfMember("url");
response.FileResponseStruct.File = searcher.GetValueOfMember("file");
response.FileResponseStruct.FileType = searcher.GetValueOfMember("type");
}
catch (Exception e)
{
Console.WriteLine(e);
return(null);
}
return(response);
}
public async Task <ActionResult <UploadFileResponse> > PostAsync([FromForm] UploadFileRequest request)
{
var fileId = Guid.NewGuid();
var finalFileName = Path.Combine(directory, $"{fileId}.file");
var finalMedataFileName = Path.Combine(directory, $"{fileId}.json");
var postedFile = request.File;
using (var file = postedFile.OpenReadStream())
using (var fileData = System.IO.File.Create(finalFileName))
{
await file.CopyToAsync(fileData);
}
using (var metadataFile = System.IO.File.CreateText(finalMedataFileName))
{
var metadata = new MetadataFile {
FileName = postedFile.FileName,
ContentType = postedFile.ContentType,
Length = postedFile.Length
};
var serializer = new JsonSerializer();
serializer.Serialize(metadataFile, metadata);
}
return(new UploadFileResponse {
FileId = fileId
});
}
public Stream Convert(Stream file, string fileName, string toFormat)
{
UploadFileRequest uploadFileRequest = new UploadFileRequest()
{
path = fileName,
File = file
};
ImagingCloudApi.UploadFile(uploadFileRequest);
var request = new ConvertImageRequest()
{
name = fileName,
format = toFormat
};
var convertResult = ImagingCloudApi.ConvertImage(request);
DeleteFileRequest deleteFileRequest = new DeleteFileRequest()
{
path = fileName
};
ImagingCloudApi.DeleteFile(deleteFileRequest);
return(convertResult);
}
private async Task <Guid> UploadFile(Table table)
{
var row = table.Rows.First();
String merchantName = SpecflowTableHelper.GetStringRowValue(row, "MerchantName");
String fileProfileId = SpecflowTableHelper.GetStringRowValue(row, "FileProfileId");
String userId = SpecflowTableHelper.GetStringRowValue(row, "UserId");
String uploadDateTime = SpecflowTableHelper.GetStringRowValue(row, "UploadDateTime");
var estate = this.TestingContext.GetEstateDetails(row);
Guid estateId = estate.EstateId;
var merchantId = estate.GetMerchantId(merchantName);
String filePath = this.TestingContext.UploadFile;
var fileData = await File.ReadAllBytesAsync(filePath);
UploadFileRequest uploadFileRequest = new UploadFileRequest
{
EstateId = estateId,
FileProfileId = Guid.Parse(fileProfileId),
MerchantId = merchantId,
UserId = Guid.Parse(userId),
};
if (String.IsNullOrEmpty(uploadDateTime) == false)
{
uploadFileRequest.UploadDateTime = SpecflowTableHelper.GetDateForDateString(uploadDateTime, DateTime.Now);
}
var fileId = await this.TestingContext.DockerHelper.FileProcessorClient.UploadFile(this.TestingContext.AccessToken,
Path.GetFileName(filePath),
fileData,
uploadFileRequest,
CancellationToken.None);
return(fileId);
}
//public StandardResponse upload(FileInfo rawFile, String filename, String signature, long fileSize, String uploadType)
public StandardResponse Upload(FileInfo rawFile, UploadFileRequest requestData, string filename, long uploadedSoFar, long fullFillSize)
{
using var fileStream = rawFile.OpenRead();
using var progressStream = new ProgressStream(fileStream, _progress, "Uploading", fullFillSize, uploadedSoFar);
var uploadedBytes = UploadSegment(progressStream, requestData, filename, rawFile.Length);
return(_response);
}
public async Task <IActionResult> Produce(UploadFileRequest request)
{
var validatorActionResult = await _validationArrangement.Validate(request);
var actionResult = await _operationArrangement.Process(request, validatorActionResult);
return(actionResult);
}
/// <summary>
/// Uploads file to storage.
/// </summary>
/// <param name="path">Path in storage.</param>
/// <param name="versionId">Api version.</param>
/// <param name="storage">Storage.</param>
/// <param name="fileContent">File content.</param>
protected void UploadFileToStorage(string path, string versionId, string storage, byte[] fileContent)
{
using (var ms = new MemoryStream(fileContent))
{
var request = new UploadFileRequest(ms, path);
this.AssemblyApi.UploadFile(request);
}
}
public async Task <IActionResult> Upload([FromQuery] UploadFileFromQuery query,
[FromForm] UploadFileFromForm body)
{
var request = new UploadFileRequest(query, body);
var result = await _apiResult.Produce(request);
return(result);
}
/// <summary>上传文件
/// </summary>
/// <param name="assignFileKey">文件Fid</param>
/// <param name="writer">文件写入方法</param>
/// <param name="fileName">文件名</param>
/// <param name="contentLength">文件长度</param>
/// <returns><see cref="Seaweedfs.Client.Rest.UploadFileResponse"/></returns>
public async Task <UploadFileResponse> UploadFile(AssignFileKey assignFileKey, Action <Stream> writer, string fileName, long contentLength)
{
var request = new UploadFileRequest(assignFileKey.Fid, writer, fileName, contentLength)
{
AssignServer = assignFileKey.Url
};
return(await UploadInternal(assignFileKey, request));
}
/// <summary>上传文件
/// </summary>
/// <param name="assignFileKey">文件Fid</param>
/// <param name="fileBytes">文件二进制</param>
/// <param name="fileName">文件名</param>
/// <returns><see cref="Seaweedfs.Client.Rest.UploadFileResponse"/></returns>
public async Task <UploadFileResponse> UploadFile(AssignFileKey assignFileKey, byte[] fileBytes, string fileName)
{
var request = new UploadFileRequest(assignFileKey.Fid, fileBytes, fileName)
{
AssignServer = assignFileKey.Url
};
return(await UploadInternal(assignFileKey, request));
}
private ByteArrayContent CreateUploadFileRequestContent(UploadFileRequest uploadFileRequest)
{
var buffer = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(uploadFileRequest));
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(byteContent);
}
/// <summary>
/// Uploads the file to cloud.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="fileContent">The file content.</param>
private void UploadToCloud(string fileName, Stream fileContent)
{
var uploadFileRequest = new UploadFileRequest(fileName, fileContent);
var result = ImagingApi.UploadFile(uploadFileRequest);
Console.WriteLine(result.Errors?.Count > 0
? $"Uploading errors count: {result.Errors.Count}"
: $"File {fileName} is uploaded to cloud storage");
}
/// <summary>
/// Upload file from the stream.
/// </summary>
/// <param name="request">The upload file request.</param>
/// <returns>The upload file response.</returns>
public UploadFileResponse Post(UploadFileRequest request)
{
MediaFolder parentFolder = null;
if (request.Data.FolderId.HasValue)
{
parentFolder = repository.AsQueryable<MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.FirstOne();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.File)
{
throw new CmsApiValidationException("Folder must be type of an file.");
}
}
var maxLength = configuration.Storage.MaximumFileNameLength > 0 ? configuration.Storage.MaximumFileNameLength : 100;
// Fix for IIS express + IE (if full path is returned)
var fileName = Path.GetFileName(request.Data.FileName);
if (fileName.Length > maxLength)
{
fileName = string.Concat(Path.GetFileNameWithoutExtension(fileName.Substring(0, maxLength)), Path.GetExtension(fileName));
}
var savedFile = mediaFileService.UploadFileWithStream(
Module.MediaManager.Models.MediaType.File,
parentFolder != null ? parentFolder.Id : Guid.Empty,
fileName,
request.Data.FileStream.Length,
request.Data.FileStream,
request.Data.WaitForUploadResult,
request.Data.Title,
request.Data.Description);
if (savedFile != null)
{
if (request.Data.AccessRules != null)
{
if (savedFile.AccessRules != null)
{
savedFile.AccessRules.RemoveDuplicateEntities();
}
var accessRules =
request.Data.AccessRules.Select(
r => (IAccessRule)new AccessRule { AccessLevel = (AccessLevel)(int)r.AccessLevel, Identity = r.Identity, IsForRole = r.IsForRole })
.ToList();
accessControlService.UpdateAccessControl(savedFile, accessRules);
mediaFileService.SaveMediaFile(savedFile);
}
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(savedFile);
}
return new UploadFileResponse
{
Data = savedFile.Id
};
}
/// <summary>
/// Uploads the image to cloud.
/// </summary>
/// <param name="imageName">Name of the image.</param>
/// <param name="image">The image.</param>
protected void UploadImageToCloud(string imageName, Stream image)
{
var uploadFileRequest = new UploadFileRequest(Path.Combine(CloudPath, imageName), image);
var result = ImagingApi.UploadFile(uploadFileRequest);
Console.WriteLine(result.Errors?.Count > 0
? $"Uploading errors count: {result.Errors.Count}"
: $"Image {imageName} is uploaded to cloud storage");
}
/// <summary>
/// Upload file
/// </summary>
/// <param name="request">Request. <see cref="UploadFileRequest" /></param>
/// <returns><see cref="FilesUploadResult"/></returns>
public FilesUploadResult UploadFile(UploadFileRequest request)
{
// verify the required parameter 'path' is set
if (request.path == null)
{
throw new ApiException(400, "Missing required parameter 'path' when calling UploadFile");
}
// verify the required parameter 'file' is set
if (request.File == null)
{
throw new ApiException(400, "Missing required parameter 'file' when calling UploadFile");
}
// create path and map variables
var resourcePath = this.configuration.GetApiRootUrl() + "/ocr/storage/file/{path}";
resourcePath = Regex
.Replace(resourcePath, "\\*", string.Empty)
.Replace("&", "&")
.Replace("/?", "?");
var formParams = new Dictionary <string, object>();
resourcePath = UrlHelper.AddPathParameter(resourcePath, "path", request.path);
resourcePath = UrlHelper.AddQueryParameterToUrl(resourcePath, "storageName", request.storageName);
if (request.File != null)
{
formParams.Add("file", this.apiInvoker.ToFileInfo(request.File, "File"));
}
try
{
var response = this.apiInvoker.InvokeApi(
resourcePath,
"PUT",
null,
null,
formParams);
if (response != null)
{
return((FilesUploadResult)SerializationHelper.Deserialize(response, typeof(FilesUploadResult)));
}
return(null);
}
catch (ApiException ex)
{
if (ex.ErrorCode == 404)
{
return(null);
}
throw;
}
}
/// <summary>
/// Upload file from the stream.
/// </summary>
/// <param name="request">The upload file request.</param>
/// <returns>The upload file response.</returns>
public UploadFileResponse Post(UploadFileRequest request)
{
MediaFolder parentFolder = null;
if (request.Data.FolderId.HasValue)
{
parentFolder = repository.AsQueryable<MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.FirstOne();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.File)
{
throw new CmsApiValidationException("Folder must be type of an file.");
}
}
var savedFile = mediaFileService.UploadFileWithStream(
Module.MediaManager.Models.MediaType.File,
parentFolder != null ? parentFolder.Id : Guid.Empty,
request.Data.FileName,
request.Data.FileStream.Length,
request.Data.FileStream,
request.Data.WaitForUploadResult,
request.Data.Title,
request.Data.Description);
if (savedFile != null)
{
if (request.Data.AccessRules != null)
{
if (savedFile.AccessRules != null)
{
savedFile.AccessRules.RemoveDuplicateEntities();
}
var accessRules =
request.Data.AccessRules.Select(
r => (IAccessRule)new AccessRule { AccessLevel = (AccessLevel)(int)r.AccessLevel, Identity = r.Identity, IsForRole = r.IsForRole })
.ToList();
accessControlService.UpdateAccessControl(savedFile, accessRules);
mediaFileService.SaveMediaFile(savedFile);
}
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(savedFile);
}
return new UploadFileResponse
{
Data = savedFile.Id
};
}
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);
}
private bool uploadFile(frmLMSMain sender, HttpRequestMessageProperty httpRequest, string jobID, string fileRefID, string fileName)
{
sender.UploadStatus += "\n\nUploading the request file.\n";
try
{
FileTransferServicePortClient client = new FileTransferServicePortClient(FTconfigName);
using (OperationContextScope scope = new OperationContextScope(client.InnerChannel))
{
OperationContext.Current.OutgoingMessageProperties.Add(HttpRequestMessageProperty.Name, httpRequest);
UploadFileRequest uploadReq = new UploadFileRequest();
uploadReq.fileAttachment = getFileAttachment(fileName);
uploadReq.fileReferenceId = fileRefID;
uploadReq.taskReferenceId = jobID;
uploadReq.fileFormat = "gzip";
UploadFileResponse uploadResponse = client.uploadFile(uploadReq);
if (uploadResponse.ack.ToString().Equals("Success"))
{
sender.UploadStatus += uploadResponse.timestamp + " :: " + fileName + " has been successfully uploaded to the server.\n";
return true;
}
else
{
sender.UploadStatus += uploadResponse.timestamp + " :: " + "Could not upload file to Server\n";
if (uploadResponse.errorMessage != null)
{
ErrorAdmin.updateResponseStatus(uploadResponse, sender, true);
}
return false;
}
}
}
catch (Exception ex)
{
sender.UploadStatus += ex + "\n";
return false;
}
}
public async Task<int?> UploadPrivateImageAsync(byte[] imageBytes)
{
var createFileRequest = new CreateFileRequest()
{
Blob = new BlobRequest()
{
Name = String.Format("image_{0}.jpeg", Guid.NewGuid()),
IsPublic = false
}
};
var createFileInfoResponse = await client.ContentClient.CreateFileInfoAsync(createFileRequest);
if (await HandleResponse (createFileInfoResponse, HttpStatusCode.Created)) {
var uploadFileRequest = new UploadFileRequest {
BlobObjectAccess = createFileInfoResponse.Result.Blob.BlobObjectAccess,
FileContent = new BytesContent () {
Bytes = imageBytes,
ContentType = "image/jpg",
}
};
var uploadFileResponse = await client.ContentClient.FileUploadAsync (uploadFileRequest);
if (!await HandleResponse (createFileInfoResponse, HttpStatusCode.Created))
return null;
var blobUploadCompleteRequest = new BlobUploadCompleteRequest {
BlobUploadSize = new BlobUploadSize () { Size = (uint)imageBytes.Length }
};
var response = await client.ContentClient.FileUploadCompleteAsync (createFileInfoResponse.Result.Blob.Id, blobUploadCompleteRequest);
if (!await HandleResponse (response, HttpStatusCode.OK))
return null;
return createFileInfoResponse.Result.Blob.Id;
} else {
return null;
}
}
static bool uploadFile(HttpRequestMessageProperty httpRequest, string jobID, string fileRefID, string FileContent)
{
try
{
FileTransferServicePortClient client = new FileTransferServicePortClient(FTconfigName);
using (OperationContextScope scope = new OperationContextScope(client.InnerChannel))
{
OperationContext.Current.OutgoingMessageProperties.Add(HttpRequestMessageProperty.Name, httpRequest);
UploadFileRequest uploadReq = new UploadFileRequest();
uploadReq.fileAttachment = getFileAttachment(FileContent);
uploadReq.fileReferenceId = fileRefID;
uploadReq.taskReferenceId = jobID;
uploadReq.fileFormat = "gzip";
UploadFileResponse uploadResponse = client.uploadFile(uploadReq);
if (uploadResponse.ack.ToString().Equals("Success"))
{
LMSMessage += Environment.NewLine + " request file uploaded successfully";
return true;
}
else
{
throw new Exception(uploadResponse.errorMessage[0].message);
return false;
}
}
}
catch (Exception ex)
{
LMSMessage += Environment.NewLine + " uploadFile:" + ex.Message;
return false;
}
}
