508 lines
26 KiB
C#
508 lines
26 KiB
C#
using CANFDApiProxy.Interfaces;
|
|
using CANFDApiProxy.Messages;
|
|
using CANFDApiProxy.Requests;
|
|
using CsvHelper.Configuration;
|
|
using DTS.Common.Classes.DASFactory;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net.Http;
|
|
using System.Runtime.InteropServices.WindowsRuntime;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace CANFDApiProxy
|
|
{
|
|
public sealed class CANFD : ICANFDApi
|
|
{
|
|
private static readonly Lazy<CANFD> lazy = new Lazy<CANFD>(() => new CANFD());
|
|
|
|
public static CANFD API { get { return lazy.Value; } }
|
|
|
|
private CANFD()
|
|
{
|
|
}
|
|
public async Task<UsbTreeMessage> GetUsbTree(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.UsbTree, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<UsbTreeMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
public async Task<BatteryMessage> GetBattery(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.Battery, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<BatteryMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
/// <summary>
|
|
/// gets results of BIST end point on unit
|
|
/// can throw units
|
|
/// </summary>
|
|
public async Task<DiagnosticMessageRow[]> GetBIST(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var request = new DiagnosticsMessageRequest() { format = "csv" };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Diagnostics, request, cancellationToken);
|
|
var config = new CsvConfiguration(CultureInfo.InvariantCulture) { PrepareHeaderForMatch = args => args.Header.ToLower(), };
|
|
using (var reader = new StringReader(jsonResponse.ToString()))
|
|
{
|
|
using (var csv = new CsvHelper.CsvReader(reader, config))
|
|
{
|
|
var records = csv.GetRecords<DiagnosticMessageRow>().ToArray();
|
|
return records;
|
|
}
|
|
}
|
|
}
|
|
public async Task<CalibrationMessage> GetCalibrationDate(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.CalibrationDate, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<CalibrationMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<SerialMessage> GetSerial(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.Serial, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<SerialMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<LEDsMessage> GetLEDs(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.LEDs, cancellationToken);
|
|
var canInternal = JsonConvert.DeserializeObject<CANInfoInternal>(jsonResponse);
|
|
|
|
var ledsMessage = new LEDsMessage();
|
|
|
|
List<LED> leds = new List<LED>
|
|
{
|
|
new LED("can1",canInternal.can1.blue, canInternal.can1.green, canInternal.can1.red),
|
|
new LED("can2",canInternal.can2.blue, canInternal.can2.green, canInternal.can2.red),
|
|
new LED("can3",canInternal.can3.blue, canInternal.can3.green, canInternal.can3.red),
|
|
new LED("can4",canInternal.can4.blue, canInternal.can4.green, canInternal.can4.red)
|
|
};
|
|
|
|
ledsMessage.LEDs = leds;
|
|
ledsMessage.Status = canInternal.status;
|
|
ledsMessage.Battery = canInternal.battery;
|
|
ledsMessage.Pwr = canInternal.pwr;
|
|
ledsMessage.Sts = canInternal.sts;
|
|
|
|
return ledsMessage;
|
|
}
|
|
|
|
public async Task<CANInfoMessage> GetCANInfo(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.CANInfo, cancellationToken);
|
|
var canInternal = JsonConvert.DeserializeObject<CANInfoInternal>(jsonResponse);
|
|
|
|
var canInfoMessage = new CANInfoMessage();
|
|
|
|
List<CANInfo> list = new List<CANInfo> { new CANInfo("can1", canInternal.can1.info),
|
|
new CANInfo("can2", canInternal.can2.info),
|
|
new CANInfo("can3", canInternal.can3.info),
|
|
new CANInfo("can4", canInternal.can4.info)};
|
|
|
|
canInfoMessage.CANInfoList = list;
|
|
|
|
return canInfoMessage;
|
|
}
|
|
|
|
public async Task<CANStateMessage> GetCANState(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.CANState, cancellationToken);
|
|
var canInternal = JsonConvert.DeserializeObject<CANInfoInternal>(jsonResponse);
|
|
|
|
var canMessage = new CANStateMessage();
|
|
|
|
List<CANState> list = new List<CANState> { new CANState("can1", canInternal.can1.state,canInternal.can1.last_updated ),
|
|
new CANState("can2", canInternal.can2.state,canInternal.can2.last_updated ),
|
|
new CANState("can3", canInternal.can3.state,canInternal.can3.last_updated ),
|
|
new CANState("can4", canInternal.can4.state,canInternal.can4.last_updated )};
|
|
|
|
canMessage.CANStateList = list;
|
|
|
|
return canMessage;
|
|
}
|
|
|
|
public async Task<CANStatsMessage> GetCANStats(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.CANStats, cancellationToken);
|
|
var canInternal = JsonConvert.DeserializeObject<CANInfoInternal>(jsonResponse);
|
|
|
|
var canMessage = new CANStatsMessage();
|
|
|
|
List<CANStats> list = new List<CANStats> {
|
|
new CANStats("can1", canInternal.can1.std_data,canInternal.can1.std_remote,canInternal.can1.ext_data,canInternal.can1.ext_remote,canInternal.can1.err_frame,canInternal.can1.bus_load,canInternal.can1.overruns, canInternal.can1.last_updated ),
|
|
new CANStats("can2", canInternal.can2.std_data,canInternal.can2.std_remote,canInternal.can2.ext_data,canInternal.can2.ext_remote,canInternal.can2.err_frame,canInternal.can2.bus_load,canInternal.can2.overruns, canInternal.can2.last_updated ),
|
|
new CANStats("can3", canInternal.can3.std_data,canInternal.can3.std_remote,canInternal.can3.ext_data,canInternal.can3.ext_remote,canInternal.can3.err_frame,canInternal.can3.bus_load,canInternal.can3.overruns, canInternal.can3.last_updated ),
|
|
new CANStats("can4", canInternal.can4.std_data,canInternal.can4.std_remote,canInternal.can4.ext_data,canInternal.can4.ext_remote,canInternal.can4.err_frame,canInternal.can4.bus_load,canInternal.can4.overruns, canInternal.can4.last_updated )};
|
|
|
|
canMessage.CANStatsList = list;
|
|
|
|
return canMessage;
|
|
}
|
|
|
|
public async Task<CANConfigMessage> GetCANConfig(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.CANConfig, cancellationToken);
|
|
var canInternal = JsonConvert.DeserializeObject<CANInfoInternal>(jsonResponse);
|
|
|
|
var canMessage = new CANConfigMessage();
|
|
|
|
List<CANConfig> list = new List<CANConfig> {
|
|
new CANConfig("can1", canInternal.can1.base_or_arb_bitrate,canInternal.can1.base_or_arb_sjw, canInternal.can1.data_bitrate, canInternal.can1.data_sjw,canInternal.can1.filetype, canInternal.can1.included, canInternal.can1.is_fd ),
|
|
new CANConfig("can2", canInternal.can2.base_or_arb_bitrate,canInternal.can2.base_or_arb_sjw, canInternal.can2.data_bitrate, canInternal.can2.data_sjw,canInternal.can2.filetype, canInternal.can2.included, canInternal.can2.is_fd ),
|
|
new CANConfig("can3", canInternal.can3.base_or_arb_bitrate,canInternal.can3.base_or_arb_sjw, canInternal.can3.data_bitrate, canInternal.can3.data_sjw,canInternal.can3.filetype, canInternal.can3.included, canInternal.can3.is_fd ),
|
|
new CANConfig("can4", canInternal.can4.base_or_arb_bitrate,canInternal.can4.base_or_arb_sjw, canInternal.can4.data_bitrate, canInternal.can4.data_sjw,canInternal.can4.filetype, canInternal.can4.included, canInternal.can4.is_fd )};
|
|
|
|
canMessage.CANConfigList = list;
|
|
canMessage.Pipe = canInternal.pipe;
|
|
|
|
return canMessage;
|
|
}
|
|
|
|
public async Task<DeviceInfoMessage> GetDeviceInfo(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.DeviceInfo, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<DeviceInfoMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
public async Task<NtpMessage> GetNtp(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.Ntp, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<NtpMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
public async Task<PowerMessage> GetPower(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.Power, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<PowerMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
public async Task<ServicesMessage> GetServices(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.Services, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<ServicesMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<NetworkMessage> GetNetwork(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.Network, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<NetworkMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<ClocksMessage> GetClocks(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.Clocks, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<ClocksMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<EventPinMessage> GetEventPin(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.EventPin, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<EventPinMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<RecordingMessage> GetRecording(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.Recording, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<RecordingMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<UsbStatsMessage> GetUsbStats(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.GetResourceAsync(deviceHost, CommandName.UsbStats, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<UsbStatsMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<SerialMessage> SetSerial(string deviceHost, SerialRequest serialRequest, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Serial, serialRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<SerialMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
public async Task<PowerMessage> SetPowerOff(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var powerRequest = new CanPostRequest { cmd = "off" };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Power, powerRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<PowerMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
public async Task<PowerMessage> SetPowerReboot(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var powerRequest = new CanPostRequest { cmd = "reboot" };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Power, powerRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<PowerMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<CANConfigMessage> SetCANConfig(string deviceHost, CANConfigRequest canConfigRequest, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.CANConfig, canConfigRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<CANConfigMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<LEDsPostMessage> SetLEDs(string deviceHost, LedName led, LedCmd cmd, LedColor color, CancellationToken cancellationToken)
|
|
{
|
|
var request = new LEDsRequest { cmd = cmd.ToString(), color = color.ToString(), led = led.ToString() };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.LEDs, request, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<LEDsPostMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<ClocksMessage> SetClocks(string deviceHost, DateTime dateTime, CancellationToken cancellationToken)
|
|
{
|
|
var request = new ClocksRequest { cmd = "set", time = dateTime.ToString("yyyy-MM-dd HH:mm:ss") };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Clocks, request, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<ClocksMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<ClocksMessage> SyncClocks(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var request = new ClocksRequest { cmd = "sync" };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Clocks, request, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<ClocksMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<RecordingMessage> SetRecordingStart(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var powerRequest = new CanPostRequest { cmd = "start" };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Recording, powerRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<RecordingMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<RecordingMessage> SetRecordingTriggerCheck_Quick(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var powerRequest = new CanPostRequest { cmd = "triggercheck_quick" };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Recording, powerRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<RecordingMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<RecordingMessage> SetRecordingStop(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var powerRequest = new CanPostRequest { cmd = "stop" };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Recording, powerRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<RecordingMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<NetworkMessage> SetNetwork(string deviceHost, NetworkRequest networkRequest, CancellationToken cancellationToken)
|
|
{
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.Network, networkRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<NetworkMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<EventPinMessage> SetEventPinArm(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var powerRequest = new CanPostRequest { cmd = "arm" };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.EventPin, powerRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<EventPinMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
public async Task<EventPinMessage> SetEventPinDisarm(string deviceHost, CancellationToken cancellationToken)
|
|
{
|
|
var powerRequest = new CanPostRequest { cmd = "disarm" };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.EventPin, powerRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<EventPinMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete the file or directory from the device
|
|
/// </summary>
|
|
/// <param name="deviceHost">device ip address</param>
|
|
/// <param name="usbPath">usb path of the file or folder which you want to delete from the device</param>
|
|
/// <param name="cancellationToken"></param>
|
|
/// <returns>status message</returns>
|
|
/// <exception cref="ArgumentException">exception on invalid arguments</exception>
|
|
public async Task<StatusMessage> Delete(string deviceHost, string usbPath, CancellationToken cancellationToken)
|
|
{
|
|
VerifyUsbPathIsNotNull(usbPath);
|
|
return await DeleteAsync(deviceHost, usbPath, cancellationToken);
|
|
}
|
|
|
|
private static void VerifyUsbPathIsNotNull(string usbPath)
|
|
{
|
|
if (string.IsNullOrEmpty(usbPath))
|
|
{
|
|
throw new ArgumentException("usbPAth cannot be null or empty", "usbPath");
|
|
}
|
|
}
|
|
|
|
private static async Task<StatusMessage> DeleteAsync(string deviceHost, string usbPath, CancellationToken cancellationToken)
|
|
{
|
|
var powerRequest = new FileRequest { cmd = "delete", path = usbPath };
|
|
var jsonResponse = await RESTWrapper.PostResourceAsync(deviceHost, CommandName.File, powerRequest, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<StatusMessage>(jsonResponse);
|
|
return response;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dwonload from file or directory, by specifying the usb path to file or directory.
|
|
/// for directory the REST api returns the zip file of the directory.
|
|
/// </summary>
|
|
/// <param name="deviceHost">device ip address</param>
|
|
/// <param name="usbPath">usb path of the download file or directory like /media/usb0/Logs/2025-07-30_15-44/ServiceLogs.1.log or /media/usb0/Logs/2025-07-30_15-44</param>
|
|
/// <param name="destinationDirectory">local destination directory</param>
|
|
/// <param name="timeOut">timeout for download</param>
|
|
/// <param name="cancellationToken">token to cancel the download</param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ArgumentException">error of not valid arguments</exception>
|
|
public async Task Download(string deviceHost, string usbPath, string destinationDirectory, TimeSpan timeOut, CancellationToken cancellationToken)
|
|
{
|
|
VerifyUsbPathIsNotNull(usbPath);
|
|
VerifyDestinationIsNotNull(destinationDirectory);
|
|
VerifyDestinationExist(destinationDirectory);
|
|
|
|
await DownloadProcess(deviceHost, usbPath, destinationDirectory, timeOut, cancellationToken);
|
|
}
|
|
|
|
private async Task DownloadProcess(string deviceHost, string usbPath, string destinationDirectory, TimeSpan timeOut, CancellationToken cancellationToken)
|
|
{
|
|
var oldTimeout = RESTWrapper.Timeout;
|
|
try
|
|
{
|
|
RESTWrapper.Timeout = timeOut;
|
|
string filePath = BuildFilePath(usbPath, destinationDirectory);
|
|
|
|
var downloadRequest = new FileRequest { cmd = "download", path = usbPath };
|
|
var response = await RESTWrapper.SendResourceReadAsStreamAsync(deviceHost, CommandName.File, downloadRequest, timeOut, cancellationToken);
|
|
|
|
await RESTWrapper.WriteStreamToFileAsync(response, filePath);
|
|
}
|
|
finally
|
|
{
|
|
RESTWrapper.Timeout = oldTimeout;
|
|
}
|
|
}
|
|
|
|
private static void VerifyDestinationExist(string destinationDirectory)
|
|
{
|
|
if (!Directory.Exists(destinationDirectory))
|
|
{
|
|
throw new ArgumentException($"directory {destinationDirectory} does not exist", "destinationDirectory");
|
|
}
|
|
}
|
|
|
|
private static void VerifyDestinationIsNotNull(string destinationDirectory)
|
|
{
|
|
if (string.IsNullOrEmpty(destinationDirectory))
|
|
{
|
|
throw new ArgumentException("destinationDirectory cannot be null or empty", "destinationDirectory");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// upload the specified source file to device
|
|
/// </summary>
|
|
/// <param name="deviceHost">device ip address</param>
|
|
/// <param name="uploadUsbPath">ubpath for upload like /media/usb0/Uploads </param>
|
|
/// <param name="sourcefile">file path that you want to upload to device</param>
|
|
/// <param name="timeOut">timeout</param>
|
|
/// <param name="cancellationToken">token to cancel upload</param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ArgumentException"></exception>
|
|
public async Task<StatusMessage> Upload(string deviceHost, string uploadUsbPath, string sourcefile, TimeSpan timeOut, CancellationToken cancellationToken)
|
|
{
|
|
VerifyUploadUsbPathIsNotEmpty(uploadUsbPath);
|
|
VerifySourceIsNotEmpty(sourcefile);
|
|
VerifySourceExist(sourcefile);
|
|
return await UploadProcess(deviceHost, uploadUsbPath, sourcefile, timeOut, cancellationToken);
|
|
}
|
|
|
|
private static async Task<StatusMessage> UploadProcess(string deviceHost, string uploadUsbPath, string sourcefile, TimeSpan timeOut, CancellationToken cancellationToken)
|
|
{
|
|
var oldTimeout = RESTWrapper.Timeout;
|
|
try
|
|
{
|
|
RESTWrapper.Timeout = timeOut;
|
|
MultipartFormDataContent multipart = new MultipartFormDataContent();
|
|
HttpContent cmd = new StringContent("upload");
|
|
HttpContent path = new StringContent(uploadUsbPath);
|
|
|
|
|
|
multipart.Add(cmd, "cmd");
|
|
multipart.Add(path, "path");
|
|
|
|
byte[] data = File.ReadAllBytes(sourcefile);
|
|
|
|
HttpContent fileContent = new StreamContent(new MemoryStream(data));
|
|
|
|
multipart.Add(fileContent, "file", Path.GetFileName(sourcefile));
|
|
|
|
var jsonResponse = await RESTWrapper.PostResourceReadAsStringAsync(deviceHost, CommandName.File, multipart, timeOut, cancellationToken);
|
|
var response = JsonConvert.DeserializeObject<StatusMessage>(jsonResponse);
|
|
return response;
|
|
|
|
}
|
|
finally
|
|
{
|
|
RESTWrapper.Timeout = oldTimeout;
|
|
}
|
|
}
|
|
|
|
private static void VerifySourceExist(string sourcefile)
|
|
{
|
|
if (!File.Exists(sourcefile))
|
|
{
|
|
throw new ArgumentException($"file {sourcefile} does not exist", "sourcefile");
|
|
}
|
|
}
|
|
|
|
private static void VerifySourceIsNotEmpty(string sourcefile)
|
|
{
|
|
if (string.IsNullOrEmpty(sourcefile))
|
|
{
|
|
throw new ArgumentException("sourcefile cannot be null or empty", "sourcefile");
|
|
}
|
|
}
|
|
|
|
private static void VerifyUploadUsbPathIsNotEmpty(string uploadUsbPath)
|
|
{
|
|
if (string.IsNullOrEmpty(uploadUsbPath))
|
|
{
|
|
throw new ArgumentException("uploadUsbPath cannot be null or empty", "uploadUsbPath");
|
|
}
|
|
}
|
|
|
|
private bool IsDirectory(string fileOrDirectory)
|
|
{
|
|
var file = Path.GetExtension(fileOrDirectory);
|
|
return string.IsNullOrEmpty(file);
|
|
}
|
|
private string BuildFilePath(string usbPath, string destinationDirectory)
|
|
{
|
|
var pathSegments = usbPath.Split('/').ToList();
|
|
|
|
string fileName;
|
|
if (IsDirectory(pathSegments.Last()))
|
|
{
|
|
fileName = $"{pathSegments.Last()}.zip";
|
|
}
|
|
else
|
|
{
|
|
fileName = pathSegments.Last();
|
|
}
|
|
var filePath = Path.Combine(destinationDirectory, fileName);
|
|
return filePath;
|
|
}
|
|
}
|
|
}
|