public void UploadFile_Succeeds()
{
// Arrange
const int FileSize = 500;
const string FileName = "MyFile.bin";
byte[] data = new byte[FileSize];
// Act
FileUploadResponse fileUploadResponse = null;
using (var sync = new InSync(nameof(SlackClient.UploadFile)))
{
this.fixture.UserClient.UploadFile(c =>
{
fileUploadResponse = c;
Assert.True(c.ok);
sync.Proceed();
},
data, FileName, new[] { this.fixture.Config.TestChannel });
}
// Assert
using (var sync = new InSync(nameof(SlackClient.UploadFile)))
{
this.fixture.UserClient.GetFileInfo(c =>
{
Assert.True(c.ok);
Assert.Equal(FileSize, c.file.size);
Assert.Equal(FileName, c.file.name);
Assert.Equal(new[] { this.fixture.Config.TestChannel }, c.file.channels);
sync.Proceed();
}, fileUploadResponse.file.id);
}
}
private void FileUploadRequestHandler(FileUploadRequest request)
{
FileUploadResponse response = new FileUploadResponse(request);
if (request.CurrentPosition == 0)
{
EventArguments.FileUploadRequestEventArguments args = new EventArguments.FileUploadRequestEventArguments(() =>
{
//Confirm File Upload
response.DestinationFilePath = request.DestinationFilePath;
SendMessage(response);
},
() =>
{
//Refuse File Upload
response.HasError = true;
response.Exception = new Exception("The file upload request was refused by the user!");
SendMessage(response);
});
args.Request = request;
OnFileUploadRequest(args);
}
else
{
Helpers.FileHelper.AppendAllBytes(request.DestinationFilePath, request.BytesToWrite);
SendMessage(response);
OnUploadFileProgress(new EventArguments.FileUploadProgressEventArguments()
{
CurrentPosition = request.CurrentPosition, FileName = request.FileName, TotalBytes = request.TotalBytes, DestinationPath = request.DestinationFilePath
});
}
}
public void TestUploadFile()
{
// 接口请求
FileUploadRequest request = new FileUploadRequest();
// 请求参数
GoodsParam param = new GoodsParam();
// 属性赋值
param.goods_name = "iphone6";
// 设置请求参数
request.Param = param;
List <UploadFile> files = new List <UploadFile>();
files.Add(new UploadFile("headImg", @"D:\1.txt"));
files.Add(new UploadFile("idcardImg", @"D:\2.txt"));
request.Files = files;
// 发送请求，返回结果
FileUploadResponse response = client.Execute <FileUploadResponse>(request);
if (response.IsSuccess())
{
Assert.IsTrue(response.data != null);
}
else
{
throw new SystemException(response.msg);
}
}
public void CleanMessageQueueFromFile(FileUploadResponse response)
{
lock (MessageQueue)
{
MessageQueue.RemoveAll(x => (x is FileUploadResponse) && ((x as FileUploadResponse).DestinationFilePath == response.DestinationFilePath));
}
}
public UploadFileModule(IFileUploadHandler fileUploadHandler, ILocalFileServer LocalFileServer)
: base("/file")
{
// It requires you to be an admin to upload
this.fileUploadHandler = fileUploadHandler;
this.fileServer = LocalFileServer;
Get("/", async args =>
{
var list = await this.fileServer.ListFiles();
var res = new
{
Status = "success",
Data = list
};
return(Response.AsJson(res));
});
Post("/upload", async parameters =>
{
this.RequiresAuthentication();
this.RequiresClaims(c => c.Value.Equals("admin"));
var request = this.Bind <FileUploadRequest>();
var uploadResult = await fileUploadHandler.HandleUpload(request.File.Name, request.File.Value);
var response = new FileUploadResponse()
{
Identifier = uploadResult.Identifier
};
return(Negotiate
.WithStatusCode(HttpStatusCode.OK)
.WithModel(response));
});
}
/// <summary>
/// 上传模板文件
/// </summary>
public void uploadTemplate()
{
try
{
FileUploadRequest fileUploadRequest = new FileUploadRequest("D://telmplate//劳动合同模板.pdf", "劳动合同模板.pdf", FileType.template, "00765245060136194048");
FileUploadResponse response = client.fileUpload(fileUploadRequest);
Console.WriteLine("上传模板文件-响应数据:" + JSONUtil.getJsonStringFromObject(response));
}
catch (SignApplicationException sae)
{
// 捕获网关校验数据
Console.WriteLine("上传模板文件-网关异常状态码为：" + sae.return_code);
Console.WriteLine("上传模板文件-网关异常信息为：" + sae.return_message);
}
catch (SignServerException sse)
{
// 捕获网关校验数据
Console.WriteLine("上传模板文件-业务异常状态码为：" + sse.result_code);
Console.WriteLine("上传模板文件-业务异常信息为：" + sse.result_message);
}
catch (Exception e)
{
Console.WriteLine("上传模板文件-异常：" + e.Message);
}
}
/// <summary>
/// 文件上传
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public FileUploadResponse fileUpload(FileUploadRequest request)
{
if (
request.fileData == null || request.fileData.Length == 0 ||
request.fileDataName == null || request.fileDataName.Trim() == string.Empty
)
{
BaseSignResponse baseSignResponse = new BaseSignResponse();
baseSignResponse.result_code = "4001";
baseSignResponse.result_message = "参数校验异常";
throw new SignServerException("参数校验异常", baseSignResponse, null);
}
FileInfo info = new FileInfo();
info.fileData = request.fileData;
info.fileName = request.fileName;
info.key = "file";
Dictionary <string, string> @params = new Dictionary <string, string>();
@params.Add("file_type", request.fileType);
@params.Add("file_name", request.fileName);
@params.Add("user_id", request.userId);
FileUploadResponse fileUploadResponse = base.FileUpload <FileUploadResponse>(ApiUrlConstant.FileManager.FileUpload, info, @params);
return(fileUploadResponse);
}
/// <summary>
/// 上传印章文件
/// </summary>
public void uploadSeal()
{
try
{
FileUploadRequest fileUploadRequest = new FileUploadRequest("D:/seal/seal.png", "我的印章.png", FileType.impression, "00765245060136194048");
FileUploadResponse response = client.fileUpload(fileUploadRequest);
Console.WriteLine("上传印章文件-响应数据:" + JSONUtil.getJsonStringFromObject(response));
}
catch (SignApplicationException sae)
{
// 捕获网关校验数据
Console.WriteLine("上传印章文件-网关异常状态码为：" + sae.return_code);
Console.WriteLine("上传印章文件-网关异常信息为：" + sae.return_message);
}
catch (SignServerException sse)
{
// 捕获网关校验数据
Console.WriteLine("上传印章文件-业务异常状态码为：" + sse.result_code);
Console.WriteLine("上传印章文件-业务异常信息为：" + sse.result_message);
}
catch (Exception e)
{
Console.WriteLine("上传印章文件-异常：" + e.Message);
}
}
public static void UploadAttachments(string DocPath, string FileName)
{
FileUploadResponse fileUploadResponse = null;
if (!string.IsNullOrEmpty(DocPath))
{
var downFileResponse = DownloadFileAttachment(DocPath, FileName);
if (downFileResponse != null && downFileResponse.FileBytes.IsValid())
{
if (downFileResponse.FileBytes.Length > 0)
{
using (var stream = new MemoryStream(downFileResponse.FileBytes))
{
fileUploadResponse = UploadToFileSystem(FileName, stream);
}
}
if (fileUploadResponse.IsValid() && fileUploadResponse.IsSuccess)
{
var Attchment = MapDownloadAttachment(fileUploadResponse);
DBUtil.Instance.UpdateAttachmentData(Attchment);
}
}
else
{
throw new System.Exception("File Upload : " + FileName + " has no data");
}
}
else
{
throw new System.Exception("LetterStream is missing");
}
}
private static PayerHospActionAttachment MapDownloadAttachment(FileUploadResponse fileUploadResponse)
{
return(new PayerHospActionAttachment()
{
AttachName = fileUploadResponse.UploadedDetails[0].FileName, AttachPath = fileUploadResponse.UploadedDetails[0].FileGuid
});
}
/// <summary>
/// Uploads a file, if the request fails this overload will delete the note record
/// </summary>
/// <param name="module">Notes</param>
/// <param name="id">Record ID</param>
/// <param name="filePath">Path to file on local disk</param>
/// <param name="deleteOnFailure">Bool: deletes record if upload fails</param>
/// <returns>Bool</returns>
public bool UploadFile(string module, string id, string filePath, bool deleteOnFailure)
{
var request = new RestRequest("{module}/{id}/file/filename", Method.POST);
request.AddUrlSegment("module", module);
request.AddUrlSegment("id", id);
request.AddParameter("format", "sugar-html-json");
request.AddParameter("delete_if_fails", deleteOnFailure);
if (deleteOnFailure)
{
request.AddParameter("oauth_token", Token);
}
if (!File.Exists(filePath))
{
//@todo create a SugarFileException class
throw new SugarException("Can not locate file path. Path attempted = " + filePath);
}
request.AddFile("filename", filePath);//?
FileUploadResponse response = Execute <FileUploadResponse>(request);
return(!string.IsNullOrEmpty(response.filename.name));
}
FileUploadResponse MakeRequest(string url, string tag, MultipartBuilder requestBodyBuilder, IDictionary <string, string> headers = null)
{
//RequestBody requestBody = requestBodyBuilder.Build();
CountingRequestBody requestBody = new CountingRequestBody(requestBodyBuilder.Build(), tag, this);
var requestBuilder = new Request.Builder();
if (headers != null)
{
foreach (string key in headers.Keys)
{
if (!string.IsNullOrEmpty(headers[key]))
{
requestBuilder = requestBuilder.AddHeader(key, headers[key]);
}
}
}
Request request = requestBuilder
.Url(url)
.Post(requestBody)
.Build();
OkHttpClient client = new OkHttpClient();
client.SetConnectTimeout(ConnectUploadTimeout, UploadTimeoutUnit); // connect timeout
client.SetReadTimeout(SocketUploadTimeout, UploadTimeoutUnit); // socket timeout
Response response = client.NewCall(request).Execute();
var responseString = response.Body().String();
var code = response.Code();
IDictionary <string, string> responseHeaders = new Dictionary <string, string>();
var rHeaders = response.Headers();
if (rHeaders != null)
{
var names = rHeaders.Names();
foreach (string name in names)
{
if (!string.IsNullOrEmpty(rHeaders.Get(name)))
{
responseHeaders.Add(name, rHeaders.Get(name));
}
}
}
FileUploadResponse fileUploadResponse = new FileUploadResponse(responseString, code, tag, new ReadOnlyDictionary <string, string>(responseHeaders));
if (response.IsSuccessful)
{
FileUploadCompleted(this, fileUploadResponse);
}
else
{
FileUploadError(this, fileUploadResponse);
}
return(fileUploadResponse);
}
/// <summary>
/// Pushes the file.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">file request</exception>
/// <exception cref="System.Exception">
/// </exception>
public PushResponse PushFile(PushFileRequest request)
{
try
{
#region pre-processing
if (request == null)
{
throw new ArgumentNullException("file request");
}
if (string.IsNullOrWhiteSpace(request.DeviceIden) && string.IsNullOrWhiteSpace(request.Email))
{
throw new Exception(PushbulletConstants.PushRequestErrorMessages.EmptyEmailProperty);
}
if (string.IsNullOrWhiteSpace(request.FileName))
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.EmptyFileNameProperty);
}
if (string.IsNullOrWhiteSpace(request.FileType))
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.EmptyFileTypeProperty);
}
if (request.FileStream == null)
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.EmptyFileStreamProperty);
}
if (!request.FileStream.CanRead)
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.CantReadFileStreamProperty);
}
#endregion pre-processing
#region processing
FileUploadResponse uploadRequestResponse = PostRequest <FileUploadResponse>(string.Concat(PushbulletConstants.BaseUrl, PushbulletConstants.FileUrls.UploadRequest), request);
if (uploadRequestResponse.Data == null || string.IsNullOrWhiteSpace(uploadRequestResponse.FileUrl))
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.ErrorMakingFileUploadRequest);
}
PushFileToAmazonAWS(request, uploadRequestResponse);
request.FileUrl = uploadRequestResponse.FileUrl;
return(PostPushRequest <PushFileRequest>(request));
#endregion processing
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Pushes the file.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">file request</exception>
public PushResponse PushFile(PushFileRequest request)
{
try
{
#region pre-processing
if (request == null)
{
throw new ArgumentNullException("file request");
}
if (string.IsNullOrWhiteSpace(request.device_iden) && string.IsNullOrWhiteSpace(request.email))
{
throw new Exception(PushbulletConstants.PushRequestErrorMessages.EmptyEmailProperty);
}
if (string.IsNullOrWhiteSpace(request.file_name))
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.EmptyFileNameProperty);
}
if (string.IsNullOrWhiteSpace(request.file_type))
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.EmptyFileTypeProperty);
}
if (request.file_stream == null)
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.EmptyFileStreamProperty);
}
if (!request.file_stream.CanRead)
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.CantReadFileStreamProperty);
}
#endregion pre-processing
#region processing
FileUploadResponse uploadRequestResponse = PostFileUploadRequest(request);
if (uploadRequestResponse.data == null || string.IsNullOrWhiteSpace(uploadRequestResponse.file_url))
{
throw new Exception(PushbulletConstants.PushFileErrorMessages.ErrorMakingFileUploadRequest);
}
PushFileToAmazonAWS(request, uploadRequestResponse);
request.file_url = uploadRequestResponse.file_url;
return(PostPushRequest(JsonSerializer.Serialize(request)));
#endregion processing
}
catch (Exception)
{
throw;
}
}
public FileUploadResponse FileUpload(FileUploadRequest req)
{
var rep = new FileUploadResponse();
var context = httpContextAccessor.HttpContext;
var files = context.Request.Form.Files;
return(rep);
}
/// <summary>
/// Posts the file upload request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
private FileUploadResponse PostFileUploadRequest(PushFileRequest request)
{
string requestJson = JsonSerializer.Serialize(request);
string responseJson = PostRequest(string.Concat(PushbulletConstants.BaseUrl, PushbulletConstants.FileUrls.UploadRequest), requestJson);
FileUploadResponse response = JsonSerializer.Deserialize <FileUploadResponse>(responseJson);
return(response);
}
public async Task <FileUploadResponse> UploadFileAsync(string url, FilePathItem[] fileItems, string tag, IDictionary <string, string> headers = null, IDictionary <string, string> parameters = null, string boundary = null)
{
if (fileItems == null || fileItems.Length == 0)
{
var fileUploadResponse = new FileUploadResponse("There are no items to upload", -1, tag, null);
FileUploadError(this, fileUploadResponse);
return(fileUploadResponse);
}
bool error = false;
string errorMessage = string.Empty;
var uploadItems = new List <UploadFileItemInfo>();
foreach (var fileItem in fileItems)
{
bool temporal = false;
string path = fileItem.Path;
var tmpPath = path;
var fileName = tmpPath.Substring(tmpPath.LastIndexOf("/") + 1);
if (path.StartsWith("/var/"))
{
var data = NSData.FromUrl(new NSUrl($"file://{path}"));
tmpPath = SaveToDisk(data, "tmp", fileName);
temporal = true;
}
if (string.IsNullOrEmpty(boundary))
{
boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");
}
if (File.Exists(tmpPath))
{
uploadItems.Add(new UploadFileItemInfo(tmpPath, fileItem.FieldName, fileName, temporal));
}
else
{
error = true;
errorMessage = $"File at path: {fileItem.Path} doesn't exist";
break;
}
}
if (error)
{
var fileUploadResponse = new FileUploadResponse(errorMessage, -1, tag, null);
FileUploadError(this, fileUploadResponse);
return(fileUploadResponse);
}
var mPath = await SaveToFileSystemAsync(uploadItems.ToArray(), parameters, boundary);
return(await MakeRequest(mPath, tag, url, headers, boundary));
}
public void OnError(string tag, string error)
{
var fileUploadResponse = new FileUploadResponse(error, -1, tag, null);
FileUploadError(this, fileUploadResponse);
System.Diagnostics.Debug.WriteLine(error);
uploadCompletionSource.TrySetResult(fileUploadResponse);
}
public async Task <IActionResult> UploadFile(string source, string share, string folder, [FromBody] FileUploadRequest request)
{
if (string.IsNullOrEmpty(source) || string.IsNullOrEmpty(share) || string.IsNullOrEmpty(folder))
{
return(BadRequest());
}
FileUploadResponse response = await _service.UploadFile(source, share, folder, request);
return(Ok(response));
}
public async Task <FileUploadResponse> UploadFileAsync(string url, FileBytesItem[] fileItems, string tag, IDictionary <string, string> headers = null, IDictionary <string, string> parameters = null)
{
if (fileItems == null || fileItems.Length == 0)
{
var fileUploadResponse = new FileUploadResponse("There are no items to upload", -1, tag);
FileUploadError(this, fileUploadResponse);
return(fileUploadResponse);
}
return(await Task.Run(() =>
{
try
{
var requestBodyBuilder = PrepareRequest(parameters);
foreach (var fileItem in fileItems)
{
var mediaType = MediaType.Parse(GetMimeType(fileItem.Name));
if (mediaType == null)
{
mediaType = MediaType.Parse("*/*");
}
RequestBody fileBody = RequestBody.Create(mediaType, fileItem.Bytes);
requestBodyBuilder.AddFormDataPart(fileItem.FieldName, fileItem.Name, fileBody);
}
return MakeRequest(url, tag, requestBodyBuilder, headers);
}
catch (Java.Net.UnknownHostException ex)
{
var fileUploadResponse = new FileUploadResponse("Host not reachable", -1, tag);
FileUploadError(this, fileUploadResponse);
System.Diagnostics.Debug.WriteLine(ex.ToString());
return fileUploadResponse;
}
catch (Java.IO.IOException ex)
{
var fileUploadResponse = new FileUploadResponse(ex.ToString(), -1, tag);
FileUploadError(this, fileUploadResponse);
System.Diagnostics.Debug.WriteLine(ex.ToString());
return fileUploadResponse;
}
catch (Exception ex)
{
var fileUploadResponse = new FileUploadResponse(ex.ToString(), -1, tag);
FileUploadError(this, fileUploadResponse);
System.Diagnostics.Debug.WriteLine(ex.ToString());
return fileUploadResponse;
}
}));
}
private void FileUploadCallback(FileUploadResponse fur)
{
if (fur.ok)
{
Console.WriteLine("Uploaded File.");
}
else
{
Console.WriteLine(fur.error);
}
}
private void Current_FileUploadCompleted(object sender, FileUploadResponse e)
{
isBusy = false;
System.Diagnostics.Debug.WriteLine($"{e.StatusCode} - {e.Message}");
Device.BeginInvokeOnMainThread(async() =>
{
await DisplayAlert("File Upload", "Upload Completed", "Ok");
progress.IsVisible = false;
progress.Progress = 0.0f;
});
}
public FileUploadResponse Post(FileUploadRequest request)//common end point for upload
{
FileUploadResponse response = new FileUploadResponse();
Log.Info("Inside FileUpload common");
try
{
this.EbConnectionFactory = new EbConnectionFactory(request.SolnId, this.Redis);
string context = string.IsNullOrEmpty(request.FileDetails.Context) ? StaticFileConstants.CONTEXT_DEFAULT : request.FileDetails.Context;
string meta = request.FileDetails.MetaDataDictionary.ToJson();
request.FileDetails.FileRefId = GetFileRefId(request.UserId, request.FileDetails.FileName, request.FileDetails.FileType, meta, request.FileDetails.FileCategory, context);
Log.Info("FileRefId : " + request.FileDetails.FileRefId);
if (request.FileCategory == EbFileCategory.File || request.FileCategory == EbFileCategory.Audio)
{
Post(new UploadFileRequest
{
FileCategory = request.FileCategory,
FileRefId = request.FileDetails.FileRefId,
Byte = request.FileByte,
SolnId = request.SolnId,
UserId = request.UserId,
UserAuthId = request.UserAuthId,
BToken = (!String.IsNullOrEmpty(this.Request.Authorization)) ? this.Request.Authorization.Replace("Bearer", string.Empty).Trim() : String.Empty,
RToken = (!String.IsNullOrEmpty(this.Request.Headers["rToken"])) ? this.Request.Headers["rToken"] : String.Empty,
SubscriptionId = (!String.IsNullOrEmpty(this.Request.Headers[TokenConstants.SSE_SUBSCRIP_ID])) ? this.Request.Headers[TokenConstants.SSE_SUBSCRIP_ID] : String.Empty
});
}
else if (request.FileCategory == EbFileCategory.Images)
{
this.MessageProducer3.Publish(new UploadImageRequest
{
FileCategory = EbFileCategory.Images,
ImageRefId = request.FileDetails.FileRefId,
Byte = request.FileByte,
SolnId = request.SolnId,
UserId = request.UserId,
UserAuthId = request.UserAuthId,
BToken = (!String.IsNullOrEmpty(this.Request.Authorization)) ? this.Request.Authorization.Replace("Bearer", string.Empty).Trim() : String.Empty,
RToken = (!String.IsNullOrEmpty(this.Request.Headers["rToken"])) ? this.Request.Headers["rToken"] : String.Empty,
SubscriptionId = (!String.IsNullOrEmpty(this.Request.Headers[TokenConstants.SSE_SUBSCRIP_ID])) ? this.Request.Headers[TokenConstants.SSE_SUBSCRIP_ID] : String.Empty
});
}
Log.Info("File Pushed to MQ");
response.FileRefId = request.FileDetails.FileRefId;
}
catch (Exception ex)
{
Log.Info("Exception:" + ex.StackTrace);
}
return(response);
}
protected override bool EvalResult(string result, out string downloadURL)
{
FileUploadResponse response = JsonUtility.FromJson <FileUploadResponse>(result);
if (response.success)
{
downloadURL = response.link;
return(true);
}
downloadURL = string.Empty;
return(false);
}
public async Task <FileUploadResponse> UploadFileAsync(string url, FilePathItem[] fileItems, string tag, IDictionary <string, string> headers = null, IDictionary <string, string> parameters = null)
{
if (fileItems == null || fileItems.Length == 0)
{
var fileUploadResponse = new FileUploadResponse("There are no items to upload", -1, tag);
FileUploadError(this, fileUploadResponse);
return(fileUploadResponse);
}
return(await Task.Run(() =>
{
try
{
var requestBodyBuilder = PrepareRequest(parameters);
foreach (var fileItem in fileItems)
{
Java.IO.File f = new Java.IO.File(fileItem.Path);
string fileAbsolutePath = f.AbsolutePath;
RequestBody file_body = RequestBody.Create(MediaType.Parse(GetMimeType(fileItem.Path)), f);
var fileName = fileAbsolutePath.Substring(fileAbsolutePath.LastIndexOf("/") + 1);
requestBodyBuilder.AddFormDataPart(fileItem.FieldName, fileName, file_body);
}
return MakeRequest(url, tag, requestBodyBuilder, headers);
}
catch (Java.Net.UnknownHostException ex)
{
var fileUploadResponse = new FileUploadResponse("Host not reachable", -1, tag);
FileUploadError(this, fileUploadResponse);
System.Diagnostics.Debug.WriteLine(ex.ToString());
return fileUploadResponse;
}
catch (Java.IO.IOException ex)
{
var fileUploadResponse = new FileUploadResponse(ex.ToString(), -1, tag);
FileUploadError(this, fileUploadResponse);
System.Diagnostics.Debug.WriteLine(ex.ToString());
return fileUploadResponse;
}
catch (Exception ex)
{
var fileUploadResponse = new FileUploadResponse(ex.ToString(), -1, tag);
FileUploadError(this, fileUploadResponse);
System.Diagnostics.Debug.WriteLine(ex.ToString());
return fileUploadResponse;
}
}));
}
private void Current_FileUploadCompleted(object sender, FileUploadResponse e)
{
ViewModel.IsBusy = false;
System.Diagnostics.Debug.WriteLine($"{e.StatusCode} - {e.Message}");
Device.BeginInvokeOnMainThread(async() =>
{
await DisplayAlert("File Upload", "Upload Completed: \n " + e.Message, "Ok");
string photoUri = e.Message;
SaveEvent(photoUri);
ProgressBar.IsVisible = false;
ProgressBar.Progress = 0.0f;
});
}
public ResponseForm(FileUploadResponse response)
{
InitializeComponent();
txtUrl.Text = response.redirectTo;
btnSaveQrCode.Enabled = false;
btnSaveQrCode.Click += btnSaveQrCode_Click;
imgQr.LoadCompleted += imgQr_LoadCompleted;
imgQr.LoadAsync(response.qrUrl);
Response = response;
}
public async Task <IActionResult> Upload()
{
var userRootPath = ResolveUserRootPath();
FileUploadResponse response = null;
foreach (var file in Request.Form.Files)
{
string filename = Path.GetFileName(file.FileName);
string folder = file.Name;
var dir = Path.Combine(userRootPath, folder);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var filePath = Path.Combine(dir, filename);
// Override 'filePath' and 'filename' if a file with the same name already exists
if (System.IO.File.Exists(filePath))
{
var filenameParts = filename.Split('.');
string namePart = filenameParts[0] + "_1";
string fileExtensionPart = filenameParts[1];
filename = string.Join('.', namePart, fileExtensionPart);
filePath = Path.Combine(dir, filename);
}
using (var fileStream = System.IO.File.Create(filePath))
{
file.CopyTo(fileStream);
response = new FileUploadResponse
{
FileName = filename,
FilePathFull = filePath,
FileSize = fileStream.Length
};
}
if (_useEncryption)
{
await Encrypter.Encrypt(filePath, _certPath);
}
}
return(Ok(response));
}
private void FileUploadResponseHandler(FileUploadResponse response)
{
FileUploadRequest request = new FileUploadRequest(response);
if (!response.HasError)
{
if (request.CurrentPosition == 0)
{
var encryptionkey = clientPublicEncryptionkeys[request.ReceiverClient];
//MemoryMappedFile mmf = MemoryMappedFile.CreateFromFile(request.SourceFilePath);
//MemoryMappedViewStream mms = mmf.CreateViewStream();
using (FileStream fs = File.Open(request.SourceFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (BufferedStream bs = new BufferedStream(fs))
using (BinaryReader fileStream = new BinaryReader(bs))
{
var bytes = new byte[request.BufferSize];
// Read and verify the data
int j = 0;
for (long i = 0; i < request.TotalBytes; i++, j++)
{
bytes[j] = fileStream.ReadByte();
if (j == request.BufferSize - 1 || i == request.TotalBytes - 1)
{
request = new FileUploadRequest(request);
var tmpbyte = new byte[j + 1];
Array.Copy(bytes, 0, tmpbyte, 0, j + 1);
request.BytesToWrite = UtilityFunction.EncryptByte(tmpbyte, encryptionkey.FirstX, encryptionkey.U, encryptionkey.SelectChoas);
request.DataLength = j + 1;
request.CurrentPosition = i + 1;
SendMessage(request);
j = -1;
}
}
fileStream.Close();
fileStream.Dispose();
}
//mms.Dispose();
//mmf.Dispose();
}
}
else
{
CleanMessageQueueFromFile(response);
}
}
public ResponseForm(FileUploadResponse response)
{
InitializeComponent();
txtUrl.Text = response.redirectTo;
btnSaveQrCode.Enabled = false;
btnSaveQrCode.Click += new EventHandler(btnSaveQrCode_Click);
imgQr.LoadCompleted += new AsyncCompletedEventHandler(imgQr_LoadCompleted);
//imgQr.ImageLocation = response.qrUrl;
imgQr.LoadAsync(response.qrUrl);
Response = response;
}
public ResponseForm(FileUploadResponse response)
{
InitializeComponent();
txtUrl.Text = response.redirectTo;
btnSaveQrCode.Enabled = false;
btnSaveQrCode.Click += new EventHandler(btnSaveQrCode_Click);
imgQr.LoadCompleted += new AsyncCompletedEventHandler(imgQr_LoadCompleted);
//imgQr.ImageLocation = response.qrUrl;
imgQr.LoadAsync(response.qrUrl);
Response = response;
}
public string DeleteFile(string name)
{
User user = GetUserFromCookie();
try
{
if (user == null)
throw new UserNotFoundException("You must be logged in.");
if (string.IsNullOrWhiteSpace(name))
throw new ParamMissingException("You must specify a file.");
UploadedFile uploadResponse = _userManager.DeleteUserFile(user.UserId, new Guid(name));
FileUploadResponse response = new FileUploadResponse(uploadResponse);
response.Message = "File deleted successfully.";
return JsonConvert.SerializeObject(response);
}
catch (BaseException e)
{
return JsonConvert.SerializeObject(new FileUploadResponse { ResponseCode = 400, Message = e.Message });
}
catch (Exception e1)
{
return JsonConvert.SerializeObject(new FileUploadResponse
{
ResponseCode = 500,
Message = "File upload failed: " + e1.Message
});
}
}
