private ITestManagementTeamProject2 GetTestProject()
        {
            var collectionUri = SpecFlow2TFSConfig.TFS_URL + "/" + SpecFlow2TFSConfig.COLLECTION.Substring(SpecFlow2TFSConfig.COLLECTION.LastIndexOf('\\') + 1);

            TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(collectionUri));

            WorkItemStore workItemStore = new WorkItemStore(tpc);

            Project project = null;

            foreach (Project p in workItemStore.Projects)
            {
                if (p.Name == SpecFlow2TFSConfig.PROJECT)
                {
                    project = p;
                    break;
                }
            }

            if (project == null)
            {
                throw new NullReferenceException("no project found for the name " + SpecFlow2TFSConfig.PROJECT);
            }

            // get test management service
            ITestManagementService2 test_service = (ITestManagementService2)tpc.GetService(typeof(ITestManagementService2));
            ITestManagementTeamProject2 test_project = test_service.GetTeamProject(project);
            return test_project;
        }

        public TFS(string servername, string domain, string username, string password)
        {
            if (string.IsNullOrEmpty(servername))
            {
                throw new ArgumentException("Parameter named:servername cannot be null or empty.");
            }

            if (string.IsNullOrEmpty(username))
            {
                throw new ArgumentException("Parameter named:username cannot be null or empty.");
            }
            if (string.IsNullOrEmpty(password))
            {
                throw new ArgumentException("Parameter named:password cannot be null or empty.");
            }
            //ICredentialsProvider provider = new UICredentialsProvider();
            //tfsServer = TeamFoundationServerFactory.GetServer(serverName, provider);
            //if (!tfsServer.HasAuthenticated)
            //    tfsServer.Authenticate();
            try
            {
                var tfsConfigurationServer = new TfsConfigurationServer(new Uri(servername),
                                                                        new NetworkCredential(username, password, domain));
                store = (WorkItemStore) tfsConfigurationServer.GetService(typeof (WorkItemStore));
            }
            catch (Exception)
            {
                var tfsServer = new TeamFoundationServer(servername, new NetworkCredential(username, password, domain));
                store = (WorkItemStore) tfsServer.GetService(typeof (WorkItemStore));
            }
        }

        /// <inheritdoc/>
        public async Task ConfigureAsync(TfsServiceProviderConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException(nameof(configuration));
            }

            if(string.IsNullOrEmpty(configuration.WorkItemType))
            {
                throw new ArgumentNullException(nameof(configuration.WorkItemType));
            }

            this.logger.Debug("Configure of TfsSoapServiceProvider started...");
            var networkCredential = new NetworkCredential(configuration.Username, configuration.Password);
            var tfsClientCredentials = new TfsClientCredentials(new BasicAuthCredential(networkCredential)) { AllowInteractive = false };
            var tfsProjectCollection = new TfsTeamProjectCollection(this.serviceUri, tfsClientCredentials);
            this.workItemType = configuration.WorkItemType;
            tfsProjectCollection.Authenticate();
            tfsProjectCollection.EnsureAuthenticated();
            this.logger.Debug("Authentication successful for {serviceUri}.", this.serviceUri.AbsoluteUri);

            await Task.Run(
                () =>
                    {
                        this.logger.Debug("Fetching workitem for id {parentWorkItemId}.", configuration.ParentWorkItemId);
                        this.workItemStore = new WorkItemStore(tfsProjectCollection);
                        this.parentWorkItem = this.workItemStore.GetWorkItem(configuration.ParentWorkItemId);
                        this.logger.Debug("Found parent work item '{title}'.", this.parentWorkItem.Title);
                    });
            this.logger.Verbose("Tfs service provider configuration complete.");
        }

        private int GetAtivatedChildUsCount(WorkItemStore workItemStore, WorkItem wi)
        {
            var ids = new List<int>();

            foreach (WorkItemLink item in wi.WorkItemLinks)
            {
                if (item.LinkTypeEnd.Name == "Child")
                {
                    ids.Add(item.TargetId);
                }
            }

            var query = string.Format("SELECT [System.Id],[System.WorkItemType],[System.Title] FROM WorkItems WHERE [System.TeamProject] = 'PSG Dashboard' AND [System.WorkItemType] = 'User Story' AND [System.State] = 'Active' AND [System.Id] In ({0})", GetFormatedIds(ids));
            var workItems = workItemStore.Query(query);

            var count = 0;

            foreach (WorkItem tWi in workItems)
            {
                if (tWi.Type.Name == "User Story")
                {
                    count++;
                }
            }

            return count;
        }

        public TFSWorkItemManager(Config.InstanceConfig config)
        {
            ValidateConfig(config);

            _config = config;

            // Init TFS service objects
            _tfsServer = ConnectToTfsCollection();
            Logger.InfoFormat("Connected to TFS. Getting TFS WorkItemStore");

            _tfsStore = _tfsServer.GetService<WorkItemStore>();

            if (_tfsStore == null)
            {
                Logger.ErrorFormat("Cannot initialize TFS Store");
                throw new Exception("Cannot initialize TFS Store");
            }

            Logger.InfoFormat("Geting TFS Project");
            _tfsProject = _tfsStore.Projects[config.TfsServerConfig.Project];

            Logger.InfoFormat("Initializing WorkItems Cache");
            InitWorkItemsCache();

            _nameResolver = InitNameResolver();
        }

        /// <summary>
        /// Search all work items
        /// </summary>
        /// <param name="store"></param>
        /// <param name="iterationPath"></param>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        public WorkItemTimeCollection(WorkItemStore store, string iterationPath, DateTime startDate, DateTime endDate)
        {
            this.IterationPath = iterationPath;
            this.Data = new ObservableCollection<WorkItemTime>();

            // Sets a list of dates to compute
            _trackDates.Add(startDate.Date);
            for (DateTime date = startDate.Date; date <= endDate.Date; date = date.AddDays(1))
            {
                _trackDates.Add(date.AddHours(23).AddMinutes(59));
            }

            // Gets all work items for each dates
            foreach (DateTime asOfDate in _trackDates)
            {
                // Execute the query
                var wiCollection = store.Query(this.GetQueryString(asOfDate));

                // Iterate through all work items
                foreach (WorkItem wi in wiCollection)
                {
                    WorkItemTime time = new WorkItemTime(asOfDate, wi);
                    this.Data.Add(time);
                }
            }
        }

        public List<Project> GetProjects()
        {
            if (tfs == null)
                throw new Exception("Not logged into server!");

            if ( store==null )
                store = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));

            System.Collections.IEnumerator proColEnum = store.Projects.GetEnumerator();

            projList = new List<Project>();

            while (proColEnum.MoveNext())
            {
                Project proj = null;

                try
                {
                    proj = (Project)proColEnum.Current;
                    projList.Add(proj);
                }
                catch (Exception e)
                {
                    throw e;
                }
            }

            return projList;
        }

 public ReviewItemCollectorStrategy(WorkItemStore store, VersionControlServer versionControlServer, IVisualStudioAdapter visualStudioAdapter, IReviewItemFilter filter)
 {
     this.store = store;
     this.versionControlServer = versionControlServer;
     this.visualStudioAdapter = visualStudioAdapter;
     this.filter = filter;
 }

        public override void AddLinkToWorkItem(int parentId, int childWorkItemId, string comment)
        {
            using (var tfsProjectCollection = GetProjectCollection())
            {
                var workItemStore = new WorkItemStore(tfsProjectCollection);
                var parentWorkItem = workItemStore.GetWorkItem(parentId);
                var linked = false;

                // Update if there's an existing link already
                foreach (var link in parentWorkItem.Links)
                {
                    var relatedLink = link as RelatedLink;
                    if (relatedLink != null && relatedLink.RelatedWorkItemId == childWorkItemId)
                    {
                        relatedLink.Comment = comment;
                        linked = true;
                    }
                }

                if (!linked)
                {
                    parentWorkItem.Links.Add(new RelatedLink(childWorkItemId) { Comment = comment });
                }

                parentWorkItem.Validate();
                parentWorkItem.Save();
            }
        }

        public Validation()
        {
            _tfsServer = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(ConfigurationManager.AppSettings["TfsServer"]));
            _vsoServer = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(ConfigurationManager.AppSettings["VsoServer"]));
            _vsoStore = _vsoServer.GetService<WorkItemStore>();
            _tfsStore = _tfsServer.GetService<WorkItemStore>();

            var actionValue = ConfigurationManager.AppSettings["Action"];
            if (actionValue.Equals("validate", StringComparison.OrdinalIgnoreCase))
            {
                _action = Action.Validate;
            }
            else
            {
                _action = Action.Compare;
            }

            var runDateTime = DateTime.Now.ToString("yyyy-MM-dd-HHmmss");

            var dataFilePath = ConfigurationManager.AppSettings["DataFilePath"];
            var dataDir = string.IsNullOrWhiteSpace(dataFilePath) ? Directory.GetCurrentDirectory() : dataFilePath;
            var dirName = string.Format("{0}\\Log-{1}",dataDir,runDateTime);

            if (!Directory.Exists(dirName))
            {
                Directory.CreateDirectory(dirName);
            }

            _errorLog = new Logging(string.Format("{0}\\Error.txt", dirName));
            _statusLog = new Logging(string.Format("{0}\\Status.txt", dirName));
            _fullLog = new Logging(string.Format("{0}\\FullLog.txt", dirName));

            _taskList = new List<Task>();

            if (!_action.Equals(Action.Compare))
            {
                return;
            }

            _valFieldErrorLog = new Logging(string.Format("{0}\\FieldError.txt", dirName));
            _valTagErrorLog = new Logging(string.Format("{0}\\TagError.txt", dirName));
            _valPostMigrationUpdateLog = new Logging(string.Format("{0}\\PostMigrationUpdate.txt", dirName));

            _imageLog = new Logging(string.Format("{0}\\ItemsWithImage.txt", dirName));

            _commonFields = new List<string>();
            _itemTypesToValidate = new List<string>();

            var fields = ConfigurationManager.AppSettings["CommonFields"].Split(',');
            foreach (var field in fields)
            {
                _commonFields.Add(field);
            }

            var types = ConfigurationManager.AppSettings["WorkItemTypes"].Split(',');
            foreach (var type in types)
            {
                _itemTypesToValidate.Add(type);
            }
        }

        /// <summary>
        /// Main Execution. UI handled in separate method, as this is a procedural utility.
        /// </summary>
        /// <param name="args">Not used</param>
        private static void Main(string[] args)
        {
            string serverUrl, destProjectName, plansJSONPath, logPath, csvPath;
            UIMethod(out serverUrl, out destProjectName, out plansJSONPath, out logPath, out csvPath);

            teamCollection = new TfsTeamProjectCollection(new Uri(serverUrl));
            workItemStore = new WorkItemStore(teamCollection);

            Trace.Listeners.Clear();
            TextWriterTraceListener twtl = new TextWriterTraceListener(logPath);
            twtl.Name = "TextLogger";
            twtl.TraceOutputOptions = TraceOptions.ThreadId | TraceOptions.DateTime;
            ConsoleTraceListener ctl = new ConsoleTraceListener(false);
            ctl.TraceOutputOptions = TraceOptions.DateTime;
            Trace.Listeners.Add(twtl);
            Trace.Listeners.Add(ctl);
            Trace.AutoFlush = true;

            // Get Project
            ITestManagementTeamProject newTeamProject = GetProject(serverUrl, destProjectName);

            // Get Test Plans in Project
            ITestPlanCollection newTestPlans = newTeamProject.TestPlans.Query("Select * From TestPlan");

            // Inform user which Collection/Project we'll be working in
            Trace.WriteLine("Executing alignment tasks in collection \"" + teamCollection.Name 
                + "\",\n\tand Destination Team Project \"" + newTeamProject.TeamProjectName + "\"...");

            // Get and print all test case information
            GetAllTestPlanInfo(newTestPlans, plansJSONPath, logPath, csvPath);
            Console.WriteLine("Alignment completed. Check log file in:\n " + logPath 
                + "\nfor missing areas or other errors. Press enter to close.");
            Console.ReadLine();
        }

        public void Close(string itemId, string comment)
        {
            using (var collection = new TfsTeamProjectCollection(locator.Location))
            {
                var workItemId = int.Parse(itemId);
                var workItemStore = new WorkItemStore(collection, WorkItemStoreFlags.BypassRules);
                var workItem = workItemStore.GetWorkItem(workItemId);
                var workItemDefinition = workItem.Store.Projects[workItem.Project.Name].WorkItemTypes[workItem.Type.Name];

                if (workItemDefinition == null)
                {
                    throw new ArgumentException("Could not obtain work item definition to close work item");
                }

                var definitionDocument = workItemDefinition.Export(false).InnerXml;
                var xDocument = XDocument.Parse(definitionDocument);
                var graphBuilder = new StateGraphBuilder();
                var stateGraph = graphBuilder.BuildStateGraph(xDocument);
                var currentStateNode = stateGraph.FindRelative(workItem.State);

                var graphWalker = new GraphWalker<string>(currentStateNode);
                var shortestWalk = graphWalker.WalkToNode("Closed");

                foreach (var step in shortestWalk.Path)
                {
                    workItem.State = step.Value;
                    workItem.Save();
                }

                workItem.Fields[CoreField.Description].Value = comment + "<br /><br/>" + workItem.Fields[CoreField.Description].Value;
                workItem.Save();
            }
        }

		public ConnectionResult Connect(string host, string user, string password)
		{
			string.Format("Connecting to TFS '{0}'", host).Debug();

			try
			{
				_projectCollectionUri = new Uri(host);
			}
			catch (UriFormatException ex)
			{
				string.Format("Invalid project URL '{0}': {1}", host, ex.Message).Error();
				return ConnectionResult.InvalidUrl;
			}

			//This is used to query TFS for new WorkItems
			try
			{
				if (_projectCollectionNetworkCredentials == null)
				{
					_projectCollectionNetworkCredentials = new NetworkCredential(user, password);

					// if this is hosted TFS then we need to authenticate a little different
					// see this for setup to do on visualstudio.com site:
					// http://blogs.msdn.com/b/buckh/archive/2013/01/07/how-to-connect-to-tf-service-without-a-prompt-for-liveid-credentials.aspx
					if (_projectCollectionUri.Host.ToLowerInvariant().Contains(".visualstudio.com"))
					{

						if (_basicAuthCredential == null)
							_basicAuthCredential = new BasicAuthCredential(_projectCollectionNetworkCredentials);

						if (_tfsClientCredentials == null)
						{
							_tfsClientCredentials = new TfsClientCredentials(_basicAuthCredential);
							_tfsClientCredentials.AllowInteractive = false;
						}

					}
					if (_projectCollection == null)
					{
						_projectCollection = _tfsClientCredentials != null
							? new TfsTeamProjectCollection(_projectCollectionUri, _tfsClientCredentials)
							: new TfsTeamProjectCollection(_projectCollectionUri, _projectCollectionNetworkCredentials);
					}
					_projectCollectionWorkItemStore = new WorkItemStore(_projectCollection);

				}

				if (_projectCollectionWorkItemStore == null)
					_projectCollectionWorkItemStore = new WorkItemStore(_projectCollection);

			}
			catch (Exception e)
			{
				string.Format("Failed to connect: {0}", e.Message).Error(e);
				return ConnectionResult.FailedToConnect;
			}

			return ConnectionResult.Success;
		}

        public ReviewModel()
        {
            teamProjectCollectionProvider = IoC.GetInstance<IVisualStudioAdapter>();
            var tpc = teamProjectCollectionProvider.GetCurrent();

            workItemStore = tpc.GetService<WorkItemStore>();
            versionControlServer = tpc.GetService<VersionControlServer>();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PooledWorkItemStore"/> class.
        /// </summary>
        /// <param name="workItemStoreConnectionPool">The work item store connection pool.</param>
        /// <param name="workItemStore">The work item store.</param>
        internal PooledWorkItemStore(WorkItemStoreConnectionPool workItemStoreConnectionPool, WorkItemStore workItemStore)
        {
            if (workItemStoreConnectionPool == null) throw new ArgumentNullException("workItemStoreConnectionPool");
            if (workItemStore == null) throw new ArgumentNullException("workItemStore");

            _workItemStoreConnectionPoolReference = new WeakReference(workItemStoreConnectionPool);
            _workItemStoreReference = new WeakReference(workItemStore);
        }

 public QueryManager(Project project, TreeView tree, WorkItemStore itemStore)
 {
     ItemStore = itemStore;
     this.project = project;
     Tree = tree;
     project.QueryHierarchy.Refresh();
     BuildQueryHierarchy(project.QueryHierarchy);
 }

 public void Initialize(TfsTeamProjectCollection tfs, string projectName)
 {
     _isInitialized = true;
     _workItemStore = tfs.GetService<WorkItemStore>();
     _project = _workItemStore.Projects
             .Cast<Project>()
             .SingleOrDefault(p => p.Name.Equals(projectName));
 }

 public WorkItemRead(TfsTeamProjectCollection tfs, Project sourceProject)
 {
     this.tfs = tfs;
     projectName = sourceProject.Name;
     store = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
     queryCol = store.Projects[sourceProject.Name].QueryHierarchy;
     workItemTypes = store.Projects[sourceProject.Name].WorkItemTypes;
 }

        public WorkItemCollection GetWorkItems(WorkItemStore wit, string wiql)
        {
            Query qry = new Query(wit, wiql, null, false);

            ICancelableAsyncResult car = qry.BeginQuery();

            WorkItemCollection items = qry.EndQuery(car);
            return items;
        }

        public TaskListForm(WorkItemStore wis, string project, TaskTypes type)
            : this()
        {
            this.wis = wis;
            this.project = project;
            this.type = type;

            this.Text = string.Format("Select {0}", type);
        }