internal override void InternalExecute()
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            //////////////////////////////////////////////////
            WorkItemStoreContext sourceStore = new WorkItemStoreContext(me.Source, WorkItemStoreFlags.None);
            TfsQueryContext      tfsqc       = new TfsQueryContext(sourceStore);

            tfsqc.AddParameter("TeamProject", me.Source.Name);
            tfsqc.Query = @"SELECT [System.Id] FROM WorkItems WHERE  [System.TeamProject] = @TeamProject ";// AND [System.Id] = 188708 ";
            WorkItemCollection sourceWIS = tfsqc.Execute();

            Trace.WriteLine(string.Format("Migrate {0} work items?", sourceWIS.Count));
            //////////////////////////////////////////////////

            int current = sourceWIS.Count;

            foreach (WorkItem sourceWI in sourceWIS)
            {
                System.Threading.Thread.Sleep(10);
            }
            stopwatch.Stop();
            Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
        }
Esempio n. 2
0
        internal override void InternalExecute()
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            //////////////////////////////////////////////////
            WorkItemStoreContext targetStore = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules);
            TfsQueryContext      tfsqc       = new TfsQueryContext(targetStore);

            tfsqc.AddParameter("TeamProject", me.Target.Name);
            tfsqc.Query = string.Format(@"SELECT [System.Id] FROM WorkItems WHERE  [System.TeamProject] = @TeamProject  AND [System.AreaPath] UNDER '{0}\_DeleteMe'", me.Target.Name);
            WorkItemCollection workitems = tfsqc.Execute();

            Trace.WriteLine(string.Format("Update {0} work items?", workitems.Count));
            //////////////////////////////////////////////////
            int current = workitems.Count;
            //int count = 0;
            //long elapsedms = 0;
            var tobegone = (from WorkItem wi in workitems where wi.AreaPath.Contains("_DeleteMe")  select wi.Id).ToList();

            foreach (int begone in tobegone)
            {
                targetStore.Store.DestroyWorkItems(new List <int>()
                {
                    begone
                });
                Trace.WriteLine(string.Format("Deleted {0}", begone));
            }


            //////////////////////////////////////////////////
            stopwatch.Stop();
            Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
        }
Esempio n. 3
0
        internal override void InternalExecute()
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            //////////////////////////////////////////////////



            WorkItemStoreContext sourceStore = new WorkItemStoreContext(me.Source, WorkItemStoreFlags.None);
            TfsQueryContext      tfsqc       = new TfsQueryContext(sourceStore);

            tfsqc.AddParameter("TeamProject", me.Source.Name);
            tfsqc.Query = string.Format(@"SELECT [System.Id], [System.Tags] FROM WorkItems WHERE [System.TeamProject] = @TeamProject {0} ORDER BY [System.ChangedDate] desc", _config.QueryBit);
            WorkItemCollection sourceWIS = tfsqc.Execute();

            WebClient webClient = new WebClient();

            webClient.Credentials = CredentialCache.DefaultNetworkCredentials;
            int current = sourceWIS.Count;

            foreach (WorkItem wi in sourceWIS)
            {
                Trace.Write(string.Format("Attachement Export: {0} of {1} - {2}", current, sourceWIS.Count, wi.Id));
                foreach (Attachment wia in wi.Attachments)
                {
                    string reflectedId = sourceStore.CreateReflectedWorkItemId(wi);
                    string fname       = string.Format("{0}#{1}", reflectedId.Replace("/", "-").Replace(":", "+"), wia.Name);
                    Trace.Write("-");
                    Trace.Write(fname);
                    string fpath = Path.Combine(exportPath, fname);
                    if (!File.Exists(fpath))
                    {
                        Trace.Write("...downloading");
                        try
                        {
                            webClient.DownloadFile(wia.Uri, fpath);
                            Trace.Write("...done");
                        }
                        catch (Exception ex)
                        {
                            Telemetry.Current.TrackException(ex);
                            Trace.Write("...failed");
                        }
                    }
                    else
                    {
                        Trace.Write("...skipping");
                    }
                    Trace.WriteLine("...done");
                }
                current--;
            }
            //////////////////////////////////////////////////
            stopwatch.Stop();
            Console.WriteLine(@"EXPORT DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
        }
        public WorkItem FindReflectedWorkItemByTitle(string title)
        {
            TfsQueryContext query = new TfsQueryContext(this);

            query.Query = @"SELECT [System.Id] FROM WorkItems  WHERE [System.TeamProject]=@TeamProject AND [System.Title] = @TitleToFind";
            query.AddParameter("TitleToFind", title);
            query.AddParameter("TeamProject", this.targetTfs.Name);
            return(FindWorkItemByQuery(query));
        }
        public WorkItem FindReflectedWorkItemByMigrationRef(string refId)
        {
            TfsQueryContext query = new TfsQueryContext(this);

            query.Query = @"SELECT [System.Id] FROM WorkItems  WHERE [System.TeamProject]=@TeamProject AND [System.Description] Contains @KeyToFind";
            query.AddParameter("KeyToFind", string.Format("##REF##{0}##", refId));
            query.AddParameter("TeamProject", this.targetTfs.Name);
            return(FindWorkItemByQuery(query));
        }
        public WorkItem FindReflectedWorkItemByReflectedWorkItemId(string refId, string reflectedWotkItemIdField)
        {
            TfsQueryContext query = new TfsQueryContext(this);

            query.Query = string.Format(@"SELECT [System.Id] FROM WorkItems  WHERE [System.TeamProject]=@TeamProject AND [{0}] = @idToFind", reflectedWotkItemIdField);
            query.AddParameter("idToFind", refId.ToString());
            query.AddParameter("TeamProject", this.targetTfs.Name);
            return(FindWorkItemByQuery(query));
        }
        public WorkItem FindWorkItemByQuery(TfsQueryContext query)
        {
            WorkItemCollection newFound;

            newFound = query.Execute();
            if (newFound.Count == 0)
            {
                return(null);
            }
            return(newFound[0]);
        }
        internal override void InternalExecute()
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            //////////////////////////////////////////////////
            WorkItemStoreContext targetStore = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules);

            TfsQueryContext tfsqc = new TfsQueryContext(targetStore);

            tfsqc.AddParameter("TeamProject", me.Target.Name);
            tfsqc.AddParameter("AreaPath", config.AreaIterationPath);
            tfsqc.Query = @"SELECT [System.Id], [System.Tags] FROM WorkItems WHERE  [System.TeamProject] = @TeamProject and [System.AreaPath] under @AreaPath";
            WorkItemCollection workitems = tfsqc.Execute();

            Trace.WriteLine(string.Format("Update {0} work items?", workitems.Count));
            //////////////////////////////////////////////////
            int  current   = workitems.Count;
            int  count     = 0;
            long elapsedms = 0;

            foreach (WorkItem workitem in workitems)
            {
                Stopwatch witstopwatch = new Stopwatch();
                witstopwatch.Start();

                Trace.WriteLine(string.Format("{0} - Updating: {1}-{2}", current, workitem.Id, workitem.Type.Name));
                string        areaPath   = workitem.AreaPath;
                List <string> bits       = new List <string>(areaPath.Split(char.Parse(@"\"))).Skip(4).ToList();
                List <string> tags       = workitem.Tags.Split(char.Parse(@";")).ToList();
                List <string> newTags    = tags.Union(bits).ToList();
                string        newTagList = string.Join(";", newTags.ToArray());
                if (newTagList != workitem.Tags)
                {
                    workitem.Open();
                    workitem.Tags = newTagList;
                    workitem.Save();
                }

                witstopwatch.Stop();
                elapsedms = elapsedms + witstopwatch.ElapsedMilliseconds;
                current--;
                count++;
                TimeSpan average   = new TimeSpan(0, 0, 0, 0, (int)(elapsedms / count));
                TimeSpan remaining = new TimeSpan(0, 0, 0, 0, (int)(average.TotalMilliseconds * current));
                Trace.WriteLine(string.Format("Average time of {0} per work item and {1} estimated to completion", string.Format(@"{0:s\:fff} seconds", average), string.Format(@"{0:%h} hours {0:%m} minutes {0:s\:fff} seconds", remaining)));
            }
            //////////////////////////////////////////////////
            stopwatch.Stop();
            Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
        }
Esempio n. 9
0
        internal override void InternalExecute()
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            //////////////////////////////////////////////////
            WorkItemStoreContext targetStore = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules);

            TfsQueryContext tfsqc = new TfsQueryContext(targetStore);

            tfsqc.AddParameter("TeamProject", me.Target.Name);
            tfsqc.Query = string.Format(@"SELECT [System.Id], [System.Tags] FROM WorkItems WHERE [System.TeamProject] = @TeamProject {0} ORDER BY [System.ChangedDate] desc", _config.QueryBit);
            WorkItemCollection workitems = tfsqc.Execute();

            Trace.WriteLine(string.Format("Update {0} work items?", workitems.Count));
            //////////////////////////////////////////////////
            int  current   = workitems.Count;
            int  count     = 0;
            long elapsedms = 0;

            foreach (WorkItem workitem in workitems)
            {
                Stopwatch witstopwatch = new Stopwatch();
                witstopwatch.Start();
                workitem.Open();
                Trace.WriteLine(string.Format("Processing work item {0} - Type:{1} - ChangedDate:{2} - CreatedDate:{3}", workitem.Id, workitem.Type.Name, workitem.ChangedDate.ToShortDateString(), workitem.CreatedDate.ToShortDateString()));
                _me.ApplyFieldMappings(workitem);

                if (workitem.IsDirty)
                {
                    if (!_config.WhatIf)
                    {
                        try
                        {
                            workitem.Save();
                        }
                        catch (Exception)
                        {
                            System.Threading.Thread.Sleep(5000);
                            workitem.Save();
                        }
                    }
                    else
                    {
                        Trace.WriteLine("No save done: (What IF: enabled)");
                    }
                }
                else
                {
                    Trace.WriteLine("No save done: (IsDirty: false)");
                }



                witstopwatch.Stop();
                elapsedms = elapsedms + witstopwatch.ElapsedMilliseconds;
                current--;
                count++;
                TimeSpan average   = new TimeSpan(0, 0, 0, 0, (int)(elapsedms / count));
                TimeSpan remaining = new TimeSpan(0, 0, 0, 0, (int)(average.TotalMilliseconds * current));
                Trace.WriteLine(string.Format("Average time of {0} per work item and {1} estimated to completion", string.Format(@"{0:s\:fff} seconds", average), string.Format(@"{0:%h} hours {0:%m} minutes {0:s\:fff} seconds", remaining)));
            }
            //////////////////////////////////////////////////
            stopwatch.Stop();
            Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
        }
Esempio n. 10
0
        internal override void InternalExecute()
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            //////////////////////////////////////////////////
            WorkItemStoreContext sourceStore = new WorkItemStoreContext(me.Source, WorkItemStoreFlags.BypassRules);
            TfsQueryContext      tfsqc       = new TfsQueryContext(sourceStore);

            tfsqc.AddParameter("TeamProject", me.Source.Name);
            tfsqc.Query = string.Format(@"SELECT [System.Id], [System.Tags] FROM WorkItems WHERE [System.TeamProject] = @TeamProject {0} ORDER BY [System.ChangedDate] desc", _config.QueryBit);
            WorkItemCollection sourceWIS = tfsqc.Execute();

            Trace.WriteLine(string.Format("Migrate {0} work items?", sourceWIS.Count), this.Name);
            //////////////////////////////////////////////////
            WorkItemStoreContext targetStore = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules);
            Project destProject = targetStore.GetProject();

            Trace.WriteLine(string.Format("Found target project as {0}", destProject.Name), this.Name);

            int  current   = sourceWIS.Count;
            int  count     = 0;
            long elapsedms = 0;

            foreach (WorkItem sourceWI in sourceWIS)
            {
                Stopwatch witstopwatch = new Stopwatch();
                witstopwatch.Start();
                WorkItem targetFound;
                targetFound = targetStore.FindReflectedWorkItem(sourceWI, me.ReflectedWorkItemIdFieldName, false);
                Trace.WriteLine(string.Format("{0} - Migrating: {1}-{2}", current, sourceWI.Id, sourceWI.Type.Name), this.Name);
                if (targetFound == null)
                {
                    WorkItem newwit = null;
                    // Deside on WIT
                    if (me.WorkItemTypeDefinitions.ContainsKey(sourceWI.Type.Name))
                    {
                        newwit = CreateAndPopulateWorkItem(_config, sourceWI, destProject, me.WorkItemTypeDefinitions[sourceWI.Type.Name].Map(sourceWI));
                        if (newwit.Fields.Contains(me.ReflectedWorkItemIdFieldName))
                        {
                            newwit.Fields[me.ReflectedWorkItemIdFieldName].Value = sourceStore.CreateReflectedWorkItemId(sourceWI);
                        }
                        me.ApplyFieldMappings(sourceWI, newwit);
                        ArrayList fails = newwit.Validate();
                        foreach (Field f in fails)
                        {
                            Trace.WriteLine(string.Format("{0} - Invalid: {1}-{2}-{3}", current, sourceWI.Id, sourceWI.Type.Name, f.ReferenceName), this.Name);
                        }
                    }
                    else
                    {
                        Trace.WriteLine("...not supported", this.Name);
                    }

                    if (newwit != null)
                    {
                        try
                        {
                            if (_config.UpdateCreatedDate)
                            {
                                newwit.Fields["System.CreatedDate"].Value = sourceWI.Fields["System.CreatedDate"].Value;
                            }
                            if (_config.UpdateCreatedBy)
                            {
                                newwit.Fields["System.CreatedBy"].Value = sourceWI.Fields["System.CreatedBy"].Value;
                            }
                            newwit.Save();
                            newwit.Close();
                            Trace.WriteLine(string.Format("...Saved as {0}", newwit.Id), this.Name);
                            if (sourceWI.Fields.Contains(me.ReflectedWorkItemIdFieldName) && _config.UpdateSoureReflectedId)
                            {
                                sourceWI.Fields[me.ReflectedWorkItemIdFieldName].Value = targetStore.CreateReflectedWorkItemId(newwit);
                            }
                            sourceWI.Save();
                            Trace.WriteLine(string.Format("...and Source Updated {0}", sourceWI.Id), this.Name);
                        }
                        catch (Exception ex)
                        {
                            Trace.WriteLine("...FAILED to Save", this.Name);
                            foreach (Field f in newwit.Fields)
                            {
                                Trace.WriteLine(string.Format("{0} | {1}", f.ReferenceName, f.Value), this.Name);
                            }
                            Trace.WriteLine(ex.ToString(), this.Name);
                        }
                    }
                }
                else
                {
                    Console.WriteLine("...Exists");

                    //  sourceWI.Open();
                    //  sourceWI.SyncToLatest();
                    //  sourceWI.Fields["TfsMigrationTool.ReflectedWorkItemId"].Value = destWIFound[0].Id;
                    //sourceWI.Save();
                }
                sourceWI.Close();
                witstopwatch.Stop();
                elapsedms = elapsedms + witstopwatch.ElapsedMilliseconds;
                current--;
                count++;
                TimeSpan average   = new TimeSpan(0, 0, 0, 0, (int)(elapsedms / count));
                TimeSpan remaining = new TimeSpan(0, 0, 0, 0, (int)(average.TotalMilliseconds * current));
                Trace.WriteLine(string.Format("Average time of {0} per work item and {1} estimated to completion", string.Format(@"{0:s\:fff} seconds", average), string.Format(@"{0:%h} hours {0:%m} minutes {0:s\:fff} seconds", remaining)), this.Name);
                Trace.Flush();
            }
            //////////////////////////////////////////////////
            stopwatch.Stop();
            Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
        }
        internal override void InternalExecute()
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            //////////////////////////////////////////////////
            WorkItemStoreContext targetStore = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules);

            TfsQueryContext tfsqc = new TfsQueryContext(targetStore);

            TfsTeamService            teamService = me.Target.Collection.GetService <TfsTeamService>();
            QueryHierarchy            qh          = targetStore.Store.Projects[me.Target.Name].QueryHierarchy;
            List <TeamFoundationTeam> teamList    = teamService.QueryTeams(me.Target.Name).ToList();

            Trace.WriteLine(string.Format("Found {0} teams?", teamList.Count));
            //////////////////////////////////////////////////
            int  current   = teamList.Count;
            int  count     = 0;
            long elapsedms = 0;

            foreach (TeamFoundationTeam team in teamList)
            {
                Stopwatch witstopwatch = new Stopwatch();
                witstopwatch.Start();

                Trace.Write(string.Format("Processing team {0}", team.Name));
                Regex  r = new Regex(@"^Project - ([a-zA-Z ]*)");
                string path;
                if (r.IsMatch(team.Name))
                {
                    Trace.Write(string.Format(" is a Project"));
                    path = string.Format(@"Projects\{0}", r.Match(team.Name).Groups[1].Value.Replace(" ", "-"));
                }
                else
                {
                    Trace.Write(string.Format(" is a Team"));
                    path = string.Format(@"Teams\{0}", team.Name.Replace(" ", "-"));
                }
                Trace.Write(string.Format(" and new path is {0}", path));
                //me.AddFieldMap("*", new RegexFieldMap("KM.Simulation.Team", "System.AreaPath", @"^Project - ([a-zA-Z ]*)", @"Nemo\Projects\$1"));

                string[] bits = path.Split(char.Parse(@"\"));

                CreateFolderHyerarchy(bits, qh["Shared Queries"]);

                //_me.ApplyFieldMappings(workitem);
                qh.Save();


                witstopwatch.Stop();
                elapsedms = elapsedms + witstopwatch.ElapsedMilliseconds;
                current--;
                count++;
                TimeSpan average   = new TimeSpan(0, 0, 0, 0, (int)(elapsedms / count));
                TimeSpan remaining = new TimeSpan(0, 0, 0, 0, (int)(average.TotalMilliseconds * current));
                Trace.WriteLine("");
                //Trace.WriteLine(string.Format("Average time of {0} per work item and {1} estimated to completion", string.Format(@"{0:s\:fff} seconds", average), string.Format(@"{0:%h} hours {0:%m} minutes {0:s\:fff} seconds", remaining)));
            }
            //////////////////////////////////////////////////
            stopwatch.Stop();
            Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
        }
Esempio n. 12
0
        internal override void InternalExecute()
        {
            try
            {
                Stopwatch stopwatch = new Stopwatch();
                stopwatch.Start();
                //////////////////////////////////////////////////
                var sourceGitRepoService = me.Source.Collection.GetService <GitRepositoryService>();
                var sourceGitRepos       = sourceGitRepoService.QueryRepositories(me.Source.Name);
                //////////////////////////////////////////////////
                var targetGitRepoService = me.Target.Collection.GetService <GitRepositoryService>();
                var targetGitRepos       = targetGitRepoService.QueryRepositories(me.Target.Name);

                WorkItemStoreContext targetStore = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules);
                TfsQueryContext      tfsqc       = new TfsQueryContext(targetStore);
                tfsqc.AddParameter("TeamProject", me.Target.Name);
                tfsqc.Query = string.Format(@"SELECT [System.Id] FROM WorkItems WHERE  [System.TeamProject] = @TeamProject AND  [System.ExternalLinkCount] > 0 ", me.Target.Name);
                WorkItemCollection workitems = tfsqc.Execute();
                Trace.WriteLine(string.Format("Update {0} work items?", workitems.Count));
                //////////////////////////////////////////////////
                int  current   = workitems.Count;
                int  count     = 0;
                long elapsedms = 0;
                int  noteFound = 0;
                foreach (WorkItem workitem in workitems)
                {
                    Stopwatch witstopwatch = new Stopwatch();
                    witstopwatch.Start();
                    workitem.Open();
                    List <ExternalLink> newEL    = new List <ExternalLink>();
                    List <ExternalLink> removeEL = new List <ExternalLink>();
                    Trace.WriteLine(string.Format("WI: {0}?", workitem.Id));

                    foreach (Link l in workitem.Links)
                    {
                        if (l is ExternalLink && l.ArtifactLinkType.Name == "Fixed in Commit")
                        {
                            ExternalLink el = (ExternalLink)l;
                            //vstfs:///Git/Commit/25f94570-e3e7-4b79-ad19-4b434787fd5a%2f50477259-3058-4dff-ba4c-e8c179ec5327%2f41dd2754058348d72a6417c0615c2543b9b55535
                            string   guidbits = el.LinkedArtifactUri.Substring(el.LinkedArtifactUri.LastIndexOf('/') + 1);
                            string[] bits     = Regex.Split(guidbits, "%2f", RegexOptions.IgnoreCase);
                            if (bits.Count() != 3)
                            {
                                throw new Exception("Regex to split bits in url is not working too great");
                            }
                            string oldGitRepoId = bits[1];
                            string oldCommitId  = bits[2];
                            var    oldGitRepo   = (from g in sourceGitRepos where g.Id.ToString() == oldGitRepoId select g).SingleOrDefault();

                            if (oldGitRepo != null && oldGitRepo.ProjectReference.Name != me.Target.Name)
                            {
                                var newGitRepo = (from g in targetGitRepos where g.Name == oldGitRepo.Name && g.ProjectReference.Name != oldGitRepo.ProjectReference.Name select g).SingleOrDefault();

                                if (newGitRepo != null)
                                {
                                    /// we have FOUND
                                    Trace.WriteLine(string.Format("Found {0} to {1}?", oldGitRepo.RemoteUrl, newGitRepo.RemoteUrl));
                                    string link   = string.Format("vstfs:///git/commit/{0}%2f{1}%2f{2}", newGitRepo.ProjectReference.Id.ToString(), newGitRepo.Id.ToString(), oldCommitId);
                                    var    elinks = from Link lq in workitem.Links where lq.ArtifactLinkType.Name == "Fixed in Commit" select(ExternalLink) lq;
                                    var    found  = (from Link lq in elinks where (((ExternalLink)lq).LinkedArtifactUri.ToLower() == link.ToLower()) select lq).SingleOrDefault();
                                    if (found == null)
                                    {
                                        newEL.Add(new ExternalLink(targetStore.Store.RegisteredLinkTypes[ArtifactLinkIds.Commit], link));
                                    }
                                    removeEL.Add(el);
                                }
                                else
                                {
                                    Trace.WriteLine(string.Format("FAIL {0} to ???", oldGitRepo.RemoteUrl));
                                }
                            }
                            else
                            {
                                Trace.WriteLine(string.Format("FAIL {0} to ???", oldGitRepoId));
                                noteFound++;
                            }
                        }
                    }
                    /// add and remove
                    foreach (ExternalLink eln in newEL)
                    {
                        try
                        {
                            Trace.WriteLine(string.Format("Addming ", eln.LinkedArtifactUri));
                            workitem.Links.Add(eln);
                        }
                        catch (Exception)
                        {
                            // eat exception as somtimes TFS thinks this is an attachemnt
                        }
                    }
                    foreach (ExternalLink elr in removeEL)
                    {
                        if (workitem.Links.Contains(elr))
                        {
                            try
                            {
                                Trace.WriteLine(string.Format("Removing ", elr.LinkedArtifactUri));
                                workitem.Links.Remove(elr);
                            }
                            catch (Exception)
                            {
                                // eat exception as somtimes TFS thinks this is an attachemnt
                            }
                        }
                    }
                    if (workitem.IsDirty)
                    {
                        Trace.WriteLine(string.Format("Saving "));
                        workitem.Save();
                    }

                    witstopwatch.Stop();
                    elapsedms = elapsedms + witstopwatch.ElapsedMilliseconds;
                    current--;
                    count++;
                    TimeSpan average   = new TimeSpan(0, 0, 0, 0, (int)(elapsedms / count));
                    TimeSpan remaining = new TimeSpan(0, 0, 0, 0, (int)(average.TotalMilliseconds * current));
                    Trace.WriteLine(string.Format("Average time of {0} per work item and {1} estimated to completion", string.Format(@"{0:s\:fff} seconds", average), string.Format(@"{0:%h} hours {0:%m} minutes {0:s\:fff} seconds", remaining)));
                }
                Trace.WriteLine(string.Format("Did not find old repo for {0} links?", noteFound));
                //////////////////////////////////////////////////
                stopwatch.Stop();
                Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Esempio n. 13
0
        internal override void InternalExecute()
        {
            WorkItemStoreContext sourceStore = new WorkItemStoreContext(me.Source, WorkItemStoreFlags.BypassRules);
            TfsQueryContext      tfsqc       = new TfsQueryContext(sourceStore);

            tfsqc.AddParameter("TeamProject", me.Source.Name);
            tfsqc.Query = string.Format(@"SELECT [System.Id] FROM WorkItems WHERE  [System.TeamProject] = @TeamProject {0} ORDER BY [System.ChangedDate] desc ", config.QueryBit); // AND  [Microsoft.VSTS.Common.ClosedDate] = ''
            WorkItemCollection sourceWIS = tfsqc.Execute();

            //////////////////////////////////////////////////

            Trace.WriteLine(string.Format("Migrate {0} work items links?", sourceWIS.Count), "LinkMigrationContext");
            int current = sourceWIS.Count;
            //////////////////////////////////////////////////
            WorkItemStoreContext targetWitsc = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules);
            Project targetProj = targetWitsc.GetProject();

            //////////////////////////////////////////////////
            foreach (WorkItem wiSourceL in sourceWIS)
            {
                Trace.WriteLine(string.Format("Migrating Links for wiSourceL={0}",
                                              wiSourceL.Id), "LinkMigrationContext");
                WorkItem wiTargetL = targetWitsc.FindReflectedWorkItem(wiSourceL, me.ReflectedWorkItemIdFieldName, true);
                if (wiTargetL == null)
                {
                    //wiSourceL was not migrated, or the migrated work item has been deleted.
                    Trace.WriteLine(string.Format("[SKIP] Unable to migrate links where wiSourceL={0}, wiTargetL=NotFound",
                                                  wiSourceL.Id), "LinkMigrationContext");
                    continue;
                }
                Trace.WriteLine(string.Format("Found Target Left wiSourceL={0}, wiTargetL=NotFound",
                                              wiSourceL.Id), "LinkMigrationContext");
                if (wiTargetL.Links.Count == wiSourceL.Links.Count)
                {
                    Trace.WriteLine(string.Format("[SKIP] SOurce and Target have same number of links  {0} - {1}", wiSourceL.Id, wiSourceL.Type.ToString()), "LinkMigrationContext");
                }
                else
                {
                    try
                    {
                        Trace.Indent();
                        foreach (Link item in wiSourceL.Links)
                        {
                            Trace.WriteLine(string.Format("Migrating link for {0} of type {1}",
                                                          wiSourceL.Id, item.GetType().Name), "LinkMigrationContext");
                            if (IsHyperlink(item))
                            {
                                CreateHyperlink((Hyperlink)item, wiTargetL);
                            }
                            else if (IsRelatedLink(item))
                            {
                                RelatedLink rl = (RelatedLink)item;
                                CreateRelatedLink(wiSourceL, rl, wiTargetL, sourceStore, targetWitsc);
                            }
                            else if (IsExternalLink(item))
                            {
                                ExternalLink rl = (ExternalLink)item;
                                CreateExternalLink((ExternalLink)item, wiTargetL);
                            }
                            else
                            {
                                UnknownLinkTypeException ex = new UnknownLinkTypeException(string.Format("  [UnknownLinkType] Unable to {0}", item.GetType().Name));
                                Telemetry.Current.TrackException(ex);
                                Trace.WriteLine(ex.ToString(), "LinkMigrationContext");
                                throw ex;
                            }
                        }
                    }
                    catch (WorkItemLinkValidationException ex)
                    {
                        wiSourceL.Reset();
                        wiTargetL.Reset();
                        Telemetry.Current.TrackException(ex);
                        Trace.WriteLine(string.Format("  [WorkItemLinkValidationException] Adding link for wiSourceL={0}", wiSourceL.Id), "LinkMigrationContext");
                        Trace.WriteLine(ex.ToString(), "LinkMigrationContext");
                    }
                    catch (Exception ex)
                    {
                        Telemetry.Current.TrackException(ex);
                        Trace.WriteLine(string.Format("  [CREATE-FAIL] Adding Link for wiSourceL={0}", wiSourceL.Id), "LinkMigrationContext");
                        Trace.WriteLine(ex.ToString(), "LinkMigrationContext");
                    }
                }
                current--;
            }
        }
Esempio n. 14
0
        //public WorkItemPostProcessingContext(MigrationEngine me, WorkItemPostProcessingConfig config, IList<string> wiTypes) : this(me, config)
        //{
        //    _workItemTypes = wiTypes;
        //}

        //public WorkItemPostProcessingContext(MigrationEngine me, WorkItemPostProcessingConfig config, IList<int> wiIDs) : this(me, config)
        //{
        //    _workItemIDs = wiIDs;
        //}

        //public WorkItemPostProcessingContext(MigrationEngine me, WorkItemPostProcessingConfig config, string queryBit) : this (me, config)
        //{
        //    _queryBit = queryBit;
        //}

        internal override void InternalExecute()
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            //////////////////////////////////////////////////
            WorkItemStoreContext sourceStore = new WorkItemStoreContext(me.Source, WorkItemStoreFlags.None);
            TfsQueryContext      tfsqc       = new TfsQueryContext(sourceStore);

            tfsqc.AddParameter("TeamProject", me.Source.Name);

            //Builds the constraint part of the query
            string constraints = BuildQueryBitConstraints();

            tfsqc.Query = string.Format(@"SELECT [System.Id] FROM WorkItems WHERE [System.TeamProject] = @TeamProject {0} ORDER BY [System.Id] ", constraints);

            WorkItemCollection sourceWIS = tfsqc.Execute();

            Trace.WriteLine(string.Format("Migrate {0} work items?", sourceWIS.Count));
            //////////////////////////////////////////////////
            WorkItemStoreContext targetStore = new WorkItemStoreContext(me.Target, WorkItemStoreFlags.BypassRules);
            Project destProject = targetStore.GetProject();

            Trace.WriteLine(string.Format("Found target project as {0}", destProject.Name));


            int  current   = sourceWIS.Count;
            int  count     = 0;
            long elapsedms = 0;

            foreach (WorkItem sourceWI in sourceWIS)
            {
                Stopwatch witstopwatch = new Stopwatch();
                witstopwatch.Start();
                WorkItem targetFound;
                targetFound = targetStore.FindReflectedWorkItem(sourceWI, me.ReflectedWorkItemIdFieldName, false);
                Trace.WriteLine(string.Format("{0} - Updating: {1}-{2}", current, sourceWI.Id, sourceWI.Type.Name));
                if (targetFound == null)
                {
                    Trace.WriteLine(string.Format("{0} - WARNING: does not exist {1}-{2}", current, sourceWI.Id, sourceWI.Type.Name));
                }
                else
                {
                    Console.WriteLine("...Exists");
                    targetFound.Open();
                    me.ApplyFieldMappings(sourceWI, targetFound);
                    if (targetFound.IsDirty)
                    {
                        try
                        {
                            targetFound.Save();
                            Trace.WriteLine(string.Format("          Updated"));
                        }
                        catch (ValidationException ve)
                        {
                            Trace.WriteLine(string.Format("          [FAILED] {0}", ve.ToString()));
                        }
                    }
                    else
                    {
                        Trace.WriteLine(string.Format("          No changes"));
                    }
                    sourceWI.Close();
                }
                witstopwatch.Stop();
                elapsedms = elapsedms + witstopwatch.ElapsedMilliseconds;
                current--;
                count++;
                TimeSpan average   = new TimeSpan(0, 0, 0, 0, (int)(elapsedms / count));
                TimeSpan remaining = new TimeSpan(0, 0, 0, 0, (int)(average.TotalMilliseconds * current));
                Trace.WriteLine(string.Format("Average time of {0} per work item and {1} estimated to completion", string.Format(@"{0:s\:fff} seconds", average), string.Format(@"{0:%h} hours {0:%m} minutes {0:s\:fff} seconds", remaining)));
            }
            //////////////////////////////////////////////////
            stopwatch.Stop();
            Console.WriteLine(@"DONE in {0:%h} hours {0:%m} minutes {0:s\:fff} seconds", stopwatch.Elapsed);
        }