private bool InitParameter(UploadParameter data)
{
if (!CommonFunction.IsNetworkAvailable())//Check Network before publish
{
System.Windows.MessageBox.Show(GlobalData.FindResource("Publish_Window_S_ErrorMessage"));
return(false);
}
IDocumentService doc = ServiceLocator.Current.GetInstance <IDocumentService>();
if (doc != null && doc.Document != null)
{
Guid sGUID = doc.Document.Guid;
data.id = ConfigFileManager.GetSectionValue(ConstData.sRemoteID, sGUID.ToString());
data.ProjectPassword = ConfigFileManager.GetSectionValue(ConstData.sProjectPassword, sGUID.ToString());
data.DocGUID = sGUID.ToString();
doc.Document.GeneratorConfigurationSet.DefaultHtmlConfiguration.CurrentPage = Guid.Empty;
}
if (String.IsNullOrEmpty(data.id))
{
return(true);
}
else
{
return(HttpGetFileInfo(data));
}
}
public ActionResult UploadImage()
{
var files = HttpContext.Request.Files;
if (files == null || files.Count < 1)
{
return(Json(new LayuiUploadImageOut(1, "没有找到上传图片")));
}
UploadParameter p = new UploadParameter(files[0]);
string path = "/UploadFiles/ArticleImages/{0}/{1}";
path = string.Format(path, DateTime.Now.ToDateString(), p.GetDefaultFileName());
p.SavePath = HttpContext.Server.MapPath(path);
var result = UploadHelper.UploadFile(UploadType.IMAGE, p);
if (result.Status == UploadStatus.Success)
{
var image = new LayuiUploadImageOut(0, result.Msg, path);
return(Json(image));
}
else
{
var image = new LayuiUploadImageOut(1, result.Msg);
return(Json(image));
}
}
private void UploadMD5HtmlEventHandler(Object para)
{
_docArray = para as List <IDocumentService>;
if (_uploadState == UploadState.upload_End)
{
_uploadState = UploadState.upload_Init;
_upLoadPara = new UploadParameter();
if (!InitMD5Parameter(_upLoadPara, _docArray))
{
_uploadState = UploadState.upload_End;
return;
}
_upLoadPara.DocArray = _docArray;
var prePublish = new PrePublishViewModel(_upLoadPara);
prePublish.Initwindow();
prePublish.Closing += PrePublish_Closing;
// //Switch to PublishSetView
_differView.Current = prePublish;
}
else
{
//ReShowProgressWindow();
}
}
public void ShouldUploadStreamWithCompleteDetails()
{
var param = UploadParameter.CreateForStreamUpload(
StreamParameterData.Create(() => new FileStream(TestTextFile, FileMode.Open, FileAccess.Read),
"stream description",
"stream name", "text/plain", new Dictionary <string, string> {
{ "streamkey", "streamval" }
}),
AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result.TransactionHash);
Assert.AreEqual(result.Data.ContentType, "text/plain");
Assert.IsNotNull(result.Data.DataHash);
Assert.AreEqual(result.Data.Description, "stream description");
Assert.AreEqual(result.Data.Name, "stream name");
Assert.AreEqual(result.Data.Metadata.Count, 1);
Assert.IsFalse(result.Data.Metadata.Except(new Dictionary <string, string> {
{ "streamkey", "streamval" }
})
.Any());
Assert.IsNotNull(result.Data.Timestamp);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadStreamWithCompleteDetails");
}
public void ShouldUploadFilesAsZipWithCompleteDetails()
{
var param = UploadParameter.CreateForFilesAsZipUpload(
FilesAsZipParameterData.Create(new List <string> {
TestTextFile, TestHtmlFile
}, "zip description",
"zip name", new Dictionary <string, string> {
{ "zipkey", "zipvalue" }
}),
AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result.TransactionHash);
Assert.AreEqual(result.Data.ContentType, "application/zip");
Assert.IsNotNull(result.Data.DataHash);
Assert.AreEqual(result.Data.Description, "zip description");
Assert.AreEqual(result.Data.Name, "zip name");
Assert.AreEqual(result.Data.Metadata.Count, 1);
Assert.IsFalse(result.Data.Metadata.Except(new Dictionary <string, string> {
{ "zipkey", "zipvalue" }
}).Any());
Assert.IsNotNull(result.Data.Timestamp);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadFilesAsZipWithCompleteDetails");
}
public void ShouldUploadStringWithCompleteDetails()
{
var param = UploadParameter.CreateForStringUpload(
StringParameterData.Create(TestString, Encoding.UTF8, "string description", "string name",
"text/plain", new Dictionary <string, string> {
{ "keystring", "valstring" }
}),
AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result.TransactionHash);
Assert.AreEqual(result.Data.ContentType, "text/plain");
Assert.IsNotNull(result.Data.DataHash);
Assert.AreEqual(result.Data.Description, "string description");
Assert.AreEqual(result.Data.Name, "string name");
Assert.AreEqual(result.Data.Metadata.Count, 1);
Assert.IsFalse(result.Data.Metadata.Except(new Dictionary <string, string> {
{ "keystring", "valstring" }
})
.Any());
Assert.IsNotNull(result.Data.Timestamp);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadStringWithCompleteDetails");
}
public void ShouldUploadPathWithCompleteDetails()
{
var param = UploadParameter.CreateForPathUpload(
PathParameterData.Create(TestPathFile, "path description", "path name",
new Dictionary <string, string> {
{ "pathkey", "pathval" }
}),
AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result.TransactionHash);
Assert.AreEqual(result.Data.ContentType, PathUploadContentType);
Assert.IsNotNull(result.Data.DataHash);
Assert.AreEqual(result.Data.Description, "path description");
Assert.AreEqual(result.Data.Name, "path name");
Assert.AreEqual(result.Data.Metadata.Count, 1);
Assert.IsFalse(result.Data.Metadata.Except(new Dictionary <string, string> {
{ "pathkey", "pathval" }
}).Any());
Assert.IsNotNull(result.Data.Timestamp);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadPathWithCompleteDetails");
}
private string DetectContentType(UploadParameter uploadParam,
IByteStreamParameterData byteStreamParamData)
{
return(uploadParam.DetectContentType && byteStreamParamData.ContentType == null
? byteStreamParamData.GetByteStream().DetectContentType()
: byteStreamParamData.ContentType);
}
/// <summary>
/// 上传多媒体文件，返回上传成功的media_id，否则null
/// </summary>
/// <param name="filePathName">包括完整路径的文件名</param>
/// <param name="fileData">文件数据</param>
/// <param name="fileType">文件类型：图片（image）、语音（voice）、视频（video）和缩略图（thumb，主要用于视频与音乐格式的缩略图）</param>
/// <returns>上传成功的media_id，否则null</returns>
public MediaFile UploadMediaFile(string filePathName, string fileType)
{
//上传的多媒体文件有格式和大小限制，如下：
//图片（image）: 1M，支持JPG格式
//语音（voice）：2M，播放长度不超过60s，支持AMR\MP3格式
//视频（video）：10MB，支持MP4格式
//缩略图（thumb）：64KB，支持JPG格式
//媒体文件在后台保存时间为3天，即3天后media_id失效
string url = "http://file.api.weixin.qq.com/cgi-bin/media/upload?access_token={0}&type={1}";
Stream fileStream = new FileStream(filePathName, FileMode.Open, FileAccess.Read);
UploadParameter uploadParam = new UploadParameter()
{
FileNameValue = Path.GetFileName(filePathName),
UploadStream = fileStream
};
url = string.Format(url, Connect.GetAccessToken(), fileType);
uploadParam.Url = url;
string resultStr = SimulateRequest.UploadFile(uploadParam);
var resultObj = JsonConvert.DeserializeObject <JObject>(resultStr);
if (resultObj["errcode"] != null && resultObj["errcode"].ToString() != "0")
{
_logObj.Error("上传多媒体文件UploadMediaFile()，微信服务报错");
var errorCode = new WeixinErrorInfo(resultObj["errcode"].ToString());
_logObj.Warn(string.Format("{0}【errmsg：{1}】", errorCode.ToString(), resultObj["errmsg"].ToString()));
return(null);
}
else
{
_logObj.InfoFormat("上传多媒体文件UploadMediaFile()，微信处理成功");
MediaFile mediaFile = JsonConvert.DeserializeObject <MediaFile>(resultStr);
return(mediaFile);
}
}
public void ShouldUploadByteArrayWithCompleteDetails()
{
var param = UploadParameter.CreateForByteArrayUpload(
ByteArrayParameterData.Create(TestByteArray, "byte array description", "byte array",
"text/plain", new Dictionary <string, string> {
{ "bytearraykey", "bytearrayval" }
}),
AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.IsNotNull(result.TransactionHash);
Assert.AreEqual(result.Data.ContentType, "text/plain");
Assert.IsNotNull(result.Data.DataHash);
Assert.AreEqual(result.Data.Description, "byte array description");
Assert.AreEqual(result.Data.Name, "byte array");
Assert.AreEqual(result.Data.Metadata.Count, 1);
Assert.IsFalse(result.Data.Metadata
.Except(new Dictionary <string, string> {
{ "bytearraykey", "bytearrayval" }
}).Any());
Assert.IsNotNull(result.Data.Timestamp);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadByteArrayWithCompleteDetails");
}
public void ShouldUploadUrlResourceWithCompleteDetails()
{
var param = UploadParameter.CreateForUrlResourceUpload(
UrlResourceParameterData.Create(FileUrlFromRelativePath(TestImagePngFile), "url description",
"url name", "image/png", new Dictionary <string, string> {
{ "urlkey", "urlval" }
}),
AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result.TransactionHash);
Assert.AreEqual(result.Data.ContentType, "image/png");
Assert.IsNotNull(result.Data.DataHash);
Assert.AreEqual(result.Data.Description, "url description");
Assert.AreEqual(result.Data.Name, "url name");
Assert.AreEqual(result.Data.Metadata.Count, 1);
Assert.IsFalse(result.Data.Metadata.Except(new Dictionary <string, string> {
{ "urlkey", "urlval" }
}).Any());
Assert.IsNotNull(result.Data.Timestamp);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadUrlResourceWithCompleteDetails");
}
public void FailUploadWhenSignerHasNoFunds()
{
var param = UploadParameter
.CreateForStringUpload(TestString, "345247BEEE41EAF0658530777EC49BA2F74CA849B6A24FDF558B83ABEB8D9DC8")
.Build();
UnitUnderTest.Upload(param);
}
private bool HttpGetFileInfo(UploadParameter para)
{
try
{
if (!CommonFunction.IsNetworkAvailable())
{
return(false);
}
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(ConstData.uploadURL + para.id);
request.Referer = ConstData.uploadReferer;
request.Headers.Add(ConstData.uploadVersionName, CommonFunction.GetClientCurrentVersion());
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
// Get the stream containing content returned by the server.
Stream dataStream = response.GetResponseStream();
var serializer = new DataContractJsonSerializer(typeof(GetFileResponseData));
GetFileResponseData data = (GetFileResponseData)serializer.ReadObject(dataStream);
if (data != null)
{
if (data.is_exist)
{
para.sShortURL = data.shortUrl;
if (!String.IsNullOrEmpty(data.updatedAt))
{
para.sTime = data.updatedAt.Substring(0, data.updatedAt.IndexOf("T"));
}
else
{
para.sTime = data.createdAt.Substring(0, data.createdAt.IndexOf("T"));
}
para.IsPublic = data.is_public;
}
else
{
para.id = "";
para.ProjectPassword = "";
}
}
else
{
System.Windows.MessageBox.Show(GlobalData.FindResource("Error_Server_response"));
return(false);
}
}
catch (System.Exception ex)
{
// NLogger.Error("HttpGetFileInfo exception->"+ex.Message);
return(false);
}
return(true);
}
public IObservable <ProximaxMessagePayloadModel> CreateMessagePayload(UploadParameter uploadParameter,
ProximaxDataModel uploadedData)
{
CheckParameter(uploadParameter != null, "uploadParameter is required");
CheckParameter(uploadedData != null, "uploadedData is required");
return(Observable.Return(ProximaxMessagePayloadModel.Create(
uploadParameter.PrivacyStrategy.GetPrivacyType(),
uploadParameter.Version, uploadedData)));
}
private IObservable <ProximaxDataModel> UploadByteStream(UploadParameter uploadParam,
IByteStreamParameterData byteStreamParamData)
{
var detectedContentType = DetectContentType(uploadParam, byteStreamParamData);
var fileUploadResponseOb = FileUploadService.UploadByteStream(byteStreamParamData.GetByteStream,
uploadParam.PrivacyStrategy, uploadParam.ComputeDigest);
return(fileUploadResponseOb.Select(fileUploadResponse =>
ProximaxDataModel.Create(byteStreamParamData, fileUploadResponse.DataHash,
fileUploadResponse.Digest, detectedContentType, fileUploadResponse.Timestamp)));
}
public void ShouldUploadToStorageConnection()
{
var param = UploadParameter.CreateForStringUpload(TestString, AccountPrivateKey1).Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.IsNotNull(result.Data.DataHash);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadToStorageConnection");
}
public void ShouldReturnVersion()
{
var param = UploadParameter.CreateForStringUpload(
TestString, AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.AreEqual(result.Version, SchemaVersion);
LogAndSaveResult(result, GetType().Name + ".ShouldReturnVersion");
}
public void ShouldUploadFileWithCustomPrivacyStrategy()
{
var param = UploadParameter.CreateForFileUpload(TestTextFile, AccountPrivateKey1)
.WithPrivacyStrategy(new MyPrivacyStrategy())
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.IsNotNull(result.TransactionHash);
Assert.IsNotNull(result.Data.DataHash);
Assert.AreEqual(result.PrivacyType, (int)PrivacyType.Custom);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadFileWithCustomPrivacyStrategy");
}
public void ShouldUploadAsynchronouslyWithoutCallback()
{
var param = UploadParameter
.CreateForFileUpload(TestPdfFile2, AccountPrivateKey1)
.Build();
var asyncTask = UnitUnderTest.UploadAsync(param, null);
while (!asyncTask.IsDone())
{
Thread.Sleep(50);
}
Assert.IsTrue(asyncTask.IsDone());
}
public void ShouldUploadWithEmptyTransactionMosaicsProvided()
{
var param = UploadParameter
.CreateForStringUpload(TestString, AccountPrivateKey1)
.WithTransactionMosaics(new List <Mosaic>())
.Build();
var result = UnitUnderTest.Upload(param);
var transaction = WaitForTransactionConfirmation(AccountPrivateKey1, result.TransactionHash);
Assert.IsTrue(transaction is TransferTransaction);
Assert.AreEqual((transaction as TransferTransaction).Mosaics.Count, 1);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadWithEmptyTransactionMosaicsProvided");
}
public void ShouldUploadWithSignerAsRecipientByDefault()
{
var param = UploadParameter
.CreateForStringUpload(TestString, AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.IsNotNull(result.TransactionHash);
var transaction = WaitForTransactionConfirmation(AccountPrivateKey1, result.TransactionHash);
Assert.IsTrue(transaction is TransferTransaction);
Assert.AreEqual((transaction as TransferTransaction).Recipient.Address.Plain, AccountAddress1);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadWithSignerAsRecipientByDefault");
}
public IObservable <ProximaxDataModel> CreateData(UploadParameter uploadParam)
{
CheckParameter(uploadParam != null, "uploadParam is required");
switch (uploadParam.Data)
{
case IByteStreamParameterData _: // when byte stream upload
return(UploadByteStream(uploadParam, (IByteStreamParameterData)uploadParam.Data));
case PathParameterData _: // when path upload
return(UploadPath((PathParameterData)uploadParam.Data));
default: // when unknown data
throw new UploadParameterDataNotSupportedException(
$"Uploading of {uploadParam.Data.GetType()} is not supported");
}
}
public void ShouldUploadAsynchronouslyWithFailureCallback()
{
var param = UploadParameter
.CreateForFileUpload(TestTextFile, AccountPrivateKey1)
.WithPrivacyStrategy(new NotImplementedPrivacyStrategy())
.Build();
var taskCompletionSource = new TaskCompletionSource <Exception>();
var asyncCallbacks = AsyncCallbacks <UploadResult> .Create <UploadResult>(
null, ex => taskCompletionSource.SetResult(ex));
UnitUnderTest.UploadAsync(param, asyncCallbacks);
taskCompletionSource.Task.Wait(5000);
var exception = taskCompletionSource.Task.Result;
Assert.IsInstanceOfType(exception, exception.GetType());
}
public void ShouldUploadAsynchronouslyWithSuccessCallback()
{
var param = UploadParameter
.CreateForFileUpload(TestTextFile, AccountPrivateKey1)
.Build();
var taskCompletionSource = new TaskCompletionSource <UploadResult>();
var asyncCallbacks = AsyncCallbacks <UploadResult> .Create <UploadResult>(
uploadResult => taskCompletionSource.SetResult(uploadResult), null);
UnitUnderTest.UploadAsync(param, asyncCallbacks);
taskCompletionSource.Task.Wait(5000);
var result = taskCompletionSource.Task.Result;
Assert.IsNotNull(result);
Assert.IsNotNull(result.TransactionHash);
}
public void ShouldUploadWithUseBlockchainSecureMessage()
{
var param = UploadParameter.CreateForStringUpload(
StringParameterData.Create(TestString, Encoding.UTF8, "string description", "string name",
"text/plain", new Dictionary <string, string> {
{ "keystring", "valstring" }
}),
AccountPrivateKey1)
.WithUseBlockchainSecureMessage(true)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.AreEqual(result.Version, SchemaVersion);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadWithUseBlockchainSecureMessage");
}
public void ShouldUploadPath()
{
var param = UploadParameter.CreateForPathUpload(TestPathFile, AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.IsNotNull(result.TransactionHash);
Assert.AreEqual(result.Data.ContentType, PathUploadContentType);
Assert.IsNotNull(result.Data.DataHash);
Assert.IsNull(result.Data.Description);
Assert.IsNull(result.Data.Name);
Assert.IsNull(result.Data.Metadata);
Assert.IsNotNull(result.Data.Timestamp);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadPath");
}
public AjaxResult UploadUserFace()
{
HttpFileCollection files = HttpContext.Current.Request.Files;
if (files == null || files.Count < 1)
{
return(new AjaxResult(false, "没有找到上传文件"));
}
UploadParameter p = new UploadParameter();
string tempPath = "/UploadFiles/UserFace";
string resultPath = "";
try
{
bool success = true;
string msg = "";
for (int i = 0; i < files.Count; i++)
{
var file = files[i];
p.File = new HttpPostedFileWrapper(file);
string fileName = p.GetDefaultFileName();
string path = string.Format("{0}/{1}", tempPath, fileName);
p.SavePath = HttpContext.Current.Server.MapPath(path);
var result = UploadHelper.UploadFile(UploadType.IMAGE, p);
if (result.Status == UploadStatus.Success)
{
success = true;
resultPath = path;
}
else
{
success = false;
}
msg = result.Msg;
}
return(new AjaxResult(success, msg, resultPath));
}
catch (Exception e)
{
return(new AjaxResult(false, "上传失败" + e.Message));
}
}
public void ShouldUploadWithTransactionDeadlinesProvided()
{
var param = UploadParameter
.CreateForStringUpload(TestString, AccountPrivateKey1)
.WithTransactionDeadline(2)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.IsNotNull(result.TransactionHash);
var transaction = WaitForTransactionConfirmation(AccountPrivateKey1, result.TransactionHash);
Assert.IsTrue(transaction is TransferTransaction);
Assert.IsTrue((transaction as TransferTransaction).Deadline.Ticks <=
Deadline.Create(2).Ticks);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadWithTransactionDeadlinesProvided");
}
public void ShouldUploadUrlResource()
{
var param = UploadParameter.CreateForUrlResourceUpload(
FileUrlFromRelativePath(TestImagePngFile), AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.IsNotNull(result.TransactionHash);
Assert.IsNull(result.Data.ContentType);
Assert.IsNotNull(result.Data.DataHash);
Assert.IsNull(result.Data.Description);
Assert.IsNull(result.Data.Name);
Assert.IsNull(result.Data.Metadata);
Assert.IsNotNull(result.Data.Timestamp);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadUrlResource");
}
public void ShouldUploadStream()
{
var param = UploadParameter.CreateForStreamUpload(
() => new FileStream(TestTextFile, FileMode.Open, FileAccess.Read), AccountPrivateKey1)
.Build();
var result = UnitUnderTest.Upload(param);
Assert.IsNotNull(result);
Assert.IsNotNull(result.TransactionHash);
Assert.IsNull(result.Data.ContentType);
Assert.IsNotNull(result.Data.DataHash);
Assert.IsNull(result.Data.Description);
Assert.IsNull(result.Data.Name);
Assert.IsNull(result.Data.Metadata);
Assert.IsNotNull(result.Data.Timestamp);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadStream");
}
