C# Asset.GetAttribute方法代码示例

        /// <summary>
        /// Validate single Asset attribute. If attribute is not loaded, it is just considered invalid.
        /// </summary>
        /// <param name="asset">Asset to validate</param>
        /// <param name="attributeDefinition">Attribute definition of validated attribute</param>
        /// <returns>Validation result</returns>
        // TODO create separate private method to avoid excessive GetRequiredFields() calls
        public bool Validate(Asset asset, IAttributeDefinition attributeDefinition)
        {
            GetRequiredFields(asset.AssetType);
            asset.EnsureAttribute(attributeDefinition);
            Attribute attribute = asset.GetAttribute(attributeDefinition);
            bool result = attribute != null && !(IsMultiValueAndUnfilled(attribute) || IsSingleValueAndUnfilled(attribute));

            if (!result && attribute != null)
            {
                result = !attribute.HasChanged && !isAttributeUnfilledOnServer(asset, attributeDefinition);
            }

            return result;
        }

 private static string GetAttributeValue(Asset asset, IAttributeDefinition attributeDef)
 {
     var value = asset.GetAttribute(attributeDef).Value;
     return (null != value) ? value.ToString() : "";
 }

 private void AssertMultiValueAttribute(object expected, Asset subject, string attributeToken)
 {
     IAttributeDefinition def = _svc.StubCentral.MetaModel.GetAttributeDefinition(attributeToken);
     IList values = subject.GetAttribute(def).ValuesList;
     Assert.IsNotNull(values);
     Assert.IsTrue(values.Contains(expected), "Attribute: {0}\n Values: {1}\n Expected: {2}", attributeToken, EnumerateValues(values), expected);
 }

 private void AssertSingleValueAttribute(object expected, Asset subject, string attributeToken)
 {
     IAttributeDefinition def = _svc.StubCentral.MetaModel.GetAttributeDefinition(attributeToken);
     object actual = subject.GetAttribute(def).Value;
     Assert.AreEqual(expected, actual, attributeToken);
 }

        private Oid FindTimebox(Asset test) {
            if(createDefect == CreateDefect.CurrentIteration) {
                return test.GetAttribute(TestTimeboxDef).Value as Oid;
            }

            return FindTimebox(test.GetAttribute(TestScheduleDef).Value as Oid);
        }

        private IEnumerable<ProjectWrapper> GetProjectWrapperList(Asset asset, IAttributeDefinition attrName, int depth) {
            var list = new List<ProjectWrapper>{new ProjectWrapper(asset, asset.GetAttribute(attrName).Value.ToString(), depth)};

            foreach (var child in asset.Children) {
                list.AddRange(GetProjectWrapperList(child, attrName, depth + 1));
            }
            
            return list;
        }

        private Asset CreateRelatedDefect(string newDescription, Asset test) {
            var defect = Services.New(DefectType, Oid.Null);
            defect.AddAttributeValue(DefectAffectedWorkitemsDef, test.GetAttribute(TestParentDef).Value);
            defect.SetAttributeValue(DefectScopeDef, test.GetAttribute(TestScopeDef).Value);

            var parent = (Oid)test.GetAttribute(TestParentDef).Value;
            
            defect.SetAttributeValue(DefectType.GetAttributeDefinition("Name"),
                string.Format(
                    "{0} \"{1}\" has failing Acceptance Test(s)",
                    Services.Localization(parent.AssetType.DisplayName),
                    test.GetAttribute(TestParentNumberDef).Value));

            defect.SetAttributeValue(DefectType.GetAttributeDefinition("Description"), newDescription);

            var timeboxOid = FindTimebox(test);

            if(!timeboxOid.IsNull) {
                defect.SetAttributeValue(DefectTimeboxDef, timeboxOid);
            }

            return defect;
        }

        private void UpdateOpenTest(Oid newStatus, Asset test) {
            var statusAttribute = test.GetAttribute(TestStatusDef);
            var statusOid = (Oid)statusAttribute.Value;

            if(newStatus != statusOid) {
                test.SetAttributeValue(TestStatusDef, newStatus);
                Services.Save(test, changeComment);
                Logger.Log(string.Format("Updating status of Acceptance Test \"{0}\".", test.Oid.Token));
            }
        }

        private bool RelatedDefectExists(Asset test) {
            var primaryWorkitemQuery = new Query(PrimaryWorkitem);

            var affectedTerm = new FilterTerm(DefectAffectedWorkitemsDef);
            affectedTerm.Equal(test.GetAttribute(TestParentDef).Value);
            var statusTerm = new FilterTerm(DefectAssetStateDef);
            statusTerm.Equal(AssetState.Active);
            primaryWorkitemQuery.Filter = new AndFilterTerm(affectedTerm, statusTerm);

            return Services.Retrieve(primaryWorkitemQuery).Assets.Count > 0;
        }

        private bool TimeboxIsCurrent(Asset test) {
            var timeboxOid = test.GetAttribute(TestTimeboxDef).Value as Oid;

            if((timeboxOid == null) || timeboxOid.IsNull) {
                return false;
            }

            var timeboxStateQuery = new Query(TimeboxType);
            timeboxStateQuery.Selection.Add(TimeboxAssetStateDef);
            var term = new FilterTerm(TimeboxType.GetAttributeDefinition("ID"));
            term.Equal(timeboxOid.Token);
            timeboxStateQuery.Filter = term;

            var result = Services.Retrieve(timeboxStateQuery);

            if(result.Assets.Count == 0) {
                return false;
            }

            var timebox = result.Assets[0];

            return ((AssetState)timebox.GetAttribute(TimeboxAssetStateDef).Value == AssetState.Active);
        }

 internal Link(Asset asset) {
     Title = asset.GetAttribute(asset.AssetType.GetAttributeDefinition(Entity.NameProperty)).Value.ToString();
     Url = asset.GetAttribute(asset.AssetType.GetAttributeDefinition(UrlProperty)).Value.ToString();
     OnMenu = (bool)asset.GetAttribute(asset.AssetType.GetAttributeDefinition(OnMenuProperty)).Value;
 }

        /// <summary>
        /// Check if asset should be used when Show My Tasks filter is on
        /// </summary>
        /// <param name="asset">Story, Task, Defect or Test</param>
        /// <returns>true if current user is owner of asset, false - otherwise</returns>
        public bool AssetPassesShowMyTasksFilter(Asset asset) {
            if(asset.HasChanged || asset.Oid.IsNull) {
                return true;
            }

            var definition = workitemType.GetAttributeDefinition(Entity.OwnersProperty);
            var attribute = asset.GetAttribute(definition);
            var owners = attribute.Values;
            
            if(owners.Cast<Oid>().Any(oid => oid == MemberOid)) {
                return true;
            }

            return asset.Children != null && asset.Children.Any(AssetPassesShowMyTasksFilter);
        }

        private void SaveChangeSetLink(ChangeSetInfo info, Asset savedAsset) 
        {
            var name = string.Format(info.Link.Name, info.Revision);
            var url = string.Format(info.Link.Url, info.Revision);
            var linkUrlAttribute = savedAsset.GetAttribute(ChangeSetType.GetAttributeDefinition("Links.URL"));

            if(linkUrlAttribute != null) 
            {
                foreach(string value in linkUrlAttribute.Values) 
                {
                    if(value.Equals(url, StringComparison.InvariantCultureIgnoreCase)) 
                    {
                        return;
                    }
                }
            }

            var newlink = V1Connection.Data.New(LinkType, savedAsset.Oid.Momentless);
            newlink.SetAttributeValue(LinkNameDef, name);
            newlink.SetAttributeValue(LinkUrlDef, url);
            newlink.SetAttributeValue(LinkOnMenuDef, info.Link.OnMenu);

            V1Connection.Data.Save(newlink, changecomment);
        }