// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
ISynologyConnection connection,
ISynologyConnectionSettings synologyConnectionSettings)
{
if (env.IsDevelopment())
{
app.UseBrowserLink();
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
connection.Api().Auth().Login(new LoginParameters
{
Username = synologyConnectionSettings.Username,
Password = synologyConnectionSettings.Password
});
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
private static async Task <T> GenericPostDataFromApiAsync <T>(this ISynologyConnection connection, string cgi, string api, int version, string method, FormParameter[] additionalParams = null) where T : ResultData
{
var uri = PostApiUrl(connection, cgi, api, version, method);
var allParameters = new[] {
new FormParameter("api", api),
new FormParameter("version", version),
new FormParameter("method", method)
}.Concat(additionalParams ?? new FormParameter[] { }).Where(t => t.MinVersion <= version).ToArray();
using (var content = new FormParameterManager(allParameters))
{
var formContent = await content.ToByteArrayAsync();
using (var requestContent = new ByteArrayContent(formContent))
{
requestContent.Headers.ContentType = new MediaTypeHeaderValue(content.MultipartContent.Headers.ContentType.ToString().Replace("\"", string.Empty));
var result = await connection.Client.PostAsync(uri, requestContent);
var data = await result.Content.ReadAsByteArrayAsync();
var jsonString = Encoding.UTF8.GetString(data);
connection.Logger.LogDebug(jsonString);
return(JsonConvert.DeserializeObject <T>(jsonString));
}
}
}
internal static void SetSid(this ISynologyConnection connection, string value)
{
if (connection.ServiceProvider.GetService <SidContainer>() is SidContainer sidContainer)
{
sidContainer.Sid = value;
}
}
public async Task <bool> AddTask(NewDownloadModels newDownloadModels)
{
ISynologyConnection syno = _scope.ServiceProvider.GetService <ISynologyConnection>();
if (!string.IsNullOrEmpty(newDownloadModels.Uri))
{
TaskCreateParameters request = new TaskCreateParameters()
{
Destination = newDownloadModels.Destination,
Password = newDownloadModels.Password,
UnzipPassword = newDownloadModels.UnzipPassword,
Username = newDownloadModels.Username,
File = newDownloadModels.Uri,
};
ResultData result = await syno.DownloadStation().Task().CreateAsync(request);
return(result.Success);
}
else
{
var result = await syno.DownloadStation().Task().CreatePostAsync(new TaskCreateParametersPost
{
Filename = newDownloadModels.File,
Destination = newDownloadModels.Destination,
File = new byte[0],
});
}
return(false);
}
public async Task <bool> ResumeTask(string ID)
{
ISynologyConnection syno = _scope.ServiceProvider.GetService <ISynologyConnection>();
ResultData <IEnumerable <ITaskMinimalResult> > result = await syno.DownloadStation().Task().ResumeAsync(new[] { ID });
return(result.Success);
}
private static async Task <T> GenericPostDataFromApiAsync <T>(this ISynologyConnection connection, string cgi, string api, int version, string method, FormParameter[] additionalParams = null) where T : ResultData
{
var uri = PostApiUrl(connection, cgi, api, version, method);
var client = new RestClient(uri);
var request = new RestRequest(Method.POST);
request.AddParameter("_sid", connection.GetSid());
request.AddParameter("api", api);
request.AddParameter("version", version);
request.AddParameter("method", method);
foreach (var temp in additionalParams)
{
if (temp is FileFormDataParameter)
{
request.AddFile("file", temp.Value, "application/x-bittorrent");
}
else if (!temp.Empty)
{
request.AddParameter(temp.Name, temp.Value);
}
}
var result = await client.ExecuteAsync(request);
var data = result.Content;
connection.Logger.LogDebug(data);
return(JsonConvert.DeserializeObject <T>(data));
}
public async Task <ITaskListResult> GetTask()
{
ISynologyConnection syno = _scope.ServiceProvider.GetService <ISynologyConnection>();
ResultData <ITaskListResult> dsResTasks = await syno.DownloadStation().Task().ListAsync(new TaskListParameters
{
Additional = TaskDetailsType.Detail | TaskDetailsType.Transfer | TaskDetailsType.File | TaskDetailsType.Tracker | TaskDetailsType.Peer
});
return(dsResTasks.Data);
}
/// <summary>
/// Get Uri for post operations
/// </summary>
/// <param name="connection"></param>
/// <param name="cgi">CGI path handling the request</param>
/// <param name="api">API name handling the request</param>
/// <param name="version">Version of the api</param>
/// <param name="method">Method of the API</param>
/// <returns>The Uri object where the request has to be sent</returns>
private static Uri PostApiUrl(this ISynologyConnection connection, string cgi, string api, int version, string method)
{
var url = new QueryStringManager(cgi);
url.AddParameters(new[] {
new QueryStringParameter("_sid", connection.GetSid()),
});
var res = url.ToString();
connection.Logger.LogDebug($"Created API Url for POST: {res}");
return(new Uri(connection.Client.BaseAddress, res));
}
public async Task <IStatisticResult> GetCurrentSpeed()
{
ISynologyConnection syno = _scope.ServiceProvider.GetService <ISynologyConnection>();
var result = await syno.DownloadStation().Statistic().InfoAsync();
if (result.Success)
{
return(result.Data);
}
else
{
return(null);
}
}
public async Task <List <string> > GetFolderList()
{
ISynologyConnection syno = _scope.ServiceProvider.GetService <ISynologyConnection>();
var listVirtualFolder = await syno.FileStation().List().ListSharesAsync(new ListSharesParameters {
});
var directory = new List <string>();
foreach (var data in listVirtualFolder.Data.Shares)
{
directory.Add(data.Name);
}
return(directory);
}
private static async Task <T> GenericGetDataFromApiAsync <T>(this ISynologyConnection connection, string cgi, string api, int version, string method, QueryStringParameter[] additionalParams = null) where T : ResultData
{
var url = GetApiUrl(connection, cgi, api, version, method, additionalParams);
var response = await connection.Client.GetStreamAsync(url);
using (var reader = new StreamReader(response))
{
var json = await reader.ReadToEndAsync();
connection.Logger.LogDebug($"Response JSON for {api} v.{version} with method {method} [cgi: {cgi}]: {json}");
return(JsonConvert.DeserializeObject <T>(json));
}
}
public async Task <IConfigResult> GetSettings()
{
ISynologyConnection syno = _scope.ServiceProvider.GetService <ISynologyConnection>();
ResultData <IConfigResult> result = (await syno.DownloadStation().Info().ConfigAsync());
if (result.Success)
{
return(result.Data);
}
else
{
return(null);
}
}
public async Task <IEnumerable <string> > GetFolderList(string baseFolder)
{
ISynologyConnection syno = _scope.ServiceProvider.GetService <ISynologyConnection>();
var result = await syno.FileStation().List().ListFilesAsync(new ListParameters {
FolderPath = baseFolder, Filetype = FileType.Directory
});
var directory = new List <string>();
IFileListResult temp = result.Data;
var json = JsonConvert.SerializeObject(temp);
var test = JsonConvert.DeserializeObject <HackJsonIFileresult>(json).files.Select(x => x.name);
return(test);
}
public async Task <bool> ConnectUser(string url, string username, string password)
{
try
{
Regex r = new Regex(@"^(?<proto>\w+)://[^/]+?(?<port>:\d+)?/", RegexOptions.None, TimeSpan.FromMilliseconds(150));
Match m = r.Match(url);
if (m.Success)
{
Console.WriteLine(m.Result("${proto}${port}"));
int port = 80;
if (string.IsNullOrEmpty(m.Groups["port"].Value))
{
port = (m.Groups["proto"].Value == "https") ? 443 : 80;
}
else
{
port = int.Parse(m.Groups["port"].Value.Replace(":", ""));
}
Uri uri = new Uri(url);
settingsSave = _scope.ServiceProvider.GetService <ISynologyConnectionSettings>();
settingsSave.BaseHost = uri.Host;
settingsSave.Ssl = (m.Groups["proto"].Value == "https");
settingsSave.Port = port;
settingsSave.SslPort = port;
settingsSave.Username = username;
settingsSave.Password = password;
settingsSave.SessionName = "SynoConnect";
ISynologyConnection syno = _scope.ServiceProvider.GetService <ISynologyConnection>();
ResultData <IAuthResult> resLogin = await syno.Api().Auth().LoginAsync();
if (resLogin.Error == null || (resLogin.Error != null && resLogin.Error.Code == 403))
{
return(true);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="connection"></param>
/// <param name="cgi"></param>
/// <param name="api"></param>
/// <param name="version"></param>
/// <param name="method"></param>
/// <param name="additionalParams"></param>
/// <returns></returns>
private static string GetApiUrl(this ISynologyConnection connection, string cgi, string api, int version, string method, QueryStringParameter[] additionalParams = null)
{
var url = new QueryStringManager(cgi);
additionalParams = additionalParams ?? new QueryStringParameter[] { };
url.AddParameters(additionalParams.Concat(new[] {
new QueryStringParameter("_sid", connection.GetSid()),
new QueryStringParameter("api", api),
new QueryStringParameter("version", version),
new QueryStringParameter("method", method)
}).Where(t => t.MinVersion <= version));
var res = url.ToString();
connection.Logger.LogDebug($"Created API Url for GET: {res}");
return(res);
}
public async Task <bool> SetSettings(IConfigResult config)
{
ISynologyConnection syno = _scope.ServiceProvider.GetService <ISynologyConnection>();
ResultData result = (await syno.DownloadStation().Info().SetConfigAsync(new Synology.DownloadStation.Info.Parameters.SetConfigParameters
{
KbpsTorrentMaxDownload = config.TorrentMaxDownload,
KbpsTorrentMaxUpload = config.TorrentMaxUpload,
KbpsEmuleMaxDownload = config.EmuleMaxDownload,
KbpsEmuleMaxUpload = config.EmuleMaxUpload,
KbpsNzbMaxDownload = config.NzbMaxDownload,
KbpsHttpMaxDownload = config.HttpMaxDownload,
KbpsFtpMaxDownload = config.FtpMaxDownload,
EmuleEnabled = config.EmuleEnabled,
UnzipEnabled = config.UnzipServiceEnabled,
DefaultDestination = config.DefaultDestination,
EmuleDefaultDestination = config.EmuleDefaultDestination
}
));
return(result.Success);
}
/// <inheritdoc />
/// <summary>
/// </summary>
/// <param name="connection"></param>
public DownloadStationApi(ISynologyConnection connection) : base(connection)
{
}
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="connection"></param> /// <returns></returns> private static T ResolveApi <T>(this ISynologyConnection connection) where T : ISynologyApi => (T)ResolveApi(connection, typeof(T));
/// <summary> /// /// </summary> /// <param name="connection"></param> /// <param name="t"></param> /// <returns></returns> private static ISynologyApi ResolveApi(this ISynologyConnection connection, Type t) => connection.ServiceProvider.GetService(t) as ISynologyApi;
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="connection"></param> /// <returns></returns> private static T ResolveRequest <T>(this ISynologyConnection connection) where T : ISynologyRequest => (T)ResolveRequest(connection, typeof(T));
/// <summary> /// /// </summary> /// <param name="connection"></param> /// <param name="t"></param> /// <returns></returns> private static ISynologyRequest ResolveRequest(this ISynologyConnection connection, Type t) => connection.ServiceProvider.GetService(t) as ISynologyRequest;
/// <summary> /// /// </summary> /// <param name="connection"></param> /// <returns></returns> public static IApi Api(this ISynologyConnection connection) => connection.Api <IApi>();
/// <summary> /// Files the station. /// </summary> /// <returns>The station.</returns> /// <param name="connection">Connection.</param> public static IFileStationApi FileStation(this ISynologyConnection connection) => connection.Api <IFileStationApi>();
/// <inheritdoc />
/// <summary>
/// </summary>
/// <param name="connection"></param>
public SurveillanceStationApi(ISynologyConnection connection) : base(connection)
{
}
/// <summary> /// /// </summary> /// <param name="connection"></param> /// <returns></returns> public static IDownloadStation2Api DownloadStation2(this ISynologyConnection connection) => connection.Api <IDownloadStation2Api>();
internal static T Api <T>(this ISynologyConnection connection) where T : ISynologyApi => ResolveApi <T>(connection);
/// <summary> /// /// </summary> /// <param name="connection"></param> /// <returns></returns> public static ISurveillanceStationApi SurveillanceStation(this ISynologyConnection connection) => connection.Api <ISurveillanceStationApi>();
internal static async Task <ResultData> GetDataFromApiAsync(this ISynologyConnection connection, string cgi, string api, int version, string method, QueryStringParameter[] additionalParams = null) => await GenericGetDataFromApiAsync <ResultData>(connection, cgi, api, version, method, additionalParams);
/// <summary>
///
/// </summary>
/// <param name="connection"></param>
protected SynologyApi(ISynologyConnection connection)
{
Connection = connection;
}
internal static string GetSid(this ISynologyConnection connection)
{
var sidContainer = connection.ServiceProvider.GetService <SidContainer>() as SidContainer;
return(sidContainer?.Sid);
}
