public async Task <DocViewModel> Upload(UploadRequest request)
{
var fileData = request.File;
var document = new Models.Doc
{
ContentType = request.File.ContentType,
Description = request.Details,
OriginalFileName = request.File.FileName,
FileName = request.Name,
SizeInMbs = request.File.Length,
CreatedBy = _httpContextAccessor.GetUser().userId,
IsPrimary = request.IsPrimary
};
//Save record to db
var resp = await _repository.CreateAsync(document);
//create server filename
var extension = Path.GetExtension(request.File.FileName);
var filePath = Path.Combine(DocStore, $"{resp.Id}.{extension}");
using (var stream = new FileStream(filePath, FileMode.Create))
{
await fileData.CopyToAsync(stream);
}
return(_mapper.Map <DocViewModel>(resp));
}
private async Task <UploadResponse> SingleUpload(UploadRequest request)
{
logger.Info("Using PutObject to upload file");
if (_configuration.EnforceMd5Upload && request.PutObjectRequest.ContentMD5 == null)
{
var inputStream = request.PutObjectRequest.PutObjectBody;
var contentMd5 = MultipartUtils.CalculateMd5(inputStream);
if (inputStream.CanSeek)
{
inputStream.Position = 0;
}
else
{
throw new NotSupportedException("Stream cannot be seeked, Please re-try with re-readable streams.");
}
request.PutObjectRequest.ContentMD5 = contentMd5;
}
if (request.OnProgress != null)
{
request.PutObjectRequest.PutObjectBody = new ProgressTrackingInputStream(
request.PutObjectRequest.PutObjectBody, new ProgressTracker(request.OnProgress, request.PutObjectRequest.PutObjectBody.Length));
}
var response = await _osClient.PutObject(request.PutObjectRequest, request.RetryConfiguration).ConfigureAwait(false);
return(new UploadResponse()
{
ETag = response.ETag,
OpcRequestId = response.OpcRequestId,
OpcClientRequestId = response.OpcClientRequestId,
OpcContentMd5 = response.OpcContentMd5
});
}
public void UploadFileToUserDocumentsFolder(
UploadRequest uploadRequest)
{
var documentsFolder = AccountHelper.GetUserDocumentsFolder(uploadRequest.UserDomain, uploadRequest.UserName, uploadRequest.UserPassword);
try
{
// replace if already exists
if (File.Exists(Path.Combine(documentsFolder, uploadRequest.FileName)))
{
File.Delete(Path.Combine(documentsFolder, uploadRequest.FileName));
}
var fileStream = File.Create(Path.Combine(documentsFolder, uploadRequest.FileName));
int bytesRead;
var buffer = new byte[4096];
while ((bytesRead = uploadRequest.FileStream.Read(buffer, 0, buffer.Length)) > 0)
{
fileStream.Write(buffer, 0, bytesRead);
}
fileStream.Close();
uploadRequest.FileStream.Close();
}
catch (Exception exc)
{
Trace.TraceError("Failed to upload file {0} to user {1} documents folder {2}, remote session {3} ({4})", uploadRequest.FileName, uploadRequest.UserName, documentsFolder, uploadRequest.RemoteSessionId, exc);
throw;
}
Trace.TraceInformation("Uploaded file {0} to user {1} documents folder {2}, remote session {3}", uploadRequest.FileName, uploadRequest.UserName, documentsFolder, uploadRequest.RemoteSessionId);
}
public IEnumerable <UploadResponse> Upload(UploadRequest request)
{
var list = new List <UploadResponse>();
request.Files.ForEach(async file =>
{
string contentType = MimeUtility.GetMimeMapping(file.FileName);
string extension = Path.GetExtension(file.FileName);
var content = ToByteArray(file);
string subs = Guid.NewGuid().ToString().Substring(0, 4);
string fileName = $"{subs}-{request.Ticket}-{file.FileName}";
var blobClient = new BlobClient(_connectionString, $"{_container}/{request.Ticket}", fileName);
list.Add(new UploadResponse
{
NomeArquivo = fileName,
Url = blobClient.Uri.AbsoluteUri,
ContentType = contentType,
Extension = extension
});
using var stream = new MemoryStream(content);
await blobClient.UploadAsync(stream);
});
return(list);
}
public IActionResult Upload(string upload)
{
string filename = Request.Form["filename"];
var files = Request.Form.Files;
if (files.Count == 0 || filename == "")
{
ViewData["Result"] = "Please choose file and give it a name";
ViewData["Saved"] = false;
}
else
{
var file = files[0];
UploadRequest model = new UploadRequest
{
Extension = Path.GetExtension(file.FileName),
Base64String = Utility.ConvertToBase64(file.OpenReadStream()),
Name = filename
};
var url = _configuration.GetSection("ApiSettings:UploadDocument").Value;
var result = _apiHelper.ApiServicePostRequest <UploadRequest, Result <Document> >(model, url, GetSession().Token);
if (result != null)
{
ViewData["Result"] = result.ResultMessage;
ViewData["Saved"] = result.ResultStatus;
}
else
{
ViewData["Result"] = "Upload failed";
ViewData["Saved"] = false;
}
}
return(Uploader());
}
public Result <DocumentInfo> Save(UploadRequest request)
{
Result <DocumentInfo> saveresult = new Result <DocumentInfo>();
var result = _validation.Base64ToStream(request.Base64String);
if (!result.ResultStatus)
{
saveresult.ResultMessage = result.ResultMessage;
saveresult.ResultInnerMessage = result.ResultInnerMessage;
saveresult.ResultCode = ResultCodes.Validation.GetHashCode();
}
Stream stream = result.ResultEntity;
result = _validation.ValidateFileSize(result.ResultEntity);
if (!result.ResultStatus)
{
saveresult.ResultMessage = result.ResultMessage;
saveresult.ResultInnerMessage = result.ResultInnerMessage;
saveresult.ResultCode = ResultCodes.Validation.GetHashCode();
return(saveresult);
}
result = _validation.ValidateExtension(result.ResultEntity, request.Extension);
if (!result.ResultStatus)
{
saveresult.ResultMessage = result.ResultMessage;
saveresult.ResultInnerMessage = result.ResultInnerMessage;
saveresult.ResultCode = ResultCodes.Validation.GetHashCode();
return(saveresult);
}
try
{
var file = Guid.NewGuid().ToString("N") + request.Extension;
var webrootFolder = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot");
var path = Path.Combine(webrootFolder, localpath, file).ToLower();
using (var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
{
stream.CopyTo(fileStream);
}
HttpRequest hrequest = _httpContextAccessor.HttpContext.Request;
saveresult.ResultEntity = new DocumentInfo {
FilePath = "http://" + hrequest.Host + "/" + localpath + "/" + file, FileSize = stream.Length.ToString()
};
saveresult.ResultStatus = true;
saveresult.ResultMessage = "Saved";
saveresult.ResultCode = ResultCodes.OK.GetHashCode();
}
catch (Exception ex)
{
saveresult.ResultEntity = null;
saveresult.ResultStatus = false;
saveresult.ResultMessage = "Error";
saveresult.ResultInnerMessage = ex.ToString();
saveresult.ResultCode = ResultCodes.Error.GetHashCode();
}
return(saveresult);
}
public async Task <IActionResult> Upload(
string dirPath,
[FromForm] UploadRequest request,
[FromServices] IMediator mediator)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
ViewData["DirPath"] = dirPath;
var directryPath = new FilePath(dirPath ?? "");
foreach (var file in request.Files)
{
using (var stream = file.OpenReadStream())
{
var data = await _storage.CreateAsync(_storage.CreateKey(), stream).ConfigureAwait(false);
var filePath = directryPath.Combine(System.IO.Path.GetFileName(file.FileName ?? "NONAME"));
var command = new CreateOrUpdateDocumentCommand
{
Path = filePath,
Data = data,
ForceCreate = true
};
var response = await mediator.Send(command).ConfigureAwait(false);
}
}
return(Redirect(Url.ViewFile(directryPath.ToString())));
}
public async Task Test_UploadFile()
{
// The cancellation token.
CancellationToken cancellationToken = CancellationToken.None;
// The content.
var file = new StringContent("File content");
// Create the request.
var request = new UploadRequest(
file,
"test",
filetype: "text",
initialComment: "This is the initial comment",
title: "file title"
);
// Post a message.
var response = await Client.Files
.UploadAsync(request, cancellationToken)
.ConfigureAwait(false);
// It is ok.
Assert.True(response.Ok, $"The call to {nameof(Client.Files.UploadAsync)} returned an error: {response.Error}");
// Assert value equality.
Assert.Equal(request.Filename, response.File.Name);
Assert.Equal(request.Title, response.File.Title);
}
public async Task <IActionResult> Upload(UploadRequest request)
{
if (string.IsNullOrEmpty(request.Title))
{
return(BadRequest("Invalid input data!"));
}
PostModel post = null;
if (request.Image != null)
{
using (var stream = new MemoryStream())
{
await request.Image.CopyToAsync(stream);
var extension = Path.GetExtension(request.Image.FileName);
post = await postService.PostImage(request.Title, stream.ToArray(), extension, User.Identity.Name, request.IsNSFW);
}
}
else if (!string.IsNullOrEmpty(request.youTubeLink))
{
post = await postService.PostYTVideo(request.Title, request.youTubeLink, User.Identity.Name, request.IsNSFW);
}
else
{
return(BadRequest());
}
eventPublisher.Publish <IPostCreatedEventHandler, PostModel>(post);
return(RedirectToAction("Index", "Home"));
}
public UploadResponse Upload(UploadRequest request)
{
var tempFile = Path.GetTempFileName();
try
{
// write data to a temp file
File.WriteAllBytes(tempFile, request.DataContent);
// create the new document object, and put the remote file
var args = new AttachedDocumentCreationArgs
{
MimeType = request.MimeType,
FileExtension = request.FileExtension,
LocalContentFilePath = tempFile
};
var document = AttachedDocument.Create(args, AttachmentStore.GetClient());
PersistenceContext.Lock(document, DirtyState.New);
PersistenceContext.SynchState();
var assembler = new AttachedDocumentAssembler();
return(new UploadResponse(assembler.CreateAttachedDocumentSummary(document)));
}
finally
{
File.Delete(tempFile);
}
}
// Save photo url
public async Task <PhotoResponse> SavePhotoUrl(int userId, UploadRequest model)
{
var userInDb = await _userService.GetUserWithPhotos(userId);
if (userInDb.Photos.Count == 9)
{
throw new AppException("You cannot have more than 9 photos");
}
var photo = _mapper.Map <Photo>(model);
photo.Order = Convert.ToByte(userInDb.Photos.Count);
//if (!userInDb.Photos.Any(u => u.IsMain))
//{
// photo.IsMain = true;
//}
userInDb.Photos.Add(photo);
if (await _context.SaveChangesAsync() > 0)
{
return(_mapper.Map <PhotoResponse>(photo));
}
throw new AppException("Save photo url failed");
}
/// <summary>
/// Start upload file asynchronously
/// </summary>
/// <param name="fileContent">FileContent</param>
/// <param name="chunkSize">ChunkSize</param>
/// <param name="replaceVideoId">ReplaceVideoId</param>
/// <returns></returns>
private async Task <IUploadRequest> StartUploadFileAsync(IBinaryContent fileContent,
int chunkSize = DefaultUploadChunkSize,
long?replaceVideoId = null)
{
if (!fileContent.Data.CanRead)
{
throw new ArgumentException("fileContent should be readable");
}
if (fileContent.Data.CanSeek && fileContent.Data.Position > 0)
{
fileContent.Data.Position = 0;
}
var ticket = replaceVideoId.HasValue
? await GetReplaceVideoUploadTicketAsync(replaceVideoId.Value).ConfigureAwait(false)
: await GetUploadTicketAsync().ConfigureAwait(false);
var uploadRequest = new UploadRequest
{
Ticket = ticket,
File = fileContent,
ChunkSize = chunkSize
};
return(uploadRequest);
}
public async Task <ActionResult> UpdateAvatar(UploadRequest request)
{
var contactId = request.RefrenceId;
if (contactId == null || contactId.Value == Guid.Empty)
{
throw new ClientFriendlyException($"Invalid contact id: {contactId}");
}
var contact = await _contactService.GetByIdAsync(contactId.Value);
if (contact == null)
{
throw new ClientFriendlyException($"Invalid contact id: {contactId}");
}
var resp = await _docService.Upload(request);
var avatar = $"http://localhost:9001/api/docs/download/{resp.Id}";
contact.Person.Avatar = avatar;
await _contactService.UpdateAsync(contact);
return(Ok(new { message = "Upload Successful", avatar }));
}
public async Task <IUploadRequest> StartUploadFileAsync(IBinaryContent fileContent,
int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE,
long?replaceVideoId = null)
{
if (!fileContent.Data.CanRead)
{
throw new ArgumentException("fileContent should be readable");
}
if (fileContent.Data.CanSeek && fileContent.Data.Position > 0)
{
fileContent.Data.Position = 0;
}
UploadTicket ticket = replaceVideoId.HasValue
? await GetReplaceVideoUploadTicketAsync(replaceVideoId.Value)
: await GetUploadTicketAsync();
var uploadRequest = new UploadRequest
{
Ticket = ticket,
File = fileContent,
ChunkSize = chunkSize
};
VerifyUploadResponse uploadStatus = await ContinueUploadFileAsync(uploadRequest);
return(uploadRequest);
}
public string UploadAsync(UploadRequest request)
{
if (request.Data == null)
{
return(string.Empty);
}
var streamData = new MemoryStream(request.Data);
if (streamData.Length > 0)
{
var folder = request.UploadType.ToDescriptionString();
var folderName = Path.Combine("Files", folder);
var pathToSave = Path.Combine(Directory.GetCurrentDirectory(), folderName);
bool exists = System.IO.Directory.Exists(pathToSave);
if (!exists)
{
System.IO.Directory.CreateDirectory(pathToSave);
}
var fileName = request.FileName.Trim('"');
var fullPath = Path.Combine(pathToSave, fileName);
var dbPath = Path.Combine(folderName, fileName);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
streamData.CopyTo(stream);
}
return(dbPath);
}
else
{
return(string.Empty);
}
}
/// <inheritdoc />
public override void SaveRequest(UploadRequest request, bool isCreate)
{
// TODO: uncomment, add check to make sure object is the same
//if (isCreate)
//{
try
{
#if NET35
_requestsLock.EnterUpgradeableReadLock();
#else
_requestsLock.AcquireReaderLock(-1);
#endif
Dictionary <string, UploadRequest> requests;
if (!_uploadRequests.TryGetValue(request.UploadSessionId, out requests))
{
requests = new Dictionary <string, UploadRequest>();
requests[request.UploadRequestId] = request;
#if !NET35
// TODO: does this break something?
LockCookie cookie = new LockCookie();
#endif
try
{
#if NET35
_requestsLock.EnterWriteLock();
#else
cookie = _requestsLock.UpgradeToWriterLock(-1);
#endif
_uploadRequests[request.UploadSessionId] = requests;
}
finally
{
#if NET35
_requestsLock.ExitWriteLock();
#else
_requestsLock.DowngradeFromWriterLock(ref cookie);
#endif
}
}
else
{
lock (requests)
requests[request.UploadRequestId] = request;
}
}
finally
{
#if NET35
_requestsLock.ExitUpgradeableReadLock();
#else
_requestsLock.ReleaseReaderLock();
#endif
}
//}
}
public UploadResponse Upload(UploadRequest request)
{
try
{
// open DB client and get DB reference
var client = new MongoClient(SysConfig.DBconn);
var database = client.GetDatabase("da_pp_db");
// stream the file to GridFS
var us = new GridFSBucket(database);
var id = us.UploadFromStream(request.FileName, request.Stream);
return(new UploadResponse
{
UploadSucceeded = true,
Errored = false,
Message = "File uploaded"
});
}
catch (Exception ex)
{
return(new UploadResponse
{
UploadSucceeded = false,
Errored = true,
Message = ex.Message
});
}
}
public string Post([FromBody] UploadRequest request)
{
string xml;
try
{
var webRequest = WebRequest.Create(request.Url);
using (var response = webRequest.GetResponse())
using (var content = response.GetResponseStream())
using (var reader = new StreamReader(content))
{
xml = reader.ReadToEnd();
}
var service = new XMLGraphParserService(xml);
if (!service.IsValid() && graphService.Create(service.Graph))
{
return(JsonConvert.SerializeObject(new UploadResponse {
Success = false, Errors = service.Errors
}, Formatting.Indented));
}
return(JsonConvert.SerializeObject(new UploadResponse {
Success = true
}));
}catch (Exception ex)
{
return(JsonConvert.SerializeObject(new UploadResponse {
Success = false, Errors = new List <string> {
ex.Message
}
}));
}
}
/// <inheritdoc />
public override UploadRequest GetRequest(string uploadSessionId, string uploadRequestId)
{
try
{
#if NET35
_requestsLock.EnterReadLock();
#else
_requestsLock.AcquireReaderLock(-1);
#endif
Dictionary <string, UploadRequest> requests;
UploadRequest request = null;
if (_uploadRequests.TryGetValue(uploadSessionId, out requests))
{
lock (requests)
{
if (!requests.TryGetValue(uploadRequestId, out request))
{
request = null;
}
}
}
return(request);
}
finally
{
#if NET35
_requestsLock.ExitReadLock();
#else
_requestsLock.ReleaseReaderLock();
#endif
}
}
internal override async Task runTest(UploadRequest.UploadRequest request) {
string data = "<script>alert(document.cookie)</script>";
request.setFileData(Encoding.ASCII.GetBytes(data));
request.setFileContentType("image/jpeg"); //Default all files to image/jpeg
//HTML case sensitivity test
request.setFileName("Test_4" + ".hTMl");
await request.send();
printResult(request, "Test 04 (.hTMl)");
//ASP case sensitivity test
request.setFileName("Test_4" + ".aSp");
await request.send();
printResult(request, "Test 04 (.aSp)");
//Change contents for php test
data = "<?php\n"
+ " echo phpinfo();\n"
+ "?>";
//PHP case sensitivity test
request.setFileName("Test_4" + ".pHp");
await request.send();
printResult(request, "Test 04 (.pHp)");
}
public async Task <IActionResult> UploadFile(
[FromForm] UploadRequest uploadRequest)
{
try
{
if (uploadRequest.upload == null ||
uploadRequest.upload.Length == 0)
{
return(BadRequest("File not selected"));
}
var result = await _fileSystemService
.UploadFileAsync(
new UploadFileState(
new NPath(uploadRequest.target),
new NPath(uploadRequest.upload_fullpath),
uploadRequest.upload.OpenReadStream()
));
if (result == null)
{
throw new SystemException("Unable to process file upload");
}
return(Json(result));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
public async Task <IUploadRequest> StartUploadFileAsync(IBinaryContent fileContent,
int chunkSize = DEFAULT_UPLOAD_CHUNK_SIZE)
{
if (!fileContent.Data.CanRead)
{
throw new ArgumentException("fileContent should be readable");
}
if (fileContent.Data.CanSeek && fileContent.Data.Position > 0)
{
fileContent.Data.Position = 0;
}
UploadTicket ticket = await GetUploadTicketAsync();
var uploadRequest = new UploadRequest
{
Ticket = ticket,
File = fileContent,
ChunkSize = chunkSize
};
VerifyUploadResponse uploadStatus = await ContinueUploadFileAsync(uploadRequest);
uploadRequest.BytesWritten = uploadStatus.BytesWritten;
return(uploadRequest);
}
public async Task <ActionResult <UploadResult> > Upload([FromQuery] UploadRequest request, [FromForm] IFormFile file)
{
var site = await _siteRepository.GetAsync(request.SiteId);
if (file == null)
{
return(this.Error("请选择有效的文件上传"));
}
var fileName = Path.GetFileName(file.FileName);
if (!_pathManager.IsVideoExtensionAllowed(site, PathUtils.GetExtension(fileName)))
{
return(this.Error("文件格式不正确，请更换文件上传!"));
}
var localDirectoryPath = await _pathManager.GetUploadDirectoryPathAsync(site, UploadType.File);
var localFileName = PathUtils.GetUploadFileName(fileName, request.IsChangeFileName);
var filePath = PathUtils.Combine(localDirectoryPath, localFileName);
await _pathManager.UploadAsync(file, filePath);
return(new UploadResult
{
Name = localFileName,
Path = filePath
});
}
public UploadResponse Upload(UploadRequest request)
{
try
{
DictionaryInfo dictInfo = request.DictInfo;
using (var db = new DictServiceEntities())
{
var user = db.Users.SingleOrDefault(x => x.Login == dictInfo.SenderLogin);
if (user == null)
{
user.Login = request.DictInfo.SenderLogin;
db.Users.Add(user);
db.SaveChanges();
}
//if (!CheckExtension(dictInfo.FileName, ".mdb"))
//{
// throw new NotSupportedException();
//}
if (!CheckPermission(user, dictInfo.Action))
{
throw new Exception("Нету прав!!!");
}
switch (dictInfo.Action)
{
case ActionEnum.AddDict:
{
AddNewDicionary(request.DictInfo, user, request.Stream);
break;
}
case ActionEnum.EditDict:
{
RefreshDictionary(request.DictInfo, user, request.Stream);
break;
}
}
return(new UploadResponse
{
UploadSucceeded = true
});
}
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation("Property: {0} Error: {1}",
validationError.PropertyName,
validationError.ErrorMessage);
}
}
return(new UploadResponse
{
UploadSucceeded = false,
Error = dbEx.ToString()
});
}
}
public void UploadObject(UploadRequest request)
{
CheckUri(request.Uri);
try
{
var client = cloudStorageAccount.CreateCloudBlobClient();
client.ParallelOperationThreadCount = 1;
var container = client.GetContainerReference(containerName);
if (request.CreateDirectory)
{
container.CreateIfNotExists();
}
var blob = container.GetBlockBlobReference(request.Uri.AbsoluteUri);
if (request.InputStream.Position != 0)
{
request.InputStream.Position = 0;
}
blob.UploadFromStream(request.InputStream);
}
catch (Exception e)
{
throw new StorageException(string.Format("Failed to upload object with request {0}.", request), e);
}
}
public override async Task <UploadResponse> UploadFile(UploadRequest request, ServerCallContext context)
{
_logger.LogInformation($"File Received: {request.Name} | Size: {request.Content.Length} ");
_db.Docs.Add(new Doc
{
Content = request.Content.ToArray(),
ContentType = request.ContentType,
PostId = request.PostId,
FileName = request.Name,
UserId = request.UserId
});
await _db.SaveChangesAsync();
// Check if it was successful
var response = new UploadResponse
{
Status = FileUploadStatus.Success,
Message = $"File upload is done => {request.Name} | " + request.Content.Length
};
return(response);
}
/// <inheritdoc />
public override IEnumerable <UploadRequest> GetRequestsForSession(string uploadSessionId)
{
List <UploadRequest> requests = new List <UploadRequest>();
string sql;
sql = "SELECT " + _statusField + " FROM " + _table + " WHERE " + _sessionIdField + "=" + _sessionIdParameterName + " AND NOT " + _requestIdField + " IS NULL";
using (IDbConnection cn = CreateConnection(_connectionString))
using (IDbCommand cmd = cn.CreateCommand())
{
cmd.CommandText = sql;
AddParameter(cmd, _sessionIdParameterName, DbType.String, uploadSessionId);
cn.Open();
using (IDataReader rd = cmd.ExecuteReader(CommandBehavior.SingleResult))
{
while (rd.Read())
{
requests.Add(UploadRequest.Deserialize(rd.GetString(0)));
}
}
}
return(requests);
}
public UploadBlogsImportFileResponse Execute(UploadImportFileViewModel request)
{
var fileId = Guid.NewGuid();
var fileUri = importService.ConstructFilePath(fileId);
using (var stream = new MemoryStream())
{
request.FileStream.CopyTo(stream);
try
{
var upload = new UploadRequest();
upload.CreateDirectory = true;
upload.Uri = fileUri;
upload.InputStream = request.FileStream;
upload.IgnoreAccessControl = true;
storageService.UploadObject(upload);
}
catch (Exception exc)
{
throw new ValidationException(() => BlogGlobalization.ImportBlogPosts_FailedToSaveFileToStorage_Message,
"Failed to save blog posts import file to storage.",
exc);
}
stream.Position = 0;
var blogs = importService.DeserializeXMLStream(stream);
var results = importService.ValidateImport(blogs);
return(new UploadBlogsImportFileResponse {
Results = results, FileId = fileId
});
}
}
public void UploadPartToAmazon(string filename, string awsBucket, UploadRequest uploadRequest, uint chunkNumber, byte[] fileContent, int numberOfBytes, uint numberOfChunks)
{
var finalKey = string.Format("{0}/p{1}", uploadRequest.MultipartParams.Key, chunkNumber);
using (var client = new HttpClient())
{
using (var formData = new MultipartFormDataContent())
{
formData.Add(new StringContent(uploadRequest.MultipartParams.AWSAccessKeyid), "x-amz-credential");
formData.Add(new StringContent(finalKey), "key");
formData.Add(new StringContent(uploadRequest.MultipartParams.Policy), "Policy");
formData.Add(new StringContent(uploadRequest.MultipartParams.Signature), "X-Amz-Signature");
formData.Add(new StringContent(uploadRequest.MultipartParams.Acl), "acl");
formData.Add(new StringContent(uploadRequest.MultipartParams.Algorithm), "x-amz-algorithm");
formData.Add(new StringContent(uploadRequest.MultipartParams.Date), "x-amz-date");
formData.Add(new StringContent(uploadRequest.MultipartParams.SuccessActionStatus), "success_action_status");
formData.Add(new StringContent(uploadRequest.MultipartParams.ContentType), "Content-Type");
formData.Add(new StringContent(filename), "name");
formData.Add(new StringContent(chunkNumber.ToString()), "chunk");
formData.Add(new StringContent(numberOfChunks.ToString()), "chunks");
formData.Add(new StringContent(finalKey), "Filename");
formData.Add(new ByteArrayContent(fileContent, 0, numberOfBytes), "file");
var task = new Task(() =>
{
using (var response = client.PostAsync(awsBucket, formData))
{
response.Result.EnsureSuccessStatusCode();
}
});
task.Start();
Task.WaitAll(task);
}
}
}
public async Task <IActionResult> Post([FromBody] UploadRequest request)
{
string authHeader = this.HttpContext.Request.Headers["Authorization"];
string token = authHeader.Substring("bearer ".Length).Trim();
var userresult = _repository.GetUserByToken(token);
if (!userresult.ResultStatus)
{
return(Unauthorized());
}
if (userresult.ResultEntity.refUserRole != 1)
{
return(Unauthorized());
}
var result = _saver.Save(request);
if (!result.ResultStatus)
{
return(Ok(await Task.Run(() => result)));
}
return(Ok(await Task.Run(() => _repositoryDocument.Insert(new Document
{
CreatedUserId = userresult.ResultEntity.Id,
CreatedDate = DateTime.UtcNow,
FilePath = result.ResultEntity.FilePath,
FileSize = result.ResultEntity.FileSize,
Name = request.Name
}))));
}
public override Task <UploadReply> Upload(UploadRequest request, ServerCallContext context)
{
UploadReply result = new UploadReply();
try
{
Stream imageStream = new MemoryStream(request.File.ToByteArray());
Image originalImage = Image.FromStream(imageStream);
List <Image> images = ImageFactory.CreateNewSizeImages(originalImage);
SaveModel saveModel = new SaveModel()
{
Directory = request.Directory,
FileName = request.FileName,
Images = images,
OriginalImage = originalImage
};
var saveList = imageCollectionSaver.Save(saveModel);
result.UploadPath = "upload/" + request.Directory + request.FileName;
}
catch (Exception ex)
{
result = new UploadReply()
{
ErrorMessage = ex.Message, HasError = true
};
}
return(Task.FromResult(result));
}
internal static void RenderProgress(HttpContext context, UploadRequest request)
{
StringBuilder sb = new StringBuilder();
sb.Append('{');
if (request != null)
{
JsonHelper.AppendJson(sb, "uploadRequestId", request.UploadRequestId);
JsonHelper.AppendJson(sb, "uploadSessionId", request.UploadSessionId);
JsonHelper.AppendJson(sb, "position", request.Position);
JsonHelper.AppendJson(sb, "contentLength", request.ContentLength);
JsonHelper.AppendJson(sb, "errorType", request.ErrorType.ToString());
if (request.Error != null)
JsonHelper.AppendJson(sb, "errorMessage", request.Error.Message);
JsonHelper.AppendJson(sb, "status", request.State.ToString());
if (request.UploadedFiles.Count > 1)
sb.Append(", files: [");
foreach (UploadedFile file in request.UploadedFiles)
{
StringBuilder fileSb;
if (request.UploadedFiles.Count > 1)
{
fileSb = new StringBuilder();
fileSb.Append('{');
}
else
{
fileSb = sb;
}
JsonHelper.AppendJson(fileSb, "name", file.ClientName);
JsonHelper.AppendJson(fileSb, "fileSelectorId", file.FileSelectorId);
JsonHelper.AppendJson(fileSb, "sourceElement", file.SourceElement);
foreach (KeyValuePair<string, string> pair in file.Data)
JsonHelper.AppendJson(fileSb, pair.Key, pair.Value);
if (request.UploadedFiles.Count > 1)
{
fileSb.Append('}');
sb.Append(fileSb.ToString());
}
}
if (request.UploadedFiles.Count > 1)
sb.Append(']');
}
sb.Append('}');
WriteResponse(context, sb.ToString(), request != null ? request.UploadProfile : null);
}
private static ValidationResponse Validate(UploadRequest uploadRequest)
{
var validationResponse = ValidationResponse.Success;
var postedFile = uploadRequest.PostedFile;
if (!ValidateEmpty(postedFile)) validationResponse = ValidationResponse.Empty;
else if (!ValidateSize(postedFile, uploadRequest.MaxSize)) validationResponse = ValidationResponse.MaxSizeExceeded;
else if (!ValidateType(postedFile.InputStream)) validationResponse = ValidationResponse.InvalidFileType;
return validationResponse;
}
public MimeUploadHandler(UploadHttpRequest httpRequest, UploadRequest request)
{
//Current = this;
_httpRequest = httpRequest;
_request = request;
_boundary = ExtractBoundary(_httpRequest.ContentType, _httpRequest.ContentEncoding);
_requestStream = new RequestStream(_httpRequest.Worker);
}
internal override async Task runTest(UploadRequest.UploadRequest request) {
const string data = "<?php\n"
+ " echo phpinfo();\n"
+ "?>";
request.setFileData(Encoding.ASCII.GetBytes(data));
request.setFileContentType("image/jpeg");
request.setFileName("Test_2.php");
await request.send();
printResult(request, "Test 02");
}
internal override async Task runTest(UploadRequest.UploadRequest request){
//Set the data to HTML (all formats support HTML)
const string data = "<script>alert(document.cookie)</script>";
string[] badExtensions = {".html", ".shtml", ".jsp", ".asp", ".phtml", ".php3", ".php4", ".php5" };
request.setFileContentType("image/jpeg"); //Default all files to image/jpeg
request.setFileData(Encoding.ASCII.GetBytes(data));
foreach (string t in badExtensions){
request.setFileName("Test_3" + t);
await request.send();
printResult(request, "Test 03 (" + t + ")");
}
}
public string GetUploadSasUrl(UploadRequest request)
{
string imageUri = string.Empty;
// Set the URI for the Blob Storage service.
Uri blobEndpoint = new Uri(string.Format("https://{0}.blob.core.windows.net", AppSettings.StorageAccountName));
// Create the BLOB service client.
CloudBlobClient blobClient = new CloudBlobClient(blobEndpoint, storageCred);
if (request.ContainerName != null)
{
// Set the BLOB store container name on the item, which must be lowercase.
request.ContainerName = request.ContainerName.ToLower();
// Create a container, if it doesn't already exist.
CloudBlobContainer container = blobClient.GetContainerReference(request.ContainerName);
container.CreateIfNotExistsAsync();
// Create a shared access permission policy.
BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
// Enable anonymous read access to BLOBs.
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob;
container.SetPermissions(containerPermissions);
// Define a policy that gives write access to the container for 5 minutes.
SharedAccessBlobPolicy sasPolicy = new SharedAccessBlobPolicy()
{
SharedAccessStartTime = DateTime.UtcNow,
SharedAccessExpiryTime = DateTime.UtcNow.AddMinutes(5),
Permissions = SharedAccessBlobPermissions.Write
};
// Get the SAS as a string.
var sasQueryString = container.GetSharedAccessSignature(sasPolicy);
// Set the URL used to store the image.
imageUri = string.Format("{0}{1}/{2}{3}", blobEndpoint.ToString(),
request.ContainerName, request.FileName, sasQueryString);
}
// Complete the insert operation.
return imageUri;
}
internal override async Task runTest(UploadRequest.UploadRequest request) {
//Upload a normal jpg
byte[] data = getFirstImage();
request.setFileContentType("image/jpeg");
request.setFileData(data);
request.setFileName("UniqueLongName.jpg");
await request.send();
printResult(request, "Test 12 (Short-name prep)");
//Upload a jpg with the shortname matching the shortname version of the previous file
data = getSecondImage();
request.setFileData(data);
request.setFileName("Unique~1.jpg");
await request.send();
printResult(request, "Test 12 (Short-name overwrite)");
}
internal override async Task runTest(UploadRequest.UploadRequest request){
byte[] data = getImage();
request.setFileData(data);
request.setFileContentType("image/jpeg");
request.setFileName("Test_7.jpg.php"); //Default extension that will work
await request.send();
printResult(request, "Test 07 (malicious image .jpg.php)");
request.setFileName("Test_7.php.abc1"); //Will only work in certain conditions
await request.send();
printResult(request, "Test 07 (malicious image .php.abc1)");
request.setFileName("Test_7.php.jpg"); //Will only work in certain conditions
await request.send();
printResult(request, "Test 07 (malicious image .php.jpg)");
}
public UploadResponse Upload(UploadRequest uploadRequest)
{
var validationResponse = Validate(uploadRequest);
string webUrl = null;
if (validationResponse == ValidationResponse.Success)
{
var postedFile = uploadRequest.PostedFile;
var relativeFolderPath = uploadRequest.RelativeFolderPath;
var fileName = string.Format("{0}{1}", Guid.NewGuid(), Path.GetExtension(postedFile.FileName));
var savePath = string.Format("{0}{1}", HttpContext.Current.Server.MapPath(relativeFolderPath), fileName);
postedFile.SaveAs(savePath);
webUrl = string.Format("{0}{1}", relativeFolderPath, fileName);
}
return new UploadResponse(validationResponse, webUrl);
}
internal override async Task runTest(UploadRequest.UploadRequest request){
//Send a new .htaccess file. If this is uploaded it will make the server execute jpgs as php files
string data = "AddType application/x-httpd-php .jpg";
request.setFileData(Encoding.ASCII.GetBytes(data));
request.setFileContentType("image/jpeg");
request.setFileName(".htaccess");
await request.send();
printResult(request, "Test 08 (.htaccess over/write)");
//Upload a valid jpg with php in it's comment section
request.setFileData(getImage());
request.setFileContentType("image/jpeg");
request.setFileName("Test_8.jpg");
await request.send();
printResult(request, "Test 08 (php w/ .jpg)");
}
internal override async Task runTest(UploadRequest.UploadRequest request) {
const string data = "<?php\n"
+ " echo phpinfo();\n"
+ "?>";
request.setFileData(Encoding.ASCII.GetBytes(data));
request.setFileContentType("image/jpeg");
//Test for validation of just the final extension (Apache will use the real extension for the MIME type)
request.setFileName("Test_6.php.123");
await request.send();
printResult(request, "Test 06 (first extension)");
//Test for validation of just the first extension (Apache will use the last extension for the MIME type if they're all real)
request.setFileName("Test_6.jpg.php");
await request.send();
printResult(request, "Test 06 (last extension)");
//Test for "AddHandler" directive for php files (This will make Apache recognize the file as PHP no matter where the extension is)
request.setFileName("Test_6.php.jpg");
await request.send();
printResult(request, "Test 06 (AddHandler test)");
}
internal override async Task runTest(UploadRequest.UploadRequest request) {
const string data = "<?php\n"
+ " echo phpinfo();\n"
+ "?>";
request.setFileData(Encoding.ASCII.GetBytes(data));
request.setFileContentType("image/jpeg");
//Dot test
request.setFileName("Test_5.php.");
await request.send();
printResult(request, "Test 05 (dot test)");
//Space test
request.setFileName("Test_5.php ");
await request.send();
printResult(request, "Test 05 (space test)");
//Mixed test
request.setFileName("Test_5.php… … . . .. .. ");
await request.send();
printResult(request, "Test 05 (mixed dot/space test)");
}
/// <inheritdoc /> public abstract void SaveRequest(UploadRequest request, bool isCreate);
static void SaveRequest(HttpSessionState state, UploadRequest request)
{
Dictionary<string, string> saveRequests = GetSessionRequestsList(state, request.UploadSessionId, true);
saveRequests[request.UploadRequestId] = GetSerializedString(request);
}
/// <inheritdoc />
public void ProcessRequest(HttpContext context)
{
try
{
string uploadRequestId = context.Request.QueryString["uploadRequestId"];
string uploadSessionId = context.Request.QueryString["uploadSessionId"];
//if (string.IsNullOrEmpty(uploadRequestId))
// throw new HttpException(500, "uploadRequestId parameter is required.");
if (string.IsNullOrEmpty(uploadSessionId))
throw new HttpException(500, "uploadSessionId parameter is required.");
if (!string.IsNullOrEmpty(uploadRequestId))
{
UploadRequest request = SlickUploadContext.SessionStorageProvider.GetRequest(uploadSessionId, uploadRequestId);
if (request == null && string.Equals(context.Request.QueryString["isLastRetry"], "true", StringComparison.InvariantCultureIgnoreCase))
{
string uploadProfile = context.Request.QueryString["uploadProfile"];
UploadSession session = SlickUploadContext.SessionStorageProvider.GetSession(uploadSessionId);
if (session == null)
{
session = new UploadSession(uploadSessionId, uploadProfile);
session.State = UploadState.Uploading;
SlickUploadContext.SessionStorageProvider.SaveSession(session, true);
}
request = new UploadRequest(uploadSessionId, uploadRequestId, -1, uploadProfile);
request.State = UploadState.Error;
request.ErrorType = UploadErrorType.RequestNotRecieved;
//request._uploadedFilesInternal.Add(new UploadedFile(context.Request.QueryString["name"], null, null, request, null));
SlickUploadContext.SessionStorageProvider.SaveRequest(request, true);
}
RenderProgress(context, request);
}
else
RenderProgress(context, SlickUploadContext.SessionStorageProvider.GetSession(uploadSessionId));
}
catch (Exception ex)
{
UploadProfileElement profileElement = SlickUploadContext.Config.UploadProfiles.GetUploadProfileElement(context.Request.QueryString["uploadProfile"], false);
StringBuilder sb = new StringBuilder();
sb.Append('{');
JsonHelper.AppendJson(sb, "progressException", ex.ToString());
sb.Append('}');
WriteResponse(context, sb.ToString(), profileElement);
}
}
/// <inheritdoc />
public override void SaveRequest(UploadRequest request, bool isCreate)
{
CallHandler("SaveRequest", request);
RegisterCleanupSessionIfStaleTimeout(request.UploadSessionId);
}
/// <summary>
/// Uploads the specified file to the shard website
/// </summary>
/// <param name="fileName">the absolute or relative path of the file to be uploaded</param>
/// <param name="uploadPath">the relative path on the web server to upload the file to</param>
/// <param name="asciiFormat">if true, upload in ASCII format; if false, upload in binary format</param>
/// <param name="deleteAfterUpload">if true, deletes the given file after uploading</param>
public void UploadFile( string fileName, string uploadPath, bool asciiFormat, bool deleteAfterUpload )
{
if( !CollectRegistrySettings(out _ftpHost, out _ftpUsername, out _ftpPassword) )
{
ExceptionManager.LogException("FTPManager", new Exception("Unable to collect the necessary registry settings to upload " + fileName));
}
else if( !File.Exists(fileName) )
{
ExceptionManager.LogException("FTPManager", new FileNotFoundException("The specified file was not found.", fileName));
}
else
{
_currentRequest = new UploadRequest(fileName, uploadPath, asciiFormat, deleteAfterUpload);
_instructionFile = DateTime.Now.Ticks.ToString() + ".ftp";
if( _processLocked || File.Exists(_instructionFile) )
_requestQueue.Enqueue(_currentRequest);
else
{
try
{
using( StreamWriter writer = new StreamWriter(_instructionFile) )
{
writer.AutoFlush = true;
writer.WriteLine("open {0}", _ftpHost);
writer.WriteLine(_ftpUsername);
writer.WriteLine(_ftpPassword);
writer.WriteLine("cd {0}", _currentRequest.UploadPath);
writer.WriteLine(_currentRequest.ASCIIFormat ? "ascii" : "binary");
writer.WriteLine("put \"{0}\"", _currentRequest.FileName);
writer.WriteLine("close");
writer.Write("quit");
writer.Close();
}
_timeoutDelay = (IsArchivePackage(fileName) ? 180 : 60);
_ftpProc = new Process();
_ftpProc.EnableRaisingEvents = true;
_ftpProc.Exited += new EventHandler(delegate( object sender, EventArgs args ) { CleanUp(); });
_ftpProc.StartInfo = new ProcessStartInfo("ftp", String.Format("-v -i -s:\"{0}\"", _instructionFile));
_ftpProc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
_processLocked = true;
_ftpProc.Start();
int elapsedTime = 0;
while( _processLocked )
{
elapsedTime += 100;
if( elapsedTime >= (_timeoutDelay * 1000) )
{
CleanUp();
break;
}
Thread.Sleep(100);
}
}
catch( IOException ioe )
{
ExceptionManager.LogException("FTPManager.UploadFile(): Unable to upload file \"" + fileName + "\":\n", ioe);
CleanUp();
}
catch( Exception e )
{
ExceptionManager.LogException("FTPManager.UploadFile(): Unable to upload file \"" + fileName + "\":\n", e);
CleanUp();
}
}
}
}
void context_PreRequestHandlerExecute(object sender, EventArgs e)
{
HttpContext context = HttpContext.Current;
//System.Diagnostics.Debug.WriteLine(context.Request.Url.ToString() + " - " + (context.Request.Cookies.Count > 0 ? context.Request.Cookies[0].Value : "null"));
if (IsUploadRequest(context.Request))
{
if (context.Trace != null && context.Trace.IsEnabled)
throw new HttpException("Trace must be disabled for SlickUpload to intercept upload requests.");
if ((DateTime.Now - _lastCleanupDate).TotalSeconds > SlickUploadContext.Config.SessionStorageProvider.StaleTimeout)
{
lock (_cleanupThreadLock)
{
if ((DateTime.Now - _lastCleanupDate).TotalSeconds > SlickUploadContext.Config.SessionStorageProvider.StaleTimeout)
{
_lastCleanupDate = DateTime.Now;
Thread cleanupThread = new Thread(CleanupThread);
cleanupThread.Start();
}
}
}
string uploadSessionId = context.Request.QueryString["uploadSessionId"];
// Generate an uploadSessionId if none was specified
if (string.IsNullOrEmpty(uploadSessionId))
uploadSessionId = Guid.NewGuid().ToString();
UploadSession session = SlickUploadContext.SessionStorageProvider.GetSession(uploadSessionId);
if (session == null)
{
session = new UploadSession(uploadSessionId, context.Request.QueryString["uploadProfile"]);
session.State = UploadState.Uploading;
SlickUploadContext.SessionStorageProvider.SaveSession(session, true);
}
SlickUploadContext.CurrentUploadSessionInternal = session;
string uploadRequestId = context.Request.QueryString["uploadRequestId"];
// Generate an uploadRequestId if none was specified
if (string.IsNullOrEmpty(uploadRequestId))
uploadRequestId = Guid.NewGuid().ToString();
UploadHttpRequest httpRequest = new UploadHttpRequest(context);
UploadRequest request = new UploadRequest(uploadSessionId, uploadRequestId, httpRequest.ContentLength, context.Request.QueryString["uploadProfile"]);
bool isCalculateSize = (context.Request.QueryString["handlerType"] == "calculatesize");
try
{
SlickUploadContext.CurrentUploadRequest = request;
if (httpRequest.ContentLength > request.UploadProfile.MaxRequestLengthBytes || (httpRequest.ContentLength < 0 && request.UploadProfile.MaxRequestLength > 2097152))
{
//SimpleLogger.Log("Request too big... aborting");
request.ErrorType = UploadErrorType.MaxRequestLengthExceeded;
context.ApplicationInstance.CompleteRequest();
}
if (request.ErrorType == UploadErrorType.None && !(request.UploadFilter == null || request.UploadFilter.ShouldHandleRequest(httpRequest)))
{
request.ErrorType = UploadErrorType.UploadFilter;
}
if (request.ErrorType != UploadErrorType.None)
request.State = UploadState.Error;
else if (isCalculateSize)
request.State = UploadState.Initializing;
else
request.State = UploadState.Uploading;
}
catch (Exception ex)
{
request.State = UploadState.Error;
request.ErrorType = UploadErrorType.Other;
request.Error = ex;
throw;
}
finally
{
bool hasExistingRequest = false;
try
{
hasExistingRequest = (SlickUploadContext.SessionStorageProvider.GetRequest(uploadSessionId, request.UploadRequestId) != null);
}
catch
{ }
if (!hasExistingRequest)
SlickUploadContext.InsertRequest(request);
else
SlickUploadContext.UpdateRequest(request, true);
}
if (request.ErrorType == UploadErrorType.None)
{
if (isCalculateSize)
{
httpRequest.Worker.CloseConnection();
context.ApplicationInstance.CompleteRequest();
return;
}
context.Server.ScriptTimeout = request.UploadProfile.ExecutionTimeout;
MimeUploadHandler handler = null;
try
{
handler = new MimeUploadHandler(httpRequest, request);
handler.ProcessRequest();
// TODO: should we check the session's state here, and cancel?
// TODO: maybe no, because MimeUploadHandler checks on part end and throws cancelled if it should
request.State = UploadState.Complete;
}
catch (Exception ex)
{
if (handler != null)
{
try
{
handler.CancelParse();
}
catch
{
// TODO: what do we do with this exception?
}
}
request.State = UploadState.Error;
if (ex is UploadDisconnectedException)
{
request.ErrorType = UploadErrorType.Disconnected;
}
else if (ex is UploadCancelledException)
{
request.ErrorType = UploadErrorType.Cancelled;
}
else
{
request.ErrorType = UploadErrorType.Other;
request.Error = ex;
}
try
{
SlickUploadContext.CleanupRequest(request);
}
catch
{
// TODO: what do we do with this exception?
}
// If we were disconnected, let everything pass through. Otherwise, rethrow it.
if (ex is UploadDisconnectedException || ex is UploadCancelledException)
{
httpRequest.Worker.CloseConnection();
context.ApplicationInstance.CompleteRequest();
}
else
throw;
}
finally
{
SlickUploadContext.UpdateRequest(request, true);
}
}
}
}
/// <inheritdoc />
public override void SaveRequest(UploadRequest request, bool isCreate)
{
InsertOrUpdate(request.UploadSessionId, request.UploadRequestId, request.Serialize(), DateTime.Now, isCreate);
}
public void LoadLocalDocument(FileInfo file)
{
try {
var uri = new Uri(HtmlPage.Document.DocumentUri, "ConvertToXps.ashx");
var request = (HttpWebRequest)WebRequest.Create(uri);
var uploadRequest = new UploadRequest() {
FileName = file.Name,
FileStream = file.OpenRead(),
Request = request
};
request.Method = "POST";
request.BeginGetRequestStream(OnGetRequestStream, uploadRequest);
ClearDocument();
this.loading.Visibility = Visibility.Visible;
this.status.Text = "Sending document...Please Wait";
this.title.Text = uploadRequest.FileName;
}
catch (Exception ex) {
ErrorWindow.ShowError(ex);
this.loading.Visibility = Visibility.Collapsed;
}
}
/// <inheritdoc />
public override void SaveRequest(UploadRequest request, bool isCreate)
{
_provider.SaveRequest(request, isCreate);
}
