public BuildResult Build(Query query, BuildResult result) {
foreach (var builder in Builders) {
builder.Build(query, result);
}
return result;
}
public DateTime? GetMostRecentChangeDateTime()
{
var defectType = _meta.GetAssetType("Defect");
var query = new Query(defectType);
var projectAttribute = defectType.GetAttributeDefinition("Scope");
var projectTerm = new FilterTerm(projectAttribute);
projectTerm.Equal(MonitoredProjects.Select(project => project.ScopeId).Cast<Object>().ToArray());
var changeAttribute = defectType.GetAttributeDefinition("ChangeDateUTC");
query.Selection.Add(changeAttribute);
if (_mostRecentChangeDateTime.HasValue)
{
var changeTerm = new FilterTerm(changeAttribute);
changeTerm.Greater(_mostRecentChangeDateTime.Value.ToString("yyyy-MM-ddTHH:mm:ss.fff", CultureInfo.InvariantCulture));
query.Filter = new AndFilterTerm(changeTerm, projectTerm);
} else
{
query.Filter = projectTerm;
}
var result = _services.Retrieve(query);
if (result.TotalAvaliable > 0)
{
foreach (var asset in result.Assets)
{
var projectChangeDateTime = DB.DateTime(asset.GetAttribute(changeAttribute).Value);
if ((!_mostRecentChangeDateTime.HasValue) || (projectChangeDateTime > _mostRecentChangeDateTime))
{
_mostRecentChangeDateTime = projectChangeDateTime;
}
}
}
return _mostRecentChangeDateTime;
}
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();
}
protected override void DoBuild(Query query, BuildResult result)
{
if (query.AsOf.CompareTo(DateTime.MinValue) > 0)
{
result.QuerystringParts.Add("asof=" + query.AsOf.ToString("yyyy-MM-ddTHH:mm:ss"));
}
}
public void QueryForNameAndStatus()
{
Oid defectId = Oid.FromToken("Defect:2258150", metaModel);
Query query = new Query(defectId);
IAssetType defectType = metaModel.GetAssetType("Defect");
IAttributeDefinition nameAttribute = defectType.GetAttributeDefinition("Name");
IAttributeDefinition statusAttribute = defectType.GetAttributeDefinition(Entity.StatusProperty);
IAttributeDefinition statusNameAttribute = defectType.GetAttributeDefinition(Entity.StatusNameProperty);
query.Selection.Add(nameAttribute);
query.Selection.Add(statusAttribute);
query.Selection.Add(statusNameAttribute);
QueryResult result = services.Retrieve(query);
Asset defect = result.Assets[0];
string name = defect.GetAttribute(nameAttribute).Value.ToString();
string status = defect.GetAttribute(statusAttribute).Value.ToString();
string statusName = defect.GetAttribute(statusNameAttribute).Value.ToString();
defect.SetAttributeValue(statusAttribute, "StoryStatus:135");
services.Save(defect);
string newStatusName = defect.GetAttribute(statusAttribute).Value.ToString();
Console.WriteLine(string.Format("{0} - {1} ", statusName, newStatusName));
}
protected Object GetSingleListValue(VersionOne.SDK.APIClient.Attribute attribute)
{
if (attribute.Value != null && attribute.Value.ToString() != "NULL")
{
IAssetType assetType = _metaAPI.GetAssetType("List");
Query query = new Query(assetType);
IAttributeDefinition assetIDAttribute = assetType.GetAttributeDefinition("ID");
query.Selection.Add(assetIDAttribute);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
FilterTerm assetName = new FilterTerm(assetIDAttribute);
assetName.Equal(attribute.Value.ToString());
query.Filter = assetName;
QueryResult result = _dataAPI.Retrieve(query);
return result.Assets[0].GetAttribute(nameAttribute).Value.ToString();
}
else
{
return DBNull.Value;
}
}
public static void SaveItemAssociations(Project project)
{
if (project.BuildRuns.Count > 0)
{
// There is no direct association between workitems and affected/included build runs.
// The indirect association occurs by relationship to ChangeSets.
string defectId = project.Defects.First(x => x.Name.Equals("Fix performance SLA on load")).Id;
IAssetType defectType = Program.MetaModel.GetAssetType("Defect");
Query query = new Query(Oid.FromToken(defectId, Program.MetaModel));
IAttributeDefinition foundDefectsDef = defectType.GetAttributeDefinition("FoundInBuildRuns");
IAttributeDefinition completedDef = defectType.GetAttributeDefinition("CompletedInBuildRuns");
IAttributeDefinition changeSetsDef = defectType.GetAttributeDefinition("ChangeSets");
QueryResult result = Program.Services.Retrieve(query);
Asset asset = result.Assets[0];
// Found in first build run and completed in last build run
// Included in build runs 2 and 3 (via ChangeSets)
asset.AddAttributeValue(foundDefectsDef, Oid.FromToken(project.BuildRuns[0].Id, Program.MetaModel));
asset.AddAttributeValue(completedDef, Oid.FromToken(project.BuildRuns[2].Id, Program.MetaModel));
asset.AddAttributeValue(changeSetsDef, Oid.FromToken(project.ChangeSets[1].Id, Program.MetaModel));
asset.AddAttributeValue(changeSetsDef, Oid.FromToken(project.ChangeSets[2].Id, Program.MetaModel));
Program.Services.Save(asset);
string storyId = project.Stories.First(x => x.Name.Equals("List of Books by Author")).Id;
IAssetType storyType = Program.MetaModel.GetAssetType("Story");
query = new Query(Oid.FromToken(storyId, Program.MetaModel));
IAttributeDefinition completedStoryDef = storyType.GetAttributeDefinition("CompletedInBuildRuns");
IAttributeDefinition changeSetsStoryDef = storyType.GetAttributeDefinition("ChangeSets");
result = Program.Services.Retrieve(query);
asset = result.Assets[0];
// Completed in last build run
// Included in build runs 2 and 3 (via ChangeSets)
asset.AddAttributeValue(completedStoryDef, Oid.FromToken(project.BuildRuns[2].Id, Program.MetaModel));
asset.AddAttributeValue(changeSetsStoryDef, Oid.FromToken(project.ChangeSets[1].Id, Program.MetaModel));
asset.AddAttributeValue(changeSetsStoryDef, Oid.FromToken(project.ChangeSets[2].Id, Program.MetaModel));
Program.Services.Save(asset);
storyId = project.Stories.First(x => x.Name.Equals("View Book Details")).Id;
query = new Query(Oid.FromToken(storyId, Program.MetaModel));
result = Program.Services.Retrieve(query);
asset = result.Assets[0];
// Included in all 3 build runs (via ChangeSets)
// Not completed yet
asset.AddAttributeValue(changeSetsStoryDef, Oid.FromToken(project.ChangeSets[0].Id, Program.MetaModel));
asset.AddAttributeValue(changeSetsStoryDef, Oid.FromToken(project.ChangeSets[1].Id, Program.MetaModel));
asset.AddAttributeValue(changeSetsStoryDef, Oid.FromToken(project.ChangeSets[2].Id, Program.MetaModel));
Program.Services.Save( asset );
}
}
private string GetLoggedInMemberRole()
{
var query = new Query(Services.LoggedIn);
var defaultRoleAttribute = Services.Meta.GetAssetType(MemberType).GetAttributeDefinition(DefaultRoleNameProperty);
query.Selection.Add(defaultRoleAttribute);
return Services.Localization(defaultRoleAttribute);
}
public FluentQuery(
string assetTypeName)
{
RawQuery = new Query(MetaModelProvider.Meta.GetAssetType(assetTypeName));
AssetTypeName = assetTypeName;
WhereCriteria = new List<Tuple<string, object, FilterTerm.Operator>>();
SelectFields = new List<object>();
}
private string GetLoggedInMemberRole() {
var query = new Query(Central.Services.LoggedIn);
var defaultRoleAttribute = Central.MetaModel.GetAssetType(MemberType).GetAttributeDefinition(DefaultRoleNameProperty);
query.Selection.Add(defaultRoleAttribute);
var asset = Central.Services.Retrieve(query).Assets[0];
var role = asset.GetAttribute(defaultRoleAttribute);
return Central.Loc.Resolve(role.Value.ToString());
}
public void FilterExist() {
var assetType = Instance.ApiClient.MetaModel.GetAssetType("Story");
var customFilter = new FilterTerm(assetType.GetAttributeDefinition("Timebox"));
customFilter.Exists();
var query = new Query(assetType) {Filter = customFilter};
Instance.ApiClient.Services.Retrieve(query);
}
public static Asset GetDefaultSchedule()
{
IAssetType assetType = Program.MetaModel.GetAssetType("Schedule");
Query query = new Query(assetType);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
query.Find = new QueryFind("Default Schedule", new AttributeSelection(nameAttribute));
QueryResult result = Program.Services.Retrieve(query);
return result.Assets[0];
}
public void Run()
{
Log("Get some meta stuff");
IAssetType memberType = Meta.GetAssetType("Member");
Log(memberType.DisplayName);
Log("Perform a query");
var query = new Query(memberType);
QueryResult result = Services.Retrieve(query);
Log(string.Format("Server returned {0} members", result.TotalAvaliable));
}
public User CreateUserToDeactivate(string username) {
User user = CreateTestUser(username);
user.Deactivate = true;
IAssetType member = model.GetAssetType("Member");
Query query = new Query(member);
FilterTerm term = new FilterTerm(member.GetAttributeDefinition("Username"));
term.Equal(username);
query.Filter = term;
QueryResult result = services.Retrieve(query);
user.V1MemberAsset = result.Assets[0];
return user;
}
public AssetList Query(string workitemTypeName, IFilterTerm filter)
{
try {
var workitemType = metaModel.GetAssetType(workitemTypeName);
var query = new Query(workitemType) { Filter = filter};
AddSelection(query, workitemTypeName, workitemType);
return services.Retrieve(query).Assets;
} catch (Exception ex) {
throw new VersionOneException(ex.Message);
}
}
protected override void DoBuild(Query query, BuildResult result)
{
if (query == null || query.Find == null || string.IsNullOrEmpty(query.Find.Text)) return;
var part = string.Concat("find=", HttpUtility.UrlEncode(query.Find.Text));
result.QuerystringParts.Add(part);
if (query.Find.Attributes == null || query.Find.Attributes.Count == 0 || string.IsNullOrEmpty(query.Find.Attributes.Token)) return;
part = string.Concat("findin=", HttpUtility.UrlEncode(query.Find.Attributes.Token));
result.QuerystringParts.Add(part);
}
public override int Export()
{
IAssetType assetType = _metaAPI.GetAssetType("AttributeDefinition");
Query query = new Query(assetType);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition isBasicAttribute = assetType.GetAttributeDefinition("IsBasic");
query.Selection.Add(isBasicAttribute);
IAttributeDefinition nativeValueAttribute = assetType.GetAttributeDefinition("NativeValue");
query.Selection.Add(nativeValueAttribute);
IAttributeDefinition isCustomAttribute = assetType.GetAttributeDefinition("IsCustom");
query.Selection.Add(isCustomAttribute);
IAttributeDefinition isReadOnlyAttribute = assetType.GetAttributeDefinition("IsReadOnly");
query.Selection.Add(isReadOnlyAttribute);
IAttributeDefinition isRequiredAttribute = assetType.GetAttributeDefinition("IsRequired");
query.Selection.Add(isRequiredAttribute);
IAttributeDefinition attributeTypeAttribute = assetType.GetAttributeDefinition("AttributeType");
query.Selection.Add(attributeTypeAttribute);
IAttributeDefinition assetNameAttribute = assetType.GetAttributeDefinition("Asset.Name");
query.Selection.Add(assetNameAttribute);
//Filter on asset type and if attribute definition is custom.
FilterTerm assetName = new FilterTerm(assetNameAttribute);
assetName.Equal(_InternalAssetType);
FilterTerm isCustom = new FilterTerm(isCustomAttribute);
isCustom.Equal("true");
query.Filter = new AndFilterTerm(assetName, isCustom);
QueryResult result = _dataAPI.Retrieve(query);
int customFieldCount = 0;
foreach (Asset asset in result.Assets)
{
string attributeName = GetScalerValue(asset.GetAttribute(nameAttribute)).ToString();
string attributeType = GetScalerValue(asset.GetAttribute(attributeTypeAttribute)).ToString();
if (attributeName.StartsWith("Custom_"))
{
_logger.Info("The CustomField is {0} and Type is {1}", attributeName, attributeType);
customFieldCount += GetCustomFields(attributeName, attributeType);
}
}
return customFieldCount;
}
public static void BlockDefectWithIssue(Project project)
{
if (project.Issues.Count > 0)
{
Query query = new Query(Oid.FromToken(project.Issues[0].Id, Program.MetaModel));
IAttributeDefinition workitemsDef = Program.MetaModel.GetAttributeDefinition("Issue.BlockedPrimaryWorkitems");
QueryResult result = Program.Services.Retrieve(query);
Asset issue = result.Assets[0];
string defectId = project.Defects.First(x => x.Name.Equals("Fix performance SLA on load")).Id;
issue.AddAttributeValue(workitemsDef, Oid.FromToken(defectId, Program.MetaModel));
Program.Services.Save(issue);
}
}
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;
}
// 8/7/2012 AJB Commented out to replace with new version of method based on API changes for Epics.
//public static void SaveEpics(Project project, IList<Member> owners)
//{
// IAssetType storyType = Program.MetaModel.GetAssetType("Story");
// IAttributeDefinition nameDef = storyType.GetAttributeDefinition("Name");
// IAttributeDefinition ownersDef = storyType.GetAttributeDefinition("Owners");
// Utils.Logger.Info("ABOUT TO SAVE EPICS FOR: " + project.Name);
// foreach (Epic epic in project.Epics)
// {
// Asset asset = Program.Services.New(storyType, Oid.FromToken(project.Id, Program.MetaModel));
// asset.SetAttributeValue(nameDef, epic.Name);
// asset.AddAttributeValue(ownersDef, Oid.FromToken(owners[0].Id, Program.MetaModel));
// Program.Services.Save(asset);
// epic.Id = asset.Oid.Momentless.Token;
// IOperation storyToEpic = storyType.GetOperation("StoryToEpic");
// Program.Services.ExecuteOperation(storyToEpic, asset.Oid);
// }
//}
public static void AddStoriesToEpic(Project project)
{
var stories = project.Stories.Where(x => x.Name.StartsWith("Search by"));
foreach (Story item in stories)
{
Query query = new Query(Oid.FromToken(item.Id, Program.MetaModel));
IAssetType storyType = Program.MetaModel.GetAssetType("Story");
IAttributeDefinition superDef = storyType.GetAttributeDefinition("Super");
QueryResult result = Program.Services.Retrieve(query);
Asset story = result.Assets[0];
story.SetAttributeValue(superDef, project.Epics[0].Id);
Program.Services.Save(story);
}
}
public static void UpdateTest(string testId, string status, int todo)
{
Query query = new Query(Oid.FromToken(testId, Program.MetaModel));
IAssetType testType = Program.MetaModel.GetAssetType("Test");
IAttributeDefinition statusAttribute = testType.GetAttributeDefinition("Status");
IAttributeDefinition toDoAttribute = testType.GetAttributeDefinition("ToDo");
QueryResult result = Program.Services.Retrieve(query);
Asset test = result.Assets[0];
test.SetAttributeValue(statusAttribute, Oid.FromToken(status, Program.MetaModel));
if (todo > -1)
test.SetAttributeValue(toDoAttribute, todo);
Program.Services.Save(test);
}
internal static string GetAssetIDFromCode(string AssetType, string Code, IMetaModel MetaAPI, IServices DataAPI)
{
IAssetType assetType = MetaAPI.GetAssetType(AssetType);
Query query = new Query(assetType);
IAttributeDefinition codeAttribute = assetType.GetAttributeDefinition("Code");
FilterTerm term = new FilterTerm(codeAttribute);
term.Equal(Code);
query.Filter = term;
QueryResult result = DataAPI.Retrieve(query);
if (result.TotalAvaliable > 0)
return result.Assets[0].Oid.Token;
else
return String.Empty;
}
private void AddSelection(Query query, string typePrefix, IAssetType type) {
foreach (var attrInfo in attributesToQuery.Where(attrInfo => attrInfo.Prefix == typePrefix)) {
IAttributeDefinition def;
if (attrInfo.IsOptional) {
if (!type.TryGetAttributeDefinition(attrInfo.Attr, out def)) {
continue;
}
} else {
def = type.GetAttributeDefinition(attrInfo.Attr);
}
query.Selection.Add(def);
}
}
public AssetList Query(string workitemTypeName, IFilterTerm filter) {
try {
var workitemType = metaModel.GetAssetType(workitemTypeName);
var query = new Query(workitemType) { Filter = filter};
if(sortBy != null) {
var order = sortBy.Order == Order.Ascending ? OrderBy.Order.Ascending : OrderBy.Order.Descending;
query.OrderBy.MajorSort(workitemType.GetAttributeDefinition(sortBy.Attribute), order);
}
AddSelection(query, workitemTypeName, workitemType);
return services.Retrieve(query).Assets;
} catch (Exception ex) {
throw new VersionOneException(ex.Message);
}
}
/**************************************************************************************
* Protected methods used by derived classes.
**************************************************************************************/
protected Asset GetAssetFromV1(string AssetID)
{
Oid assetId = Oid.FromToken(AssetID, _metaAPI);
Query query = new Query(assetId);
IAssetType assetType = _metaAPI.GetAssetType("Epic");
IAttributeDefinition assetStateAttribute = assetType.GetAttributeDefinition("AssetState");
query.Selection.Add(assetStateAttribute);
QueryResult result = _dataAPI.Retrieve(query);
if (result.Assets.Count > 0)
return result.Assets[0];
else
return null;
}
private void UpdateStory(AssetID id, string originalName, string newName)
{
IMetaModel metaModel = Instance.ApiClient.MetaModel;
IServices services = Instance.ApiClient.Services;
Oid storyId = Oid.FromToken(id.Token, metaModel);
Query query = new Query(storyId);
IAssetType storyType = metaModel.GetAssetType("Story");
IAttributeDefinition nameAttribute = storyType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
QueryResult result = services.Retrieve(query);
Asset storyAsset = result.Assets[0];
string oldName = storyAsset.GetAttribute(nameAttribute).Value.ToString();
Assert.AreEqual(originalName, oldName);
storyAsset.SetAttributeValue(nameAttribute, newName);
services.Save(storyAsset);
}
public QueryResult Retrieve(Query query) {
var doc = new XmlDocument();
try {
using(var stream = connector.GetData(new QueryURLBuilder(query).ToString())) {
doc.Load(stream);
}
} catch (WebException ex) {
//if we get a 404, return an empty query result otherwise throw the exception
if(ex.Response is HttpWebResponse && ((HttpWebResponse)ex.Response).StatusCode == HttpStatusCode.NotFound) {
return GetEmptyQueryResult(query);
}
throw;
}
return ParseQueryResult(doc.DocumentElement, query);
}
public bool HasChangedSince(DateTime? lastCheckedDateTime)
{
if (!lastCheckedDateTime.HasValue)
{
return true;
}
var defectType = _meta.GetAssetType("Defect");
var query = new Query(defectType);
var changeAttribute = defectType.GetAttributeDefinition("ChangeDateUTC");
var changeTerm = new FilterTerm(changeAttribute);
changeTerm.Greater(lastCheckedDateTime.Value.ToString("yyyy-MM-ddTHH:mm:ss.fff", CultureInfo.InvariantCulture));
var projectAttribute = defectType.GetAttributeDefinition("Scope");
var projectTerm = new FilterTerm(projectAttribute);
projectTerm.Equal(MonitoredProjects.Select(project => project.ScopeId).Cast<Object>().ToArray());
query.Filter = new AndFilterTerm(changeTerm, projectTerm);
var result = _services.Retrieve(query);
return result.TotalAvaliable > 0;
}
public override int Export()
{
int listTypeCount = 0;
string SQL = BuildListTypeInsertStatement();
foreach (V1DataCore.MigrationConfiguration.ListTypeInfo listType in _config.ListTypesToMigrate)
{
if (listType.Enabled == true)
{
IAssetType assetType = _metaAPI.GetAssetType(listType.Name);
Query query = new Query(assetType);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition assetStateAttribute = assetType.GetAttributeDefinition("AssetState");
query.Selection.Add(assetStateAttribute);
IAttributeDefinition descriptionAttribute = assetType.GetAttributeDefinition("Description");
query.Selection.Add(descriptionAttribute);
QueryResult result = _dataAPI.Retrieve(query);
foreach (Asset asset in result.Assets)
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = _sqlConn;
cmd.CommandText = SQL;
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.AddWithValue("@AssetOID", asset.Oid.ToString());
cmd.Parameters.AddWithValue("@AssetType", listType.Name);
cmd.Parameters.AddWithValue("@AssetState", GetScalerValue(asset.GetAttribute(assetStateAttribute)));
cmd.Parameters.AddWithValue("@Description", GetScalerValue(asset.GetAttribute(descriptionAttribute)));
cmd.Parameters.AddWithValue("@Name", GetScalerValue(asset.GetAttribute(nameAttribute)));
cmd.ExecuteNonQuery();
}
listTypeCount++;
}
}
}
return listTypeCount;
}
public IDictionary<string, User> GetVersionOneUsers() {
IAssetType memberType = _model.GetAssetType(V1Constants.MEMBER);
Query userQuery = new Query(memberType);
IAttributeDefinition username = _model.GetAttributeDefinition(V1Constants.USERNAME);
IAttributeDefinition isInactive = _model.GetAttributeDefinition(V1Constants.ISINACTIVE);
IAttributeDefinition ckInactivate = _model.GetAttributeDefinition(V1Constants.CHECKINACTIVATE);
userQuery.Selection.Add(username);
userQuery.Selection.Add(isInactive);
userQuery.Selection.Add(ckInactivate);
QueryResult result = _services.Retrieve(userQuery);
IDictionary<string, User> v1UserList = BuildV1UsersList(result.Assets);
logger.Info(v1UserList.Count + " users successfully retrieved from VersionOne.");
//[count] users successfully retrieved from V1...
return v1UserList;
}
