protected void btnUpload_Click(object sender, EventArgs e)
{
UploadItem info = new UploadItem("weixinarticle", flTitleImg);
var url = UploadHelper.Upload(info);
imgPerview.ImageUrl = url;
}
private void btnAdd_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Filter = GlobalMembers.SupportedFileType;
dlg.FilterIndex = 1;
dlg.Multiselect = false;
if ((bool)dlg.ShowDialog())
{
foreach (UploadItem ui in listUploadItems.Items)
{
if (ui.ItemInfo.Name == dlg.File.Name)
return;
}
int itemId = listUploadItems.Items.Count;
if (itemId < GlobalMembers.MaxThread)
{
UploadItem item = new UploadItem(dlg.File, itemId);
listUploadItems.Items.Add(item);
if (IsSignIn && !btnUpload.IsEnabled)
btnUpload.IsEnabled = true;
}
}
}
protected override void InitializeInternal()
{
_hasAccessToken = _flickrService.HasAccessToken();
UploadItem uploadItem1 = new UploadItem()
{
Header = "Bild 1",
Description = "Text von Bild 1",
Tags = string.Empty,
Location = new System.IO.FileInfo(@"D:\Bilder\60D\2020_10_01\darktable_exported\IMG_8536_01.jpg"),
IsPublic = false
};
UploadItems.Add(new UploadItemViewModel(uploadItem1));
UploadItem uploadItem2 = new UploadItem()
{
Header = "Bild 2",
Description = "Text von Bild 2",
Tags = string.Empty,
Location = new System.IO.FileInfo(@"D:\Bilder\60D\2020_11_18\darktable_exported\IMG_9149_01.jpg"),
IsPublic = true
};
UploadItems.Add(new UploadItemViewModel(uploadItem2));
}
protected override List <UploadItem> SetUploadItemFilePath(string sourceFolder, string filePath, UploadItem uploadItem)
{
if (ConfigurationManager.GetInstance().Configuration.OutlookConfigurations.SaveAsWord&& Path.GetExtension(filePath) == ".msg")
{
List <UploadItem> additionalItems = new List <UploadItem>();
Microsoft.Office.Interop.Outlook.Application outlook = new Microsoft.Office.Interop.Outlook.Application();
Microsoft.Office.Interop.Outlook.MailItem mailItem = (Microsoft.Office.Interop.Outlook.MailItem)outlook.CreateItemFromTemplate(filePath);
string newFileName = filePath.Substring(0, filePath.LastIndexOf('.')) + ".doc";
mailItem.SaveAs(newFileName, Microsoft.Office.Interop.Outlook.OlSaveAsType.olDoc);
foreach (Microsoft.Office.Interop.Outlook.Attachment attachment in mailItem.Attachments)
{
string extensionName = String.Empty;
string filenameWithoutExtension = String.Empty;
string fileName = String.Empty;
GetFileNameAndExtension(attachment.FileName, out filenameWithoutExtension, out extensionName);
filePath = GetUnuqieFileName(sourceFolder, filenameWithoutExtension, extensionName, out fileName);//keep original name
attachment.SaveAsFile(filePath);
UploadItem attachmentItem = new UploadItem();
attachmentItem.Folder = uploadItem.Folder;
attachmentItem.ContentType = uploadItem.ContentType;
attachmentItem.FieldInformations = uploadItem.FieldInformations;
attachmentItem.FilePath = filePath;
additionalItems.Add(attachmentItem);
}
uploadItem.FilePath = newFileName;
return(additionalItems);
}
else
{
base.SetUploadItemFilePath(sourceFolder, filePath, uploadItem);
return(null);
}
}
public async Task UploadChunkAsync(UploadJob job, UploadItem item)
{
//create reference to a part of the input stream
var chunkStream = GlacierUtils.CreatePartStream(item.DataStream, job.ChunkSize);
var chunkChecksum = TreeHashGenerator.CalculateTreeHash(chunkStream);
//prepare request
var request = new UploadMultipartPartRequest
{
VaultName = job.VaultName,
Body = chunkStream,
Checksum = chunkChecksum,
UploadId = job.UploadId
};
//set range of the current part
request.SetRange(job.CurrentPosition,
job.CurrentPosition + chunkStream.Length - 1);
//upload this part
var response = await _client.UploadMultipartPartAsync(request);
response.EnsureSuccess();
//commit progress
job.ChunkChecksums.Add(chunkChecksum);
job.CurrentPosition += chunkStream.Length;
}
public void AttachToRecord(UploadItem item)
{
try
{
Action <IEnumerable <string>, string, byte[]> attachFileMethod = GetAttachFunction(item.DocType);
using (MemoryStream stream = new MemoryStream())
{
item.Data.CopyTo(stream);
attachFileMethod.Invoke(item.KeyValues, item.FileName, stream.ToArray());
}
_logger.LogFileAttached(item);
}
catch (DocTypeUnrecognizedException)
{
_logger.LogDocTypeUnsupported(item);
}
catch (ApiException a)
{
if (a.ServerException.ExceptionType.Contains("NoEntitySatisfiesTheConditionException"))
{
_logger.LogRecordMissing(item);
}
else
{
_logger.LogError(a, "There was an unhandled exception");
}
}
catch (Exception e)
{
_logger.LogError(e, "There was an unhandled exception");
}
}
public async Task <ActionResult <Item> > Create([FromForm] UploadItem item)
{
var geometryFactory = NtsGeometryServices.Instance.CreateGeometryFactory(srid: 4326);
var myLocation = geometryFactory.CreatePoint(new Coordinate(item.Long, item.Lat));
var newItem = new Item
{
Location = myLocation,
Created = DateTime.Now
};
_context.Items.Add(newItem);
await _context.SaveChangesAsync();
if (Request.Form.Files.Count() == 1)
{
IFormFile file = Request.Form.Files[0];
if (file != null)
{
var result = await _blobService.UploadFileBlobAsync(_configuration["BlobStorage:Containername"], file.OpenReadStream(), file.ContentType, newItem.Id.ToString());
var toReturn = result.AbsoluteUri;
newItem.Image = toReturn;
await _context.SaveChangesAsync();
}
}
Console.WriteLine("Thank you!");
return(CreatedAtAction(nameof(Item), new { id = newItem.Id }, newItem));
// return Ok(new { path = toReturn });
}
/// <summary>
/// 添加对象.
/// </summary>
/// <param name="iTarget">上传目标.</param>
public void AddTarget(UploadItem iTarget)
{
DownloadTargetInfo target = null;
if (false == isTargetExist(iTarget.ID, iTarget.FileType, out target))
{
target = new DownloadTargetInfo();
this.Targets.Add(target);
target.No = iTarget.No;
target.ID = iTarget.ID;
target.BundleType = iTarget.BundleType;
target.FileType = iTarget.FileType;
target.DataSize = iTarget.DataSize;
target.CheckCode = iTarget.CheckCode;
target.Downloaded = false;
this.Info("AddTarget()::New:{0}", iTarget.toString());
}
else
{
// 变更的场合
if (false == iTarget.CheckCode.Equals(target.CheckCode))
{
target.DataSize = iTarget.DataSize;
target.CheckCode = iTarget.CheckCode;
target.Downloaded = false;
this.Info("AddTarget()::Changed:{0}", iTarget.toString());
}
}
}
public void UploadFile(ISiteSetting siteSetting, UploadItem uploadItem, IConnectorExplorer connectorExplorer, bool canUpdateItemInGrid, bool saveAsWord, UploadEventHandler UploadSucceeded, UploadEventHandler UploadFailed)
{
IServiceManager serviceManager = ServiceManagerFactory.GetServiceManager(siteSetting.SiteSettingType);
bool isListItemAndAttachment = ConfigurationManager.GetInstance().GetListItemAndAttachmentOption();
IItem item = null;
bool isSuccess = serviceManager.UploadFile(siteSetting, uploadItem, isListItemAndAttachment, out item);
UploadEventArgs e = new UploadEventArgs();
e.UploadItem = uploadItem;
e.UploadedItem = item;
e.CanUpdateItemInGrid = canUpdateItemInGrid;
e.ConnectorExplorer = connectorExplorer;
if (isSuccess == true)
{
UploadSucceeded(null, e);
}
else
{
e.ErrorMessage = Languages.Translate("Upload failed");
UploadFailed(null, e);
}
}
/// <summary>
/// 更新 2016-09-22 16:40 fengyh
/// </summary>
private void uploadFiles(int count)
{
this.uploadedBytes.Clear();
ManualResetEvent[] doneEvents = new ManualResetEvent[count];
this.uploadInfos = new UploadInfo[count];
for (int taskId = 0; taskId < count; taskId++)
{
this.uploadInfos[taskId] = new UploadInfo();
doneEvents[taskId] = new ManualResetEvent(false);
FileUploader uploader = new FileUploader(this.syncSetting, doneEvents[taskId], this, taskId);
UploadItem uploadItem = uploadItems[currentIndex + taskId];
dbItems.Add(new HashDBItem()
{
LocalFile = uploadItem.LocalFile,
FileHash = uploadItem.FileHash,
LastUpdate = uploadItem.LastUpdate
});
ThreadPool.QueueUserWorkItem(new WaitCallback(uploader.uploadFile), uploadItem);
}
try
{
WaitHandle.WaitAll(doneEvents);
}
catch (Exception ex)
{
Log.Error(ex.Message);
}
}
public static void LogFileAttached(this ILogger logger, UploadItem item)
{
string message = GenerateRecordPrefix(item);
message += " - Success";
logger.LogInformation(message);
}
private void UploadBeginEventHander(UploadItemVO vo)
{
UploadInfoComps comps = new UploadInfoComps();
comps.vo = vo;
UploadItem item = new UploadItem(this, comps, uploadHelper, floatWin);
itemDic[vo.name] = item;
}
public void Initialize_Test()
{
var file = new MemoryFileInfo("Hello from uploader...");
var uploadItem = new UploadItem(file);
var handler = Substitute.For<UploadHandlerBase>();
var task = new Task(handler, uploadItem);
Assert.AreEqual(task.Handler, handler);
Assert.AreEqual(task.UploadItem, uploadItem);
}
private static string GenerateRecordPrefix(UploadItem item)
{
string seperator = " / ";
string message = item.DocType + seperator;
foreach (string keyValue in item.KeyValues)
{
message += keyValue + seperator;
}
return(message.TrimEnd(seperator.ToCharArray()));
}
public UploadItem Post([FromBody] Video video)
{
video.Id = ObjectId.GenerateNewId();
var uploadItem = new UploadItem
{
Video = video
};
UploadItems.Add(uploadItem);
return(uploadItem);
}
public void SkynetPath_InvalidSiaPath_ThrowsArgumentException()
{
// Arrange
var fileInfoMock = new Mock <IFileInfo>().SetupValidFile();
var uploadItem = new UploadItem(fileInfoMock.Object);
// Act
void SetSkynetPath() => uploadItem.SkynetPath = "../home";
// Assert
Assert.That(SetSkynetPath, Throws.ArgumentException);
}
public void SkynetPath_ValidSiaPath_ThrowsNothing()
{
// Arrange
var fileInfoMock = new Mock <IFileInfo>().SetupValidFile();
var uploadItem = new UploadItem(fileInfoMock.Object);
// Act
void SetSkynetPath() => uploadItem.SkynetPath = "ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz0123456789-_";
// Assert
Assert.That(SetSkynetPath, Throws.Nothing);
}
public void Dispose_Test()
{
var file = new MemoryFileInfo("Hello from uploader...");
var uploadItem = new UploadItem(file);
var handler = Substitute.For<UploadHandlerBase>();
var task = new Task(handler, uploadItem);
task.Dispose();
handler.Received(1).Dispose();
}
public void Construction_ContentType_IsSet()
{
// Arrange
var fileInfoMock = new Mock <IFileInfo>().SetupValidFile();
var contentType = MediaTypeHeaderValue.Parse("text/csv");
// Act
var item = new UploadItem(fileInfoMock.Object, null, contentType);
// Assert
Assert.That(item.ContentType, Is.EqualTo(contentType));
}
public async Task UploadFile_FromUploadItemDifferentSkynetPath_ExpectedSkylink()
{
// Arrange
var file = new PhysicalFileInfo(new FileInfo("assets/test-file.json"));
var item = new UploadItem(file, skynetPath: "custom/directory/test-file.json");
// Act
var skylink = await _skynetWebPortal.UploadFile(item);
// Assert
Assert.That(skylink.ToString() == "AADoxsbpEVLgFTMco_fS3eiTAvtKx5WCfll5wqHEfyksrQ");
}
public void Construction_SkynetPath_IsSet()
{
// Arrange
var fileInfoMock = new Mock <IFileInfo>().SetupValidFile();
var skynetPath = "base/sky/net";
// Act
var item = new UploadItem(fileInfoMock.Object, skynetPath);
// Assert
Assert.That(item.SkynetPath, Is.EqualTo(skynetPath));
}
/// <summary>
/// 取得Bundle的上传地址.
/// 上传地址：<上传资源用URL>/<BuildMode>/<UploadDateTime>
/// </summary>
/// <returns>Bundle的上传地址.</returns>
/// <param name="iServerInfo">上传服务器信息.</param>
/// <param name="iUploadInfo">上传信息.</param>
public static string GetBundleUploadBaseURL(
UploadServerInfo iServerInfo, UploadItem iUploadInfo)
{
string uploadBaseUrl = GetUploadBaseURL(iServerInfo);
string bundleUploadUrl = string.Format("{0}/{1}",
uploadBaseUrl,
UploadList.GetBundleRelativePath((TBundleType.Scene == iUploadInfo.BundleType)));
// UtilsLog.Info ("GetBundleUploadBaseURL", "BundleUploadUrl:{0}", bundleUploadUrl);
return(bundleUploadUrl);
}
public async Task UploadFile_FromUploadItemDifferentContentType_ExpectedSkylink()
{
// Arrange
var file = new PhysicalFileInfo(new FileInfo("assets/test-file.json"));
var item = new UploadItem(file, contentType: new MediaTypeHeaderValue("text/xml"));
// Act
var skylink = await _skynetWebPortal.UploadFile(item);
// Assert
Assert.That(skylink.ToString() == "AABDI5UpS0B8tuxKBOiwwKEULV7V4Ln_aBdPPFLWpTlFhA");
}
public void Construction_FileInfo_IsSet()
{
// Arrange
var fileInfoMock = new Mock <IFileInfo>().SetupValidFile();
var fileInfo = fileInfoMock.Object;
// Act
var item = new UploadItem(fileInfo);
// Assert
Assert.That(item.FileInfo, Is.EqualTo(fileInfo));
}
private static async Task <HttpResponseMessage> Upload(Stream stream, UploadItem ui)
{
using (var client = new HttpClient())
{
string host = "https://s3.amazonaws.com";
client.BaseAddress = new Uri(host);
string uri = ui.upload_uri.Substring(host.Length);
HttpResponseMessage response = await client.PutAsync(uri, new StreamContent(stream));
return(response);
}
}
protected void btnUpload_Click(object sender, EventArgs e)
{
UploadItem info = new UploadItem("erweima", flImg);
string url = UploadHelper.Upload(info);
if (DN.WeiAd.Business.Config.AppConfig.AliYunIsSave)
{
string path = Server.MapPath(url);
string fileName = Path.GetFileName(path);
url = DN.WeiAd.Business.Utilty.AliYunOssClientHelper.PutObject(fileName, path);
}
imgPreview.ImageUrl = url;
}
public async Task UploadFile_UploadItemIsNotNull_ReturnsSkylink()
{
// Arrange
using var httpClient = SetUpHttpClientThatReturns(HttpStatusCode.OK, JsonSerializer.Serialize(ValidUploadResponse));
var webPortalClient = new SkynetWebPortal(httpClient);
var fileMock = new Mock <IFileInfo>().SetupValidFile();
var uploadItem = new UploadItem(fileMock.Object);
// Act
var response = await webPortalClient.UploadFile(uploadItem);
// Assert
Assert.That(response, Is.EqualTo(Skylink.Parse(ValidUploadResponse.Skylink)));
}
public void UploadFile_UploadItemIsNotNull_ThrowsNothing()
{
// Arrange
using var httpClient = SetUpHttpClientThatReturns(HttpStatusCode.OK, JsonSerializer.Serialize(ValidUploadResponse));
var webPortalClient = new SkynetWebPortal(httpClient);
var fileMock = new Mock <IFileInfo>().SetupValidFile();
var uploadItem = new UploadItem(fileMock.Object);
// Act
Task UploadRequest() => webPortalClient.UploadFile(uploadItem);
// Assert
Assert.That(UploadRequest, Throws.Nothing);
}
public string GetBestSource(UploadItem item)
{
switch (SelectionMode)
{
case SourceSelectionMode.RandomWithAbsoluteErrorCount:
return(RandomWithAbsoluteErrorCountSelection(item.Content.SystemPaths));
case SourceSelectionMode.HashBasedWithErrorThresold:
return(HashBasedWithErrorThresoldSelection(item.Content.Magnet.TTH, item.Content.SystemPaths));
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Generates the lines.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>A <see cref="IEnumerable{T}"/> of <see cref="string"/>.</returns>
private static IEnumerable <string> GenerateLines(UploadItem item)
{
return(new List <string>
{
Path.GetFileNameWithoutExtension(item.FileName),
Path.GetFileNameWithoutExtension(item.NewFileName),
"[color=#FF0000]Passwort:[/color] [quote]" + item.Password + "[/quote]",
"[color=#FF0000]Links:[/color]",
"[list]",
"[*]Download: [url]" + item.MegaLink + "[/url]",
"[*]Backup: [url]" + item.GDriveLink + "[/url]",
"[*]Backup2: [url]" + item.FilehorstLink + "[/url]",
"[/list]"
});
}
public void Run_Test()
{
var file = new MemoryFileInfo("Hello from uploader...");
var uploadItem = new UploadItem(file);
var handler = new LocalUploadHandler();
var completed = false;
var task = new Task(handler, uploadItem);
task.Run(() =>
{
completed = true;
});
Assert.IsTrue(completed);
}
//would need renaming if made public
async Task <NewMediaItemResult?> AddMediaItemAsync(UploadItem uploadItem, string?albumId, AlbumPosition?albumPosition)
{
var newMediaItems = new List <UploadItem> {
uploadItem
};
var res = await AddMediaItemsAsync(newMediaItems, albumId, albumPosition);
if (res is object && !res.newMediaItemResults.IsNullOrEmpty())
{
return(res.newMediaItemResults[0]);
}
else
{
_logger.LogError($"Upload failure, {uploadItem.fileName}");
return(null);
}
}
public async Task <IActionResult> Post(UploadItem model, IFormFile fileToUpload)
{
if (fileToUpload != null)
{
// limit size to 100MB
if (fileToUpload.Length > 104857600)
{
return(BadRequest("File is to large. Allowed size < 100MB"));
}
var privateFileName = Hash.GetSecureToken(_rndProvider);
var safeFileName = WebUtility.HtmlEncode(Path.GetFileName(fileToUpload.FileName));
var fileExtension = Path.GetExtension(safeFileName);
if (!string.IsNullOrEmpty(fileExtension))
{
privateFileName += fileExtension;
}
var basePath = Path.Combine("wwwroot", "Uploads");
var filePath = Path.Combine(basePath, privateFileName);
using (var memStream = new MemoryStream())
{
await fileToUpload.CopyToAsync(memStream);
var byteData = _protector.EncryptStream(memStream);
Stream encryptedStream = new MemoryStream(byteData);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
await encryptedStream.CopyToAsync(fileStream);
}
}
model.Token = $"https://{Request.Host}/upload/" + privateFileName;
_context.UploadItems.Add(new UploadItem {
Token = privateFileName, OriginalName = safeFileName,
CreatedDate = DateTime.Now, ExpiredBy = DateTime.Now + TimeSpan.FromMinutes(5)
});
_context.SaveChanges();
}
return(View("~/Views/Upload/Index.cshtml", model));
}
private void displayUploadingInfo()
{
List <UploadItemVO> voList = uploadHelper.voList;
foreach (UploadItemVO vo in voList)
{
UploadInfoComps comps = new UploadInfoComps();
comps.vo = vo;
if (comps.vo.status == "success")
{
addSuccessItem(comps.vo);
}
else
{
UploadItem item = new UploadItem(this, comps, uploadHelper, floatWin);
itemDic[vo.name] = item;
}
}
}
