public TrinitySoapClient(ISoapClientFactory soapClientFactory,
string host,
int port,
string userName,
string password)
{
endpoint = new Uri($"http://{host}:{port}");
soapClient = soapClientFactory.Factory(userName, password);
soapParser = new TrinitySoapParser();
}
public SoapConfigViewModel(IConnectionSettingsProvider settings, ISoapClientFactory clientFactory)
{
port = (settings.GetSettings().Port ?? 7878).ToString();
user = settings.GetSettings().User;
pass = settings.GetSettings().Password;
host = settings.GetSettings().Host ?? "127.0.0.1";
this.settings = settings;
Save = new DelegateCommand(() =>
{
int?port = null;
if (int.TryParse(Port, out int port_))
{
port = port_;
}
settings.UpdateSettings(User, Password, Host, port);
IsModified = false;
});
TestConnection = new AsyncAutoCommand(async() =>
{
int?port = null;
if (int.TryParse(Port, out int port_))
{
port = port_;
}
var client = new TrinitySoapClient(clientFactory, host, port ?? 0, user !, pass !);
try
{
var response = await client.ExecuteCommand("server info");
if (response.Success)
{
TestConnectionOutput = "Success:\n" + response.Message;
}
else
{
if (string.IsNullOrEmpty(response.Message))
{
TestConnectionOutput =
"Server responded, but response ill-formed. Is it TrinityCore based server?";
}
else
{
TestConnectionOutput = "Server responded, but command failed: " + response.Message;
}
}
}
catch (Exception e)
{
TestConnectionOutput = "Connection failed: " + e.Message;
}
}, _ => !string.IsNullOrEmpty(host) && int.TryParse(port, out var _) && !string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(pass));
PropertyChanged += (_, _) => TestConnection.RaiseCanExecuteChanged();
}
public SoapRemoteConnectorService(IConnectionSettingsProvider connectionSettings,
ISoapClientFactory soapClientFactory)
{
this.connectionSettings = connectionSettings;
var settings = connectionSettings.GetSettings();
if (settings.IsEmpty)
{
trinitySoapClient = null;
}
else
{
trinitySoapClient = new TrinitySoapClient(soapClientFactory, settings.Host !, settings.Port !.Value, settings.User !, settings.Password !);
}
}
/// <summary>
/// Gets a <see cref="ISoapClient" /> instance from the factory and releases
/// when the action completes.
/// </summary>
/// <typeparam name="TSoapClient">The SOAP client type</typeparam>
/// <typeparam name="TResult">The result type</typeparam>
/// <param name="factory">The factory to use</param>
/// <param name="action">The action to execute</param>
/// <returns>The action result</returns>
/// <exception cref="ArgumentNullException"></exception>
public static TResult GetAndRelease <TSoapClient, TResult>(this ISoapClientFactory factory, Func <TSoapClient, TResult> action)
where TSoapClient : ISoapClient
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
var client = factory.Get <TSoapClient>();
try
{
return(action(client));
}
finally
{
factory.Release(client);
}
}
/// <summary>
/// Gets a <see cref="ISoapClient" /> instance from the factory and releases
/// when the action completes.
/// </summary>
/// <typeparam name="TSoapClient">The SOAP client type</typeparam>
/// <typeparam name="TResult">The result type</typeparam>
/// <param name="factory">The factory to use</param>
/// <param name="action">The action to execute</param>
/// <param name="ct">The cancellation token</param>
/// <returns>A task that can be awaited for the result</returns>
/// <exception cref="ArgumentNullException"></exception>
public static async Task <TResult> GetAndReleaseAsync <TSoapClient, TResult>(
this ISoapClientFactory factory, Func <TSoapClient, CancellationToken, Task <TResult> > action, CancellationToken ct = default(CancellationToken))
where TSoapClient : ISoapClient
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
var client = factory.Get <TSoapClient>();
try
{
return(await action(client, ct).ConfigureAwait(false));
}
finally
{
factory.Release(client);
}
}
/// <summary>
/// Gets a <see cref="ISoapClient" /> instance from the factory and releases
/// when the action completes.
/// </summary>
/// <param name="factory">The factory to use</param>
/// <param name="action">The action to execute</param>
/// <exception cref="ArgumentNullException"></exception>
public static void GetAndRelease(this ISoapClientFactory factory, Action <SoapClient> action)
{
GetAndRelease <SoapClient>(factory, action);
}
/// <summary>
/// Gets a <see cref="ISoapClient" /> instance from the factory and releases
/// when the action completes.
/// </summary>
/// <typeparam name="TResult">The result type</typeparam>
/// <param name="factory">The factory to use</param>
/// <param name="action">The action to execute</param>
/// <param name="ct">The cancellation token</param>
/// <returns>A task that can be awaited for the result</returns>
/// <exception cref="ArgumentNullException"></exception>
public static async Task <TResult> GetAndReleaseAsync <TResult>(
this ISoapClientFactory factory, Func <SoapClient, CancellationToken, Task <TResult> > action, CancellationToken ct = default(CancellationToken))
{
return(await GetAndReleaseAsync <SoapClient, TResult>(factory, action, ct).ConfigureAwait(false));
}
/// <summary>
/// Gets a <see cref="ISoapClient" /> instance from the factory and releases
/// when the action completes.
/// </summary>
/// <param name="factory">The factory to use</param>
/// <param name="action">The action to execute</param>
/// <param name="ct">The cancelattion token</param>
/// <returns>A task that can be awaited</returns>
/// <exception cref="ArgumentNullException"></exception>
public static async Task GetAndReleaseAsync(
this ISoapClientFactory factory, Func <SoapClient, CancellationToken, Task> action, CancellationToken ct = default(CancellationToken))
{
await GetAndReleaseAsync <SoapClient>(factory, action, ct).ConfigureAwait(false);
}
/// <summary>
/// Gets a <see cref="ISoapClient" /> instance from the factory and releases
/// when the action completes.
/// </summary>
/// <typeparam name="TResult">The result type</typeparam>
/// <param name="factory">The factory to use</param>
/// <param name="action">The action to execute</param>
/// <returns>The action result</returns>
/// <exception cref="ArgumentNullException"></exception>
public static TResult GetAndRelease <TResult>(this ISoapClientFactory factory, Func <SoapClient, TResult> action)
{
return(GetAndRelease <SoapClient, TResult>(factory, action));
}
