public TeamFoundationServerWorkItemQueryProvider(IWorkItemStore workItemStore, IWiqlQueryBuilder queryBuilder, IWorkItemMapper workItemMapper) { WorkItemStore = workItemStore; WiqlQueryBuilder = queryBuilder; WorkItemMapper = workItemMapper; }
public RelativesAwareTeamFoundationServerWorkItemQueryProvider( IWorkItemStore workItemStore, IWiqlQueryBuilder queryBuilder, IWorkItemMapper workItemMapper, IFieldMapper fieldMapper) : base(workItemStore, queryBuilder, workItemMapper) { _fieldMapper = fieldMapper; }
public override void Given() { var workItems = new List <IWorkItem> { new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object> { { "ID", 1 }, { "IntField", 2 } }), new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object> { { "ID", 2 }, { "IntField", 4 } }) , new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object> { { "ID", 3 }, { "IntField", 3 } }) , new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object> { { "ID", 4 }, { "IntField", 4 } }) , new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object> { { "ID", 5 }, { "IntField", 5 } }) }; var links = new[] { new MockWorkItemLinkInfo(0, 3), new MockWorkItemLinkInfo(3, 1), new MockWorkItemLinkInfo(3, 2), new MockWorkItemLinkInfo(0, 4), new MockWorkItemLinkInfo(0, 5) }; WorkItemStore = new MockWorkItemStore(workItems, links); FieldMapper = new CachingFieldMapper(new FieldMapper()); var propertyInspector = new PropertyInspector(PropertyReflector); var mapperStrategies = new IWorkItemMapperStrategy[] { new AttributeMapperStrategy(propertyInspector, new TypeParser()), new WorkItemLinksMapperStrategy(propertyInspector, WorkItemStore) }; Builder = new WiqlQueryBuilder(new WiqlTranslator(FieldMapper), new PartialEvaluator(), new QueryRewriter()); Mapper = new WorkItemMapper(mapperStrategies); }
public virtual void Map( Type targetWorkItemType, IDictionary <IWorkItem, IIdentifiable <int?> > workItemMappings, IWorkItemMapper workItemMapper) { foreach (var workItemMapping in workItemMappings) { Map(targetWorkItemType, workItemMapping.Key, workItemMapping.Value, workItemMapper); } }
protected virtual void Map( Type targetWorkItemType, IWorkItem sourceWorkItem, IIdentifiable targetWorkItem, IWorkItemMapper workItemMapper) { Map( targetWorkItemType, new[] { new KeyValuePair <IWorkItem, IIdentifiable>(sourceWorkItem, targetWorkItem) }, workItemMapper); }
protected virtual void Map( Type targetWorkItemType, IWorkItem sourceWorkItem, IIdentifiable <int?> targetWorkItem, IWorkItemMapper workItemMapper) { Map(targetWorkItemType, new Dictionary <IWorkItem, IIdentifiable <int?> >(Comparer.WorkItem) { { sourceWorkItem, targetWorkItem } }, workItemMapper); }
public override void Given() { var propertyInspector = new PropertyInspector(new PropertyReflector()); var mappingStrategies = new IWorkItemMapperStrategy[] { new AttributeMapperStrategy(propertyInspector), new WorkItemLinksMapperStrategy(propertyInspector, WorkItemStore) }; WorkItemMapper = new WorkItemMapper(mappingStrategies); }
public override void Map <T>(IDictionary <IWorkItem, T> workItemMappings, IWorkItemMapper workItemMapper) { var targetWorkItemType = typeof(T); foreach (var workItemMapping in workItemMappings) { var sourceWorkItem = workItemMapping.Key; var targetWorkItem = workItemMapping.Value; MapImpl(targetWorkItemType, sourceWorkItem, targetWorkItem); } }
protected virtual void Map <T>(IWorkItem sourceWorkItem, T targetWorkItem, IWorkItemMapper workItemMapper) where T : IIdentifiable <int?>, new() { Map(typeof(T), sourceWorkItem, targetWorkItem, workItemMapper); }
public virtual void Map <T>(IDictionary <IWorkItem, T> workItemMappings, IWorkItemMapper workItemMapper) where T : IIdentifiable <int?>, new() { Map(typeof(T), workItemMappings.ToDictionary(k => k.Key, e => (IIdentifiable <int?>)e.Value, Comparer.WorkItem), workItemMapper); }
public MapperTeamFoundationServerWorkItemQueryProvider(IWorkItemStore workItemStore, IWiqlQueryBuilder queryBuilder, IWorkItemMapper workItemMapper) : base(workItemStore, queryBuilder) { WorkItemMapper = workItemMapper; }
protected virtual void Map <T>(IWorkItem sourceWorkItem, T targetWorkItem, IWorkItemMapper workItemMapper) { Map(typeof(T), sourceWorkItem, (IIdentifiable)targetWorkItem, workItemMapper); }
public override void Map(Type targetWorkItemType, IEnumerable <KeyValuePair <IWorkItem, IIdentifiable> > workItemMappings, IWorkItemMapper workItemMapper) { var accessor = TypeAccessor.Create(targetWorkItemType, true); foreach (var workItemMapping in workItemMappings) { var sourceWorkItem = workItemMapping.Key; var targetWorkItem = workItemMapping.Value; MapImpl(targetWorkItemType, sourceWorkItem, accessor, targetWorkItem); } }
public override void Map( Type targetWorkItemType, IEnumerable <KeyValuePair <IWorkItem, IIdentifiable> > workItemMappings, IWorkItemMapper workItemMapper) { var linksLookup = BuildLinksRelationships(targetWorkItemType, workItemMappings); // REVIEW: We don't have any cycle detection, this avoids causing stack overflows in those cases workItemMapper = new WorkItemMapper(workItemMapper.MapperStrategies.Except(new[] { this })); // If there were no items added to the lookup, don't bother querying VSO if (!linksLookup.Any()) { return; } // Load all the items var workItems = Store.Query(linksLookup.SelectMany(p => p.Value).Distinct()) .ToDictionary(k => k.Id, e => e); var idToMapTargetLookup = workItemMappings.ToDictionary(k => k.Key.Id, e => e); var accessor = TypeAccessor.Create(targetWorkItemType, true); // REVIEW: The recursion of links can cause mapping multiple times on the same values // For example, a common ancestor var previouslyMapped = new Dictionary <Tuple <int, RuntimeTypeHandle>, IIdentifiable>(); // Enumerate through items requiring a VSO lookup and map the objects // There are n-passes to map, where n=number of link types foreach (var item in linksLookup) { var sourceWorkItem = idToMapTargetLookup[item.Key.Item1].Key; var targetWorkItem = idToMapTargetLookup[item.Key.Item1].Value; #if DEBUG && TRACE Trace.TraceInformation("{0}: Mapping {1} on {2}", GetType().Name, item.Key.Item2, sourceWorkItem.Id); #endif foreach (var property in PropertiesOnWorkItemCache( _inspector, sourceWorkItem, targetWorkItemType, typeof(WorkItemLinkAttribute))) { var def = PropertyInfoLinkTypeCache(_inspector, property); if (def != null) { var propertyType = def.WorkItemType; var linkType = def.LinkName; var key = new Tuple <int, string>(sourceWorkItem.Id, linkType); List <int> linkIds; if (!linksLookup.TryGetValue(key, out linkIds)) { // Could not find any IDs for the given ID/LinkType continue; } var wi = linkIds // Only get the new items that need to be mapped .Where(p => !previouslyMapped.ContainsKey(new Tuple <int, RuntimeTypeHandle>(p, propertyType.TypeHandle))) .Select( s => { IWorkItem val; workItems.TryGetValue(s, out val); return(val); }).Where(p => p != null) .ToList(); var createdItems = workItemMapper.Create(propertyType, wi).ToList(); // Add the newly created items to the cache // This allows for lazy creation of common parents foreach (var createdItem in createdItems) { var key2 = new Tuple <int, RuntimeTypeHandle>(createdItem.Id, propertyType.TypeHandle); previouslyMapped[key2] = createdItem; } var existing = linkIds // Only get the new items that need to be mapped .Where( p => previouslyMapped.ContainsKey( new Tuple <int, RuntimeTypeHandle>(p, propertyType.TypeHandle))) .Select(s => previouslyMapped[new Tuple <int, RuntimeTypeHandle>(s, propertyType.TypeHandle)]); var allItems = createdItems.Union(existing).ToList(); // REVIEW: These steps are required as the type defined for the link may be different than targetWorkItemType // ReSharper disable SuggestVarOrType_SimpleTypes IList results = (IList)typeof(List <>) // ReSharper restore SuggestVarOrType_SimpleTypes .MakeGenericType(propertyType) .GetConstructor(new[] { typeof(int) }) .Invoke(new object[] { allItems.Count }); foreach (var link in allItems) { results.Add(link); } accessor[targetWorkItem, property.Name] = results; } } } }
public override void Map(Type targeWorkItemType, IEnumerable <KeyValuePair <IWorkItem, IIdentifiable> > workItemMappings, IWorkItemMapper workItemMapper) { var workingSet = workItemMappings.ToDictionary(kvp => kvp.Key, kvp => kvp.Value, new WorkItemKeyComparer()); if (!workingSet.Any()) { return; } var validIdentityProperties = GetWorkItemIdentityFieldNameToIdentityPropertyMap(targeWorkItemType, _inspector); if (!validIdentityProperties.Any()) { return; } var accessor = TypeAccessor.Create(targeWorkItemType, true); var validIdentityFieldsWithWorkItems = GetWorkItemsWithIdentityFieldValues(workingSet.Keys.ToList(), validIdentityProperties.Keys.ToList()); var identitySearchTerms = GetIdentitySearchTerms(validIdentityFieldsWithWorkItems).ToList(); var identitySearchResults = GetIdentityMap(_identityManagementService, identitySearchTerms); foreach (var workItem in validIdentityFieldsWithWorkItems) { var targetObject = workingSet[workItem.WorkItem]; foreach (var sourceField in workItem.ValidFields) { var targetProperty = validIdentityProperties[sourceField.Name]; var mappedValue = identitySearchResults[sourceField.Value]; if (!string.IsNullOrEmpty(mappedValue)) { accessor[targetObject, targetProperty.Name] = mappedValue; } } } }
public override void Map(Type targetWorkItemType, IDictionary <IWorkItem, IIdentifiable <int?> > workItemMappings, IWorkItemMapper workItemMapper) { foreach (var workItemMapping in workItemMappings) { var sourceWorkItem = workItemMapping.Key; var targetWorkItem = workItemMapping.Value; MapImpl(targetWorkItemType, sourceWorkItem, targetWorkItem); } }
public override void Map(Type targeWorkItemType, IEnumerable <KeyValuePair <IWorkItem, IIdentifiable> > workItemMappings, IWorkItemMapper workItemMapper) { var workingSet = workItemMappings.ToList(); var parentIdField = targeWorkItemType.GetProperty("ParentId"); if (!workingSet.Any() || parentIdField == null) { return; } var workItems = workingSet.Select(wi => wi.Key).ToList(); var ids = workItems.Select(wi => wi.Id); var asOf = workItems.Max(wi => wi.ChangedDate); var childToParentLinks = _workItemStore.QueryLinks(string.Format(ParentLinkQueryFormat, string.Join(",", ids), asOf)) .Where(link => link.LinkTypeId != SelfReferenceLinkId); var childToParentDictionary = childToParentLinks.ToDictionary(link => link.SourceId, link => link.TargetId); foreach (var workItemMapping in workingSet) { var childId = workItemMapping.Key.Id; if (childToParentDictionary.ContainsKey(childId)) { parentIdField.SetValue(workItemMapping.Value, childToParentDictionary[childId]); } } }
public virtual void Map(Type targetWorkItemType, IEnumerable <KeyValuePair <IWorkItem, IIdentifiable> > workItemMappings, IWorkItemMapper workItemMapper) { foreach (var workItemMapping in workItemMappings) { Map(targetWorkItemType, workItemMapping.Key, workItemMapping.Value, workItemMapper); } }
/// <summary> /// Maps the specified target work item type. /// </summary> /// <param name="targetWorkItemType">Type of the targe work item.</param> /// <param name="workItemMappings">The work item mappings.</param> /// <param name="workItemMapper">The work item mapper.</param> public override void Map(Type targetWorkItemType, IDictionary <IWorkItem, IIdentifiable <int?> > workItemMappings, IWorkItemMapper workItemMapper) { if (!workItemMappings.Any()) { return; } var validIdentityProperties = GetWorkItemIdentityFieldNameToIdentityPropertyMap(targetWorkItemType, _inspector); if (!validIdentityProperties.Any()) { return; } var validIdentityFieldsWithWorkItems = GetWorkItemsWithIdentityFieldValues(workItemMappings.Keys, validIdentityProperties.Keys); var identitySearchTerms = GetIdentitySearchTerms(validIdentityFieldsWithWorkItems); var identitySearchResults = MapIdentityValues(identitySearchTerms); foreach (var workItem in validIdentityFieldsWithWorkItems) { var targetObject = workItemMappings[workItem.WorkItem]; foreach (var sourceField in workItem.ValidFields) { var targetProperties = validIdentityProperties[sourceField.Name]; var mappedValue = identitySearchResults[sourceField.Value]; foreach (var targetProperty in targetProperties) { AssignFieldValue(targetWorkItemType, workItem.WorkItem, targetObject, targetProperty, sourceField.Name, true, sourceField.Value, mappedValue); } } } }
public virtual void Map <T>( IEnumerable <KeyValuePair <IWorkItem, T> > workItemMappings, IWorkItemMapper workItemMapper) where T : IIdentifiable, new() { Map(typeof(T), workItemMappings.Select(s => new KeyValuePair <IWorkItem, IIdentifiable>(s.Key, s.Value)), workItemMapper); }