/// <summary>
/// Create connection to V1 server.
/// </summary>
/// <param name="settings">Connection settings</param>
public void Connect(VersionOneSettings settings)
{
var url = settings.ApplicationUrl;
var accessToken = settings.AccessToken;
try
{
var connector = SDK.APIClient.V1Connector
.WithInstanceUrl(url)
.WithUserAgentHeader("VersionOne.Integration.JIRASync", Assembly.GetEntryAssembly().GetName().Version.ToString());
ICanSetProxyOrEndpointOrGetConnector connectorWithAuth;
connectorWithAuth = connector.WithAccessToken(accessToken);
if (settings.ProxySettings.Enabled)
connectorWithAuth.WithProxy(GetProxy(settings.ProxySettings));
services = new Services(connectorWithAuth.Build());
if (!services.LoggedIn.IsNull)
{
IsConnected = true;
ListPropertyValues = new Dictionary<string, IList<ListValue>>();
}
else
IsConnected = false;
}
catch (Exception)
{
IsConnected = false;
}
}
private void btnVerifyV1Connection_Click(object sender, EventArgs e)
{
if (ValidationRequested == null)
{
return;
}
var settings = new VersionOneSettings
{
ApplicationUrl = txtServerUrl.Text,
AccessToken = txtAccessToken.Text,
ProxySettings = new ProxyConnectionSettings
{
Enabled = chkUseProxy.Checked,
Domain = txtProxyDomain.Text,
UserName = txtProxyUsername.Text,
Password = txtProxyPassword.Text,
Uri = txtProxyUri.Text
}
};
lblV1ConnectionValidationResult.Text = string.Empty;
ValidationRequested(this, new ConnectionValidationEventArgs(settings));
}
public bool ValidateIsAccessToken(VersionOneSettings settings)
{
if (settings.AccessToken == null)
{
return(false);
}
return(true);
}
public bool ValidateIsAccessToken(VersionOneSettings settings)
{
if (settings.AccessToken == null)
{
return false;
}
return true;
}
/// <summary>
/// Validate with proxy settings.
/// </summary>
/// <param name="connectionSettings">Connection settings for VersionOne.</param>
public ConnectionValidationEventArgs(VersionOneSettings connectionSettings) {
this.url = connectionSettings.ApplicationUrl;
this.username = connectionSettings.Username;
this.password = connectionSettings.Password;
this.integrated = connectionSettings.IntegratedAuth;
this.useProxy = connectionSettings.ProxySettings.Enabled;
this.proxyDomain = connectionSettings.ProxySettings.Domain;
this.proxyUri = connectionSettings.ProxySettings.Uri;
this.proxyUsername = connectionSettings.ProxySettings.UserName;
this.proxyPassword = connectionSettings.ProxySettings.Password;
this.versionOneSettings = connectionSettings;
}
/// <summary>
/// Create connection to V1 server.
/// </summary>
/// <param name="settings">Connection settings</param>
public void Connect(VersionOneSettings settings)
{
var url = settings.ApplicationUrl;
var accessToken = settings.AccessToken;
var username = settings.Username;
var password = settings.Password;
try
{
var connector = SDK.APIClient.V1Connector
.WithInstanceUrl(url)
.WithUserAgentHeader("VersionOne.Integration.HP-ALM", Assembly.GetEntryAssembly().GetName().Version.ToString());
ICanSetProxyOrEndpointOrGetConnector connectorWithAuth;
switch (settings.AuthenticationType)
{
case AuthenticationTypes.AccessToken:
connectorWithAuth = connector.WithAccessToken(accessToken);
break;
case AuthenticationTypes.Basic:
connectorWithAuth = connector.WithUsernameAndPassword(username, password);
break;
case AuthenticationTypes.Integrated:
connectorWithAuth = connector.WithWindowsIntegrated();
break;
case AuthenticationTypes.IntegratedWithCredentials:
connectorWithAuth = connector.WithWindowsIntegrated(username, password);
break;
default:
throw new Exception("Invalid authentication type");
}
if (settings.ProxySettings.Enabled)
connectorWithAuth.WithProxy(GetProxy(settings.ProxySettings));
services = new Services(connectorWithAuth.Build());
if (!services.LoggedIn.IsNull)
{
IsConnected = true;
ListPropertyValues = new Dictionary<string, IList<ListValue>>();
}
else
IsConnected = false;
}
catch (Exception)
{
IsConnected = false;
}
}
/// <summary>
/// Create connection to V1 server.
/// </summary>
/// <param name="settings">Connection settings</param>
public void Connect(VersionOneSettings settings)
{
var url = settings.ApplicationUrl;
var accessToken = settings.AccessToken;
try
{
var connector = SDK.APIClient.V1Connector
.WithInstanceUrl(url)
.WithUserAgentHeader("VersionOne.Integration.Bugzilla", Assembly.GetEntryAssembly().GetName().Version.ToString());
ICanSetProxyOrEndpointOrGetConnector connectorWithAuth;
switch (settings.AuthenticationType)
{
case AuthenticationTypes.AccessToken:
connectorWithAuth = connector.WithAccessToken(accessToken);
break;
default:
throw new Exception("Invalid authentication type");
}
if (settings.ProxySettings.Enabled)
{
connectorWithAuth.WithProxy(GetProxy(settings.ProxySettings));
}
services = new Services(connectorWithAuth.UseOAuthEndpoints().Build());
if (!services.LoggedIn.IsNull)
{
IsConnected = true;
ListPropertyValues = new Dictionary <string, IList <ListValue> >();
}
else
{
IsConnected = false;
}
}
catch (Exception)
{
IsConnected = false;
}
}
/// <summary>
/// Validate V1 connection
/// </summary>
/// <param name="settings">settings for connection to VersionOne.</param>
/// <returns>true, if validation succeeds; false, otherwise.</returns>
public bool ValidateConnection(VersionOneSettings settings) {
var validator = !settings.IntegratedAuth
? new V1ConnectionValidator(settings.ApplicationUrl, settings.Username, settings.Password, settings.IntegratedAuth, GetProxy(settings.ProxySettings))
: new V1ConnectionValidator(settings.ApplicationUrl, null, null, settings.IntegratedAuth, GetProxy(settings.ProxySettings));
try {
validator.CheckConnection();
validator.CheckAuthentication();
} catch (ConnectionException) {
IsConnected = false;
return false;
}
if (!settings.ApplicationUrl.EndsWith("/")) {
settings.ApplicationUrl += "/";
}
Connect(settings);
return true;
}
/// <summary>
/// Create connection to V1 server.
/// </summary>
/// <param name="settings">Connection settings</param>
public void Connect(VersionOneSettings settings) {
var url = settings.ApplicationUrl;
var username = settings.Username;
var password = settings.Password;
var integrated = settings.IntegratedAuth;
var proxy = GetProxy(settings.ProxySettings);
try {
var metaConnector = new V1APIConnector(url + MetaUrlSuffix, username, password, integrated, proxy);
metaModel = new MetaModel(metaConnector);
var dataConnector = new V1APIConnector(url + DataUrlSuffix, username, password, integrated, proxy);
services = new Services(metaModel, dataConnector);
IsConnected = true;
ListPropertyValues = new Dictionary<string, IList<ListValue>>();
} catch (Exception) {
IsConnected = false;
}
}
public TestWriterEntity()
{
Settings = new VersionOneSettings();
}
public WorkitemWriterEntity() {
Settings = new VersionOneSettings();
}
public ChangesetWriterEntity() {
Settings = new VersionOneSettings();
Link = new ChangesetLink();
}
public WorkitemWriterEntity()
{
Settings = new VersionOneSettings();
}
public ChangesetWriterEntity()
{
Settings = new VersionOneSettings();
Link = new ChangesetLink();
}
/// <summary>
/// Validate V1 connection
/// </summary>
/// <param name="settings">settings for connection to VersionOne.</param>
/// <returns>true, if validation succeeds; false, otherwise.</returns>
public bool ValidateConnection(VersionOneSettings settings) {
Connect(settings);
return IsConnected;
}
private VersionOneSettings GetVersionOneSettings()
{
VersionOneSettings settings = new VersionOneSettings();
settings.ApplicationUrl = url;
settings.IntegratedAuth = integrated;
settings.Password = password;
settings.Username = username;
settings.ProxySettings = new ProxyConnectionSettings();
settings.ProxySettings.Uri = proxyPath;
settings.ProxySettings.UserName = proxyUsername;
settings.ProxySettings.Password = proxyPassword;
settings.ProxySettings.Domain = proxyDomain;
settings.ProxySettings.Enabled = true;
return settings;
}
/// <summary>
/// Validate V1 connection
/// </summary>
/// <param name="settings">settings for connection to VersionOne.</param>
/// <returns>true, if validation succeeds; false, otherwise.</returns>
public bool ValidateConnection(VersionOneSettings settings)
{
Connect(settings);
return(IsConnected);
}
public TestWriterEntity() {
Settings = new VersionOneSettings();
}
private static VersionOneSettings GetVersionOneSettings()
{
var settings = new VersionOneSettings {
ApplicationUrl = V1Url,
Password = V1Password,
Username = V1Username
};
return settings;
}
private VersionOneSettings GetVersionOneSettingsWihthoutProxy(bool integratedAuth)
{
VersionOneSettings settings = new VersionOneSettings();
settings.ApplicationUrl = V1Url;
settings.IntegratedAuth = integratedAuth;
settings.Password = V1Password;
settings.Username = V1Username;
return settings;
}
