C# APIClient.Asset类代码示例

        protected void AddMultiValueRelation(IAssetType assetType, Asset asset, string TableName, string attributeName, string valueList)
        {
            IAttributeDefinition customerAttribute = assetType.GetAttributeDefinition(attributeName);
            string[] values = valueList.Split(';');
            foreach (string value in values)
            {
                //SPECIAL CASE: Skip "Member:20" for Scope.Members attribute.
                if (assetType.Token == "Scope" && attributeName == "Members" && value == "Member:20") continue;

                if (String.IsNullOrEmpty(value)) continue;

                string newAssetOID = GetNewAssetOIDFromDB(value, TableName);

                if (String.IsNullOrEmpty(newAssetOID) == false)

                    //SPECIAL CASE: Epic conversion issue. If setting story dependants or dependencies, ensure that we do not set for Epic values.
                    if ((attributeName == "Dependants" || attributeName == "Dependencies") && newAssetOID.Contains("Epic"))
                    {
                        continue;
                    }
                    else
                    {
                        asset.AddAttributeValue(customerAttribute, newAssetOID);
                    }
            }
        }

 internal Entity(Asset asset, IEntityFieldTypeResolver typeResolver)
     : base(asset)
 {
     Id = asset.Oid.Momentless.ToString();
     TypeName = asset.AssetType.Token;
     TypeResolver = typeResolver;
 }

 private void ValidateAsset(Asset asset, IDictionary<Asset, List<RequiredFieldsDto>> validationResults) {
     var fields = Validate(asset);
     
     if (fields.Count > 0) {
         validationResults.Add(asset, fields);
     }
 }

        private Project(Asset asset) : base(asset, null) {
            // the following check is for unit tests
            if(asset == null || asset.Children == null) {
                return;
            }

            Children.AddRange(asset.Children.Select(item => WorkitemFactory.CreateProject(item, this)));
        }

        private void DeleteAsset(Asset subject)
        {
            if(subject == null) {
                return;
            }

            var operation = subject.AssetType.GetOperation(VersionOneProcessor.DeleteOperation);
            services.ExecuteOperation(operation, subject.Oid);
        }

 internal static new PrimaryWorkitem Create(Asset asset, IDictionary<string, PropertyValues> listPropertyValues, IEntityFieldTypeResolver typeResolver, IList<Member> owners = null) {
     switch(asset.AssetType.Token) {
         case VersionOneProcessor.StoryType:
             return new Story(asset, listPropertyValues, typeResolver, owners);
         case VersionOneProcessor.DefectType:
             return new Defect(asset, listPropertyValues, typeResolver, owners);
         default:
             throw new NotSupportedException("Type " + asset.AssetType.Token + " is not supported in factory method");
     }
 }

 private static void SetAssetAttribute(Asset asset, string attrName, object value) {
     var type = asset.AssetType;
     var def = type.GetAttributeDefinition(attrName);
     
     if (value == null || (value is Oid && value.Equals(Oid.Null))) {
         asset.EnsureAttribute(def);
     } else {
         asset.SetAttributeValue(def, value);
     }
 }

        public void WriteAsset(Asset asset) {
            writer.WriteStartElement("Asset");

            if(!asset.Oid.IsNull) {
                writer.WriteAttributeString("id", asset.Oid.Token);
            }

            foreach(var attribute in asset.Attributes.Values) {
                WriteAttributeReference(attribute);
            }

            writer.WriteEndElement();
        }

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

        internal Asset CreateAssetForPrimaryWorkitem(string typeToken) {
            var type = ResolveAssetTypeFor(typeToken);

            try {
                var asset = new Asset(type);

                SetupAssetAttributes(asset, typeToken);
                LoadAssetAttribute(asset, "Scope.Name", currentProject.GetProperty(Entity.NameProperty));
                LoadAssetAttribute(asset, "Timebox.Name", currentProject.GetProperty("Schedule.EarliestActiveTimebox.Name"));
                SetAssetAttribute(asset, "Timebox", currentProject.GetProperty("Schedule.EarliestActiveTimebox"));
                SetAssetAttribute(asset, "Scope", currentProject.Asset.Oid);

                return asset;
            } catch(MetaException ex) {
                throw new DataLayerException("Cannot create new " + typeToken, ex);
            } catch(APIException ex) {
                throw new DataLayerException("Cannot create new " + typeToken, ex);
            }
        }

		public void AddLinkToWorkitem()
		{
			const string url = "http://qqq.com";
			const string title = "Url title";
			var workitemAsset = new Asset(new TestOid(new TestAssetType("Workitem"), 100, null));
			var workitem = new TestWorkitem(workitemAsset, null);
			var link = new Link(url, title);
			var linkAsset = new TestAssetType("Link");
			var asset = new Asset(new TestOid(new TestAssetType("Link"), 10, null));

			Expect.Call(_mockMetaModel.GetAssetType(VersionOneProcessor.LinkType)).Return(linkAsset);
			Expect.Call(_mockQueryBuilder.Query(string.Empty, Filter.Empty())).IgnoreArguments().Return(new AssetList());
			Expect.Call(_mockServices.New(null, null)).IgnoreArguments().Return(asset);
			Expect.Call(() => _mockServices.Save(asset));

			_repository.ReplayAll();
			_processor.AddLinkToEntity(workitem, link);
			_repository.VerifyAll();
		}

        internal Workitem(Asset asset, Workitem parent, IEntityContainer entityContainer) : base(asset, entityContainer) {
            Parent = parent;

            //TODO maybe make one more constructor for tests instead of this?
            // the following check is for unit tests            
            if(asset == null || asset.Children == null) {
                return;
            }

            if(!SupportedTypes.Contains(asset.AssetType.Token)) {
                throw new ArgumentException(string.Format("Illegal asset type, '{0}' is not supported.", asset.AssetType.Token));
            }

            foreach (var childAsset in asset.Children.Where(childAsset => DataLayer.ShowAllTasks || DataLayer.AssetPassesShowMyTasksFilter(childAsset))) {
                Children.Add(WorkitemFactory.CreateWorkitem(childAsset, this, entityContainer));
                Children.Sort(new WorkitemComparer(TestType, TaskType));
            }

            Children.TrimExcess();
        }

        internal Asset CreateAssetForSecondaryWorkitem(string typeToken, Workitem parent) {
            var type = ResolveAssetTypeFor(typeToken);

            try {
                var asset = new Asset(type);

                SetupAssetAttributes(asset, typeToken);
                SetAssetAttribute(asset, "Parent", parent.Asset.Oid);
                LoadAssetAttribute(asset, "Scope.Name", currentProject.GetProperty(Entity.NameProperty));
                LoadAssetAttribute(asset, "Parent.Name", parent.GetProperty(Entity.NameProperty));
                LoadAssetAttribute(asset, "Timebox.Name", parent.GetProperty("Timebox.Name"));

                parent.Asset.Children.Add(asset);

                return asset;
            } catch(MetaException ex) {
                throw new DataLayerException("Cannot create new " + typeToken, ex);
            } catch(APIException ex) {
                throw new DataLayerException("Cannot create new " + typeToken, ex);
            }
        }

        public static Asset CreateTeamRoom(Project project, Asset schedule)
        {
            IAssetType assetType = Program.MetaModel.GetAssetType("TeamRoom");
            IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
            IAttributeDefinition scheduleAttribute = assetType.GetAttributeDefinition("Schedule");
            IAttributeDefinition scopeAttribute = assetType.GetAttributeDefinition("Scope");
            IAttributeDefinition participantAttribute = assetType.GetAttributeDefinition("Participants");
            
            Asset newTeamRoom = Program.Services.New(assetType, null);
            newTeamRoom.SetAttributeValue(nameAttribute, project.Name + " TeamRoom");
            newTeamRoom.SetAttributeValue(scheduleAttribute, schedule.Oid);
            newTeamRoom.SetAttributeValue(scopeAttribute, project.Id);

            foreach (Member member in project.Members)
            {
                newTeamRoom.AddAttributeValue(participantAttribute, member.Id);
            }

            Program.Services.Save(newTeamRoom);
            return newTeamRoom;
        }

		public void AddLinkToWorkitemWithExistingLink()
		{
			const string type = "Link";
			const string url = "http://qqq.com";
			const string title = "Url title";
			var workitemAsset = new Asset(new TestOid(new TestAssetType("Workitem"), 100, null));
			var workitem = new TestWorkitem(workitemAsset, null);
			var link = new Link(url, title);
			var linkAsset = new TestAssetType(type);
			var definitions = new Dictionary<string, IAttributeDefinition> {
                {Entity.NameProperty, new TestAttributeDefinition(linkAsset)},
                {Link.OnMenuProperty, new TestAttributeDefinition(linkAsset)},
                {Link.UrlProperty, new TestAttributeDefinition(linkAsset)},
            };
			var linkOid = new TestOid(new TestAssetType(type, definitions), 10, null);
			var existedLink = new Asset(linkOid);

			Expect.Call(_mockMetaModel.GetAssetType(VersionOneProcessor.LinkType)).Return(linkAsset);
			Expect.Call(_mockQueryBuilder.Query(string.Empty, Filter.Empty())).IgnoreArguments().Return(new AssetList { existedLink });

			_repository.ReplayAll();
			_processor.AddLinkToEntity(workitem, link);
			_repository.VerifyAll();
		}