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);
            }
        }