public static string GetAssetOid(string jiraId, string assetTypeStr)
{
var config = (JiraConnectionConfiguration)ConfigurationManager.GetSection("jiraAttachments");
var metaconnector = new VersionOneAPIConnector(config.V1Connection.ServerUrl + "/meta.v1/");
var dataconnector =
new VersionOneAPIConnector(config.V1Connection.ServerUrl + "/rest-1.v1/")
.WithVersionOneUsernameAndPassword(config.V1Connection.Username, config.V1Connection.Password);
MetaModel metaModel = new MetaModel(metaconnector);
Services services = new Services(metaModel, dataconnector);
var assetType = metaModel.GetAssetType(assetTypeStr);
var query = new Query(assetType);
var jiraIdAttribute = assetType.GetAttributeDefinition(GetV1IdCustomFieldName(assetTypeStr));
query.Selection.Add(jiraIdAttribute);
var jiraIdTerm = new FilterTerm(jiraIdAttribute);
jiraIdTerm.Equal(jiraId);
query.Filter = jiraIdTerm;
var result = services.Retrieve(query);
if (result.Assets.Count == 0)
{
return String.Empty;
}
return result.Assets[0].Oid.ToString();
}
public void TestFixtureSetUp()
{
var metaConnector = new VersionOneAPIConnector(V1Url + MetaUrl).WithVersionOneUsernameAndPassword(Username, Password);
var serviceConnector = new VersionOneAPIConnector(V1Url + DataUrl).WithVersionOneUsernameAndPassword(Username, Password);
MetaModel = new MetaModel(metaConnector);
Services = new Services(MetaModel, serviceConnector);
var doc = new XmlDocument();
doc.LoadXml(string.Format(@"<Settings>
<APIVersion></APIVersion>
<ApplicationUrl>{0}</ApplicationUrl>
<Username>{1}</Username>
<Password>{2}</Password>
<IntegratedAuth>false</IntegratedAuth>
<ProxySettings disabled='1'>
<Uri>http://proxyhost:3128</Uri>
<UserName>username</UserName>
<Password>password</Password>
<Domain>domain</Domain>
</ProxySettings>
</Settings>", V1Url, Username, Password));
var loggerMock = MockRepository.Stub<ILogger>();
V1Processor = new VersionOneProcessor(doc["Settings"], loggerMock);
V1Processor.AddProperty(Workitem.NumberProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(Entity.NameProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(Entity.DescriptionProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(Workitem.PriorityProperty, VersionOneProcessor.PrimaryWorkitemType, true);
V1Processor.AddProperty(Entity.StatusProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(Workitem.EstimateProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(Entity.AssetTypeProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(PrimaryWorkitem.ParentNameProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(PrimaryWorkitem.TeamNameProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(PrimaryWorkitem.SprintNameProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(PrimaryWorkitem.OrderProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(BaseEntity.ReferenceProperty, VersionOneProcessor.PrimaryWorkitemType, false);
V1Processor.AddProperty(Entity.NameProperty, VersionOneProcessor.StoryType, false);
V1Processor.AddProperty(Entity.NameProperty, VersionOneProcessor.FeatureGroupType, false);
V1Processor.AddProperty(BaseEntity.ReferenceProperty, VersionOneProcessor.FeatureGroupType, false);
V1Processor.AddProperty(VersionOneProcessor.OwnersAttribute, VersionOneProcessor.FeatureGroupType, false);
V1Processor.AddProperty(FieldInfo.NameProperty, VersionOneProcessor.AttributeDefinitionType, false);
V1Processor.AddProperty(FieldInfo.AssetTypeProperty, VersionOneProcessor.AttributeDefinitionType, false);
V1Processor.AddProperty(FieldInfo.AttributeTypeProperty, VersionOneProcessor.AttributeDefinitionType, false);
V1Processor.AddProperty(FieldInfo.IsReadOnlyProperty, VersionOneProcessor.AttributeDefinitionType, false);
V1Processor.AddProperty(FieldInfo.IsRequiredProperty, VersionOneProcessor.AttributeDefinitionType, false);
V1Processor.AddProperty(Entity.NameProperty, VersionOneProcessor.LinkType, false);
V1Processor.AddProperty(Link.UrlProperty, VersionOneProcessor.LinkType, false);
V1Processor.AddProperty(Link.OnMenuProperty, VersionOneProcessor.LinkType, false);
V1Processor.AddProperty(Entity.NameProperty, VersionOneProcessor.MemberType, false);
V1Processor.AddProperty(Member.EmailProperty, VersionOneProcessor.MemberType, false);
V1Processor.AddProperty(Member.DefaultRoleNameProperty, VersionOneProcessor.MemberType, false);
V1Processor.AddProperty(Workitem.OwnersProperty, VersionOneProcessor.StoryType, false);
V1Processor.AddProperty(Workitem.OwnersProperty, VersionOneProcessor.DefectType, false);
V1Processor.AddProperty(Workitem.OwnersProperty, VersionOneProcessor.PrimaryWorkitemType, false);
Assert.IsTrue(V1Processor.ValidateConnection(), "Connection is not valid");
}
private IAPIConnector MakeConnector(string path, ProxyProvider proxy = null)
{
var connector = new VersionOneAPIConnector(path, proxyProvider: proxy);
connector.WithVersionOneUsernameAndPassword(_credentials.V1UserName, _credentials.V1Password);
if (_useWindowsIntegratedAuth)
connector.WithWindowsIntegratedAuthentication();
return connector;
}
private IAPIConnector MakeConnector(string path, ProxyProvider proxy = null)
{
var connector = new VersionOneAPIConnector(path, proxyProvider: proxy);
connector.WithVersionOneUsernameAndPassword(_credentials.V1UserName, _credentials.V1Password);
if (_useWindowsIntegratedAuth)
{
connector.WithWindowsIntegratedAuthentication();
}
return(connector);
}
private IAPIConnector PrepareConnector(string url)
{
var connector = new VersionOneAPIConnector(url, proxyProvider: _proxyProvider)
.WithVersionOneUsernameAndPassword(_username, _password);
if (_integratedAuth)
{
connector.WithWindowsIntegratedAuthentication();
}
return(PopulateHeaders(connector));
}
private IAPIConnector GetConnector(string path, bool anonymous)
{
var connector = new VersionOneAPIConnector(ApplicationUrl + path, proxyProvider: Proxy);
if (anonymous)
return connector;
connector.WithVersionOneUsernameAndPassword(_username, _password);
if (_integratedAuth)
connector.WithWindowsIntegratedAuthentication();
return connector;
}
public static string GetV1IdCustomFieldName(string internalAssetTypeName)
{
var config = (JiraConnectionConfiguration)ConfigurationManager.GetSection("jiraAttachments");
if (!String.IsNullOrEmpty(config.V1Connection.CustomField))
{
string customFieldName = String.Empty;
var metaconnector = new VersionOneAPIConnector(config.V1Connection.ServerUrl + "/meta.v1/");
var dataconnector =
new VersionOneAPIConnector(config.V1Connection.ServerUrl + "/rest-1.v1/")
.WithVersionOneUsernameAndPassword(config.V1Connection.Username, config.V1Connection.Password);
MetaModel metaApi = new MetaModel(metaconnector);
Services dataApi = new Services(metaApi,dataconnector);
IAssetType assetType = metaApi.GetAssetType("AttributeDefinition");
Query query = new Query(assetType);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition isCustomAttribute = assetType.GetAttributeDefinition("IsCustom");
query.Selection.Add(isCustomAttribute);
IAttributeDefinition assetNameAttribute = assetType.GetAttributeDefinition("Asset.Name");
query.Selection.Add(assetNameAttribute);
FilterTerm assetName = new FilterTerm(assetNameAttribute);
assetName.Equal(internalAssetTypeName);
FilterTerm isCustom = new FilterTerm(isCustomAttribute);
isCustom.Equal("true");
query.Filter = new AndFilterTerm(assetName, isCustom);
QueryResult result = dataApi.Retrieve(query);
foreach (Asset asset in result.Assets)
{
string attributeValue = asset.GetAttribute(nameAttribute).Value.ToString();
if (attributeValue.StartsWith(config.V1Connection.CustomField))
{
customFieldName = attributeValue;
break;
}
}
return customFieldName;
}
return null;
}
private IAPIConnector GetConnector(string path, bool anonymous)
{
var connector = new VersionOneAPIConnector(ApplicationUrl + path, proxyProvider: Proxy);
if (anonymous)
{
return(connector);
}
connector.WithVersionOneUsernameAndPassword(_username, _password);
if (_integratedAuth)
{
connector.WithWindowsIntegratedAuthentication();
}
return(connector);
}
private IAPIConnector MakeConnector(string path, ProxyProvider proxy = null)
{
var connector = new VersionOneAPIConnector(path, proxyProvider: proxy);
if (_storage != null)
return connector.WithOAuth2(_storage);
if (_useWindowsIntegratedAuth)
return connector.WithWindowsIntegratedAuthentication();
if (!string.IsNullOrWhiteSpace(_credentials.V1UserName))
return connector
.WithVersionOneUsernameAndPassword(_credentials.V1UserName, _credentials.V1Password);
throw new Exception("It was not possible to create a connector with the current authentication configuration.");
}
static void Main(string[] args)
{
var dataConnector = new VersionOneAPIConnector(BASE_URL + "/rest-1.v1/").WithOAuth2(SecretsFile, CredsFile);
var metaConnector = new VersionOneAPIConnector(BASE_URL + "/meta.v1/");
var metaModel = new MetaModel(metaConnector);
var services = new Services(metaModel, dataConnector);
var scopeType = metaModel.GetAssetType("Member");
var nameAttr = scopeType.GetAttributeDefinition("Name");
var descAttr = scopeType.GetAttributeDefinition("Nickname");
var worksItemsNameAttr = scopeType.GetAttributeDefinition("OwnedWorkitems.Name");
var query = new Query(scopeType);
var whereAdmin = new FilterTerm(descAttr);
whereAdmin.Equal("admin");
var whereNotTheAdmin = new FilterTerm(nameAttr);
whereNotTheAdmin.NotEqual("theAdmin");
var andFilter = new AndFilterTerm(whereAdmin, whereNotTheAdmin);
query.Filter = andFilter;
query.Selection.AddRange(new[] { nameAttr, descAttr, worksItemsNameAttr });
var result = services.Retrieve(query);
foreach (var asset in result.Assets)
{
Console.WriteLine("Name: " + asset.GetAttribute(nameAttr).Value);
Console.WriteLine("Description: " + asset.GetAttribute(descAttr).Value);
var workItems = asset.GetAttribute(worksItemsNameAttr).ValuesList;
Console.WriteLine("Workitems count: " + workItems.Count);
foreach (var workitem in workItems)
{
Console.WriteLine("Workitem: " + workitem);
}
}
Console.ReadLine();
}
//Verifies the connection to the V1 source instance.
private static void VerifyV1SourceConnection()
{
try
{
_sourceMetaConnector = new V1APIConnector(_config.V1SourceConnection.Url + "/meta.v1/");
if (_config.V1SourceConnection.AuthenticationType == "standard")
{
_sourceDataConnector = new V1APIConnector(_config.V1SourceConnection.Url + "/rest-1.v1/", _config.V1SourceConnection.Username, _config.V1SourceConnection.Password, false);
_sourceImageConnector = new V1APIConnector(_config.V1SourceConnection.Url + "/attachment.img/", _config.V1SourceConnection.Username, _config.V1SourceConnection.Password, false);
}
else if (_config.V1SourceConnection.AuthenticationType == "windows")
{
_logger.Info("Connecting with user {0}.", System.Security.Principal.WindowsIdentity.GetCurrent().Name);
_sourceDataConnector = new V1APIConnector(_config.V1SourceConnection.Url + "/rest-1.v1/", null, null, true);
_sourceImageConnector = new V1APIConnector(_config.V1SourceConnection.Url + "/attachment.img/", null, null, true);
VersionOneAPIConnector v1connec = new VersionOneAPIConnector(_config.V1SourceConnection.Url);
}
else if (_config.V1SourceConnection.AuthenticationType == "oauth")
{
throw new Exception("OAuth authentication is not supported -- yet.");
}
else
{
throw new Exception("Unable to determine the V1SourceConnection authentication type in the config file. Value used must be standard|windows|oauth.");
}
_sourceMetaAPI = new MetaModel(_sourceMetaConnector);
_sourceDataAPI = new Services(_sourceMetaAPI, _sourceDataConnector);
IAssetType assetType = _sourceMetaAPI.GetAssetType("Member");
Query query = new Query(assetType);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Username");
query.Selection.Add(nameAttribute);
FilterTerm idFilter = new FilterTerm(nameAttribute);
idFilter.Equal(_config.V1SourceConnection.Username);
query.Filter = idFilter;
QueryResult result = _sourceDataAPI.Retrieve(query);
if (result.TotalAvaliable > 0)
{
_logger.Info("-> Connection to V1 source instance \"{0}\" verified.", _config.V1SourceConnection.Url);
_logger.Debug("-> V1 source instance version: {0}.", _sourceMetaAPI.Version.ToString());
MigrationStats.WriteStat(_sqlConn, "Source API Version", _sourceMetaAPI.Version.ToString());
}
else
{
throw new Exception(String.Format("Unable to validate connection to {0} with username {1}. You may not have permission to access this instance.", _config.V1SourceConnection.Url, _config.V1SourceConnection.Username));
}
}
catch (Exception ex)
{
_logger.Error("-> Unable to connect to V1 source instance \"{0}\".", _config.V1SourceConnection.Url);
throw ex;
}
}
private VersionOneAPIConnector PopulateHeaders(VersionOneAPIConnector connector)
{
IDictionary<string, string> dict = connector.CustomHttpHeaders;
foreach(KeyValuePair<string, string> pair in _customHttpHeaders) {
dict.Add(pair.Key, pair.Value);
}
return connector;
}
private VersionOneAPIConnector PrepareConnector(string url)
{
var connector = new VersionOneAPIConnector(url, proxyProvider: _proxyProvider);
if (_integratedAuth)
connector.WithWindowsIntegratedAuthentication();
else
connector.WithVersionOneUsernameAndPassword(_username, _password);
return PopulateHeaders(connector);
}
private VersionOneAPIConnector GetConnector(string path, bool anonymous)
{
var connector = new VersionOneAPIConnector(ApplicationUrl + path, proxyProvider: Proxy);
if (anonymous)
return connector;
if (_integratedAuth)
return connector.WithWindowsIntegratedAuthentication();
if (!string.IsNullOrWhiteSpace(_username))
return connector.WithVersionOneUsernameAndPassword(_username, _password);
throw new Exception("It was not possible to create a connector with the current authentication configuration.");
}
public static bool UploadAttachment(string filename, string jiraId, string rawfile)
{
var config = (JiraConnectionConfiguration)ConfigurationManager.GetSection("jiraAttachments");
var metaconnector = new VersionOneAPIConnector(config.V1Connection.ServerUrl + "/meta.v1/");
var dataconnector =
new VersionOneAPIConnector(config.V1Connection.ServerUrl + "/rest-1.v1/")
.WithVersionOneUsernameAndPassword(config.V1Connection.Username, config.V1Connection.Password);
var attachmentconnector =
new VersionOneAPIConnector(config.V1Connection.ServerUrl + "/attachment.img/")
.WithVersionOneUsernameAndPassword(config.V1Connection.Username, config.V1Connection.Password);
MetaModel metaModel = new MetaModel(metaconnector);
Services services = new Services(metaModel, dataconnector);
Attachments attachments = new Attachments(attachmentconnector);
string mimeType = MimeType.Resolve(filename);
string assetoid = GetAssetOid(jiraId, "PrimaryWorkitem");
if (String.IsNullOrEmpty(assetoid))
{
assetoid = GetAssetOid(jiraId, "Task");
}
if (String.IsNullOrEmpty(assetoid)) return false;
Oid attachmentContext = Oid.FromToken(assetoid, metaModel);
IAssetType attachmentType = metaModel.GetAssetType("Attachment");
IAttributeDefinition attachmentNameDef = attachmentType.GetAttributeDefinition("Name");
IAttributeDefinition attachmentContentDef = attachmentType.GetAttributeDefinition("Content");
IAttributeDefinition attachmentContentTypeDef = attachmentType.GetAttributeDefinition("ContentType");
IAttributeDefinition attachmentFileNameDef = attachmentType.GetAttributeDefinition("Filename");
Asset newAttachment = services.New(attachmentType, attachmentContext);
newAttachment.SetAttributeValue(attachmentNameDef, "Imported from Jira");
newAttachment.SetAttributeValue(attachmentContentDef, string.Empty);
newAttachment.SetAttributeValue(attachmentContentTypeDef, mimeType);
newAttachment.SetAttributeValue(attachmentFileNameDef, rawfile);
services.Save(newAttachment);
//Setup and attach the payload
string attachmentKey = newAttachment.Oid.Key.ToString();
int buffersize = 4096;
using (FileStream input = new FileStream(filename, FileMode.Open, FileAccess.Read))
{
using (Stream output = attachments.GetWriteStream(attachmentKey))
{
byte[] buffer = new byte[buffersize];
for (; ; )
{
int read = input.Read(buffer, 0, buffersize);
if (read == 0)
break;
output.Write(buffer, 0, read);
}
}
}
attachments.SetWriteStream(attachmentKey, mimeType);
return true;
}
