示例#1
0
        private async Task<float> GetAverageForType(ApplicationUser student, IEnumerable<WorkItem> workItems, WorkItemType type, GradeDistribution distribution)
        {
            var scoreUnitManager = new ScoreUnitManager(_db);
            var workItemsForType = workItems.Where(wi => wi.Type == type);
            var PointsForType = MaxPointsForType(type, distribution);

            // If no WorkItem for the type, return total for that type
            if(workItemsForType.Count() == 0)
            {
                return PointsForType;
            }

            bool hasGradedScoreUnit = false;
            float studentsScores = 0.0f;
            float total = 0.0f;
            foreach(var workItem in workItemsForType)
            {
                var scoreUnit = await scoreUnitManager.GetStudentScoreUnit(workItem, student);
                if(scoreUnit != null && scoreUnit.Grade.HasValue)
                {
                    hasGradedScoreUnit = true;
                    studentsScores += scoreUnit.Grade.Value;
                    total += workItem.MaxPoints;
                }
            }

            // If no ScoreUnit has been graded, return the total for that type
            if(!hasGradedScoreUnit)
            {
                return PointsForType;
            }

            return (studentsScores / total) * PointsForType;
        }
        private int GetWorkItemsForLastNDays(string noOfDays = "30")
        {
            WorkItemType       workItemType = project.WorkItemTypes["Bug"];
            WorkItemCollection collection   = store.Query("SELECT [System.Id],[System.Title],[System.State],[System.CreatedDate] FROM WorkItems WHERE [System.CreatedDate] >= " + "@" + "Today-" + noOfDays);

            return(collection.Count);
        }
示例#3
0
        private static WorkItem CreateWorkItem(Project project, string workItemType)
        {
            LipsumGenerator gen = new LipsumGenerator();
            Random          rnd = new Random();

            WorkItemType wiType = project.WorkItemTypes[workItemType];

            // Create the work item.
            WorkItem work = new WorkItem(wiType)
            {
                Title       = string.Join(" ", gen.GenerateWords(4)),
                Description = gen.GenerateLipsum(4, Features.Sentences, "")
            };

            if (workItemType == "Task")
            {
                work.Fields["Remaining Work"].Value = rnd.Next(2, 10);
            }
            else if (workItemType == "Product Backlog Item" || workItemType == "Bug")
            {
                work.Fields["Effort"].Value = rnd.Next(1, 13);
            }

            // Save the new user story.
            work.Save();
            Count++;
            return(work);
        }
        private WorkItemCollection GetWorkItemsByState(string state = "New")
        {
            WorkItemType       workItemType = project.WorkItemTypes["Bug"];
            WorkItemCollection collection   = store.Query("SELECT [System.Id],[System.Title],[System.State],[System.CreatedDate] FROM WorkItems WHERE [System.State] = '" + state + "'");

            return(collection);
        }
        private void button2_Click(object sender, System.EventArgs e)
        {
            //Configure credentials
            ICredentials credentials = new NetworkCredential(this.txtLogin.Text, this.txtPassword.Text, this.txtDomain.Text);

            //Create the team foundation server class
            TeamFoundationServer teamFoundationServer = new TeamFoundationServer("http://inflectrasvr03:8080/", credentials);

            //Get access to the work item store
            WorkItemStore workItemStore = new WorkItemStore(teamFoundationServer);

            try
            {
                //Create the new work item
                Project      project      = workItemStore.Projects["Library Information System"];
                WorkItemType workItemType = project.WorkItemTypes["Bug"];
                WorkItem     workItem     = new WorkItem(workItemType);
                //workItem.AreaId = 1;
                workItem.Title       = "SpiraTest Imported bug";
                workItem.Description = "Test description from SpiraTest";
                workItem.State       = "Active";
                workItem.Reason      = "New";
                workItem["Issue"]    = "No";
                //workItem[CoreField.CreatedBy] = "Administrator";
                //workItem[CoreField.ChangedDate] = DateTime.Now;
                workItem.Save();
                this.textBox1.Text = workItem.Id.ToString();
            }
            catch (Exception exception)
            {
                this.textBox1.Text = exception.Message + "\nStack Trace:\n" + exception.StackTrace;
            }
        }
示例#6
0
        /// <summary>
        /// 创建工作项
        /// </summary>
        /// <param name="type">工作项类型</param>
        /// <returns>工作项</returns>
        public WorkItem CreateWorkItem(string type)
        {
            WorkItemType itemtype = this.Project.WorkItemTypes[type];
            WorkItem     workitem = new WorkItem(itemtype);

            return(workitem);
        }
        private string GetExecutor(WorkItemType type)
        {
            var users = _users;
            IEnumerable <string> roleIds;
            bool mayBeEmpty = false;

            switch (type)
            {
            case WorkItemType.Project:
            case WorkItemType.Stage:
                roleIds = _roles.Where(x => x.RoleCode == RoleType.Director || x.RoleCode == RoleType.MainProjectEngeneer).Select(x => x.Id);
                users   = users.Where(x => x.Roles.Any(r => roleIds.Contains(r.Id))).ToList();
                break;

            case WorkItemType.Partition:
            case WorkItemType.Task:
                mayBeEmpty = true;
                roleIds    = _roles.Where(x => x.RoleCode == RoleType.Manager || x.RoleCode == RoleType.Executor).Select(x => x.Id);
                users      = users.Where(x => x.Roles.Any(r => roleIds.Contains(r.Id))).ToList();
                break;
            }
            var isEmpty = mayBeEmpty && _random.Next(0, 4) == 0;

            return(isEmpty ? null : users[_random.Next(0, users.Count)].Id);
        }
        public void Copy_UnitTest1()
        {
            IWorkItem    instance   = GetTestWorkItem();
            WorkItemType targetType = FindWorkItemType("Task");

            instance.Copy(WorkItemTypeWrapper.GetWrapper(targetType));
        }
示例#9
0
        /* Compare work item type definitions and add fields from source work item types and replace workflow */
        public void SetFieldDefinitions(WorkItemTypeCollection workItemTypesSource, Hashtable fieldList)
        {
            foreach (WorkItemType workItemTypeSource in workItemTypesSource)
            {
                WorkItemType workItemTypeTarget = null;
                if (workItemTypeSource.Name == "User Story")
                {
                    workItemTypeTarget = workItemTypes["Product Backlog Item"];
                }
                else if (workItemTypeSource.Name == "Issue")
                {
                    workItemTypeTarget = workItemTypes["Impediment"];
                }
                else
                {
                    workItemTypeTarget = workItemTypes[workItemTypeSource.Name];
                }

                XmlDocument workItemTypeXmlSource = workItemTypeSource.Export(false);
                XmlDocument workItemTypeXmlTarget = workItemTypeTarget.Export(false);

                workItemTypeXmlTarget = AddNewFields(workItemTypeXmlSource, workItemTypeXmlTarget, (List <object>)fieldList[workItemTypeTarget.Name]);

                try
                {
                    WorkItemType.Validate(store.Projects[projectName], workItemTypeXmlTarget.InnerXml);
                    store.Projects[projectName].WorkItemTypes.Import(workItemTypeXmlTarget.InnerXml);
                }
                catch (XmlException)
                {
                    logger.Info("XML import falied for " + workItemTypeSource.Name);
                }
            }
        }
 internal IEnumerable <int> GetWorkItems(Guid projectId, WorkItemType workItemType)
 {
     return(DataContext.WorkItems
            .Where(w => w.ProjectId == projectId && w.WorkItemType == (int)workItemType)
            .Select(i => i.WorkItemId)
            .Distinct());
 }
示例#11
0
        public WorkItem GetNewWorkItem(TfsTeamProjectCollection conn, string projectName, string WIType, string areaPath, string iterationPath, string title, string description)
        {
            try
            {
                WorkItemStore workItemStore = conn.GetService <WorkItemStore>();
                Project       prj           = workItemStore.Projects[projectName];
                WorkItemType  workItemType  = prj.WorkItemTypes[WIType];


                var WIToAdd = new WorkItem(workItemType)
                {
                    Title         = title,
                    Description   = description,
                    IterationPath = iterationPath,
                    AreaPath      = areaPath,
                };

                return(WIToAdd);
            }
            catch (Exception ex)
            {
                Logger.Fatal(new LogInfo(MethodBase.GetCurrentMethod(), "ERR", string.Format("Si è verificato un errore durante la creazione del work Item. Dettagli: {0}", ex.Message)));
                throw ex;
            }
        }
示例#12
0
        public WorkItem(
            WorkItemReference reference,
            WorkItemType type,
            string title,
            string epicId,
            decimal?storyPoints = null,
            string sprint       = null,
            string assignee     = null,
            WorkItemReference parentReference = null)
        {
            if (string.IsNullOrEmpty(title))
            {
                throw new ArgumentException("Value cannot be null or empty.", nameof(title));
            }

            if (string.IsNullOrEmpty(epicId))
            {
                throw new ArgumentException("Value cannot be null or empty.", nameof(epicId));
            }

            Reference       = reference ?? throw new ArgumentNullException(nameof(reference));
            Type            = type;
            Title           = title;
            StoryPoints     = storyPoints;
            Sprint          = sprint;
            EpicId          = epicId;
            Assignee        = assignee;
            ParentReference = parentReference;
        }
 internal int GetWorkItem(Guid projectId, WorkItemType workItemType)
 {
     return(DataContext.WorkItems
            .Where(w => w.ProjectId == projectId && w.WorkItemType == (int)workItemType)
            .Select(i => i.WorkItemId)
            .FirstOrDefault());
 }
示例#14
0
        static void Main(string[] args)
        {
            if (args.Length != 6)
            {
                Console.WriteLine("Usage :");
                Console.WriteLine("\t WitdDiff.exe sourceServerName sourceTeamProjectName sourceWitName targetServerName targetTeamProjectName targetWitName");
                Console.WriteLine("\t Ex) WitdDiff.exe server1 tp1 Bug1 server2 tp2 Bug2");
                Environment.Exit(0);
            }

            string sourceServer  = args[0];
            string sourceTP      = args[1];
            string sourceWitName = args[2];
            string targetServer  = args[3];
            string targetTP      = args[4];
            string targetWitName = args[5];

            WorkItemType srcWit = GetWorkItemType(sourceServer, sourceTP, sourceWitName);
            WorkItemType tarWit = GetWorkItemType(targetServer, targetTP, targetWitName);

            SymDiff <string> witFieldDiff = GetWitFieldDiff(srcWit, tarWit);

            PrintFieldDiff(witFieldDiff, srcWit, tarWit);

            PrintRequiredFields(srcWit);
            PrintRequiredFields(tarWit);
        }
示例#15
0
        private static SymDiff <string> GetWitFieldDiff(WorkItemType srcWit, WorkItemType tarWit)
        {
            List <string> srcWitFields = new List <string>();

            foreach (FieldDefinition fd in srcWit.FieldDefinitions)
            {
                srcWitFields.Add(fd.ReferenceName);
            }
            srcWitFields.Sort();

            List <string> tarWitFields = new List <string>();

            foreach (FieldDefinition fd in tarWit.FieldDefinitions)
            {
                tarWitFields.Add(fd.ReferenceName);
            }
            tarWitFields.Sort();

            SymDiff <string> fieldDiff = new SymDiff <string>(
                srcWitFields.ToArray(),
                tarWitFields.ToArray(),
                StringComparer.InvariantCulture);

            return(fieldDiff);
        }
示例#16
0
        /// <summary>
        /// The add work item for current project.
        /// </summary>
        /// <param name="projectName">
        /// The project name.
        /// </param>
        /// <param name="title">
        /// The title.
        /// </param>
        /// <param name="workItemTypeString">
        /// The work item type string.
        /// </param>
        /// <returns>
        /// The <see cref="int"/>.
        /// </returns>

        public static int AddWorkItemForCurrentProject(string projectName, string title, string workItemTypeString, string areapath = "", string linkend = "", int linkid = 0, string DocUrl = "")
        {
            WorkItemType workItemType =
                TfsManager.Instance.ItemsStore.Projects[projectName].WorkItemTypes[workItemTypeString];
            var wi = new WorkItem(workItemType)
            {
                Title = title
            };

            if (areapath != "" && areapath != projectName)
            {
                wi.AreaPath = areapath;
            }

            var requiredFields = GetRequiredFieldsForWorkItem(wi);

            var popup = new RequiredFields {
                DataContext = requiredFields
            };

            if (requiredFields.Count != 0)
            {
                //Thread.CurrentThread.CurrentCulture = (CultureInfo)Thread.CurrentThread.CurrentCulture.Clone();
                //Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortDatePattern = "dd.MM.yyyy";
                popup.Create(null, Icons.AddNewWorkItem);
                if (popup.IsCancelled && !popup.IsCreated)
                {
                    return(0);
                }
            }

            if (!SetRequiredFieldsForWorkIetm(requiredFields, wi))
            {
                return(0);
            }

            if (linkend != "" && linkid > 0)
            {
                if (TfsManager.Instance.ItemsStore.WorkItemLinkTypes.LinkTypeEnds.Contains(linkend))
                {
                    WorkItemLinkTypeEnd linkTypeEnd = TfsManager.Instance.ItemsStore.WorkItemLinkTypes.LinkTypeEnds[linkend];
                    wi.Links.Add(new RelatedLink(linkTypeEnd, linkid));
                }
            }

            if (DocUrl != "")
            {
                wi.Links.Add(new Hyperlink(DocUrl));
            }

            var _save_errors = wi.Validate();

            if (_save_errors.Count > 0)
            {
                return(0);
            }

            wi.Save();
            return(wi.Id);
        }
示例#17
0
        } // end of Generatexml

        /// <summary>
        /// Create the default control of type "FieldControl" in the FORM
        /// </summary>
        /// <param name="label">Label of the control</param>
        /// <param name="fldName">Actual field name</param>
        /// <param name="cqFieldType">Field Type</param>
        /// <returns></returns>
        private static ControlType CreateDefaultControl(string label,
                                                        string fldName,
                                                        FieldType cqFieldType,
                                                        WorkItemType wit)
        {
            if (CQConstants.FixedFormFields.ContainsKey(fldName))
            {
                // generate the field in FORM only if it is not already there in Fixed Form section
                return(null);
            }

            ControlType ctrl = new ControlType();

            ctrl.LabelPosition = new LabelPositionType();
            ctrl.LabelPosition = LabelPositionType.Left;

            ctrl.Label     = CQConverterUtil.ValidateXmlString(label);
            ctrl.FieldName = fldName;

            if (cqFieldType != FieldType.PlainText)
            {
                ctrl.Type = Const.GenericControl;
            }
            else
            {
                ctrl.Type = Const.HtmlControl;
            }
            if (wit != null)
            {
                wit.FORM.Layout.WITDItems.Add(ctrl);
            }
            return(ctrl);
        } // end of createdefaultcontrol
        public async Task <IActionResult> Edit(int id, [Bind("Name,Id")] WorkItemType workItemType)
        {
            if (id != workItemType.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workItemType);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkItemTypeExists(workItemType.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(workItemType));
        }
示例#19
0
        public object Convert(object value, Type targetType, object parameter, string language)
        {
            WorkItem     item = (WorkItem)value;
            WorkItemType type = item.Type;

            switch (type)
            {
            case WorkItemType.Bug:
                if (((item.State == State.Resolved) || (item.State == State.Closed)) && (ResolvedBug != null))
                {
                    return(ResolvedBug);
                }
                return(Bug);

            case WorkItemType.Task:
                if ((item.State == State.Completed) && (CompletedTask != null))
                {
                    return(CompletedTask);
                }
                if ((item.IterationPath != Logic.TeamSettings.IterationPath) && (FutureTask != null))
                {
                    return(FutureTask);
                }
                return(Task);
            }

            throw new ArgumentException();
        }
示例#20
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,AlimTarihi,AlinanKisi,TeslimAlan,Marka,TeslimAlinanAdet,WorkItemsId")] WorkItemType workItemType)
        {
            if (id != workItemType.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workItemType);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkItemTypeExists(workItemType.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["WorkItemsId"] = new SelectList(_context.WorkItems, "Id", "Id", workItemType.WorkItemsId);
            return(View(workItemType));
        }
        private int GetWorkItemsByTitle(string searchText = "Reason: Other", string noOfDays = "30")
        {
            WorkItemType       workItemType = project.WorkItemTypes["Bug"];
            WorkItemCollection collection   = store.Query("SELECT [System.Id],[System.Title],[System.State],[System.CreatedDate] FROM WorkItems WHERE [System.Title] CONTAINS '" + searchText + "'" + "AND [System.CreatedDate] >= " + "@" + "Today-" + noOfDays);

            return(collection.Count);
        }
示例#22
0
        public HttpResponseMessage CreateItem([FromUri] string requestedCollectionUri, [FromUri] string requestedProject, [FromBody] SimpleWorkItem requestedWorkItem)
        {
            Uri collectionUri                      = new Uri(requestedCollectionUri);
            TfsTeamProjectCollection tpc           = new TfsTeamProjectCollection(collectionUri, new NetworkCredential(username, password, domain));
            WorkItemStore            workItemStore = tpc.GetService <WorkItemStore>();
            Project      teamProject               = workItemStore.Projects[requestedProject];
            WorkItemType workItemType              = teamProject.WorkItemTypes[Utils.GetTFSType(requestedWorkItem.Type)];

            // Create the work item.
            WorkItem newWorkItem = new WorkItem(workItemType)
            {
                // The title is generally the only required field that doesn’t have a default value.
                // You must set it, or you can’t save the work item. If you’re working with another
                // type of work item, there may be other fields that you’ll have to set.
                Title         = requestedWorkItem.Title,
                AreaPath      = requestedWorkItem.AreaPath,
                State         = requestedWorkItem.State,
                IterationPath = requestedWorkItem.IterationPath,
            };
            RelatedLink parent = new RelatedLink(workItemStore.WorkItemLinkTypes.LinkTypeEnds[requestedWorkItem.LinkType], requestedWorkItem.LinkId);

            newWorkItem.Links.Add(parent);
            newWorkItem.Save();
            requestedWorkItem.id = newWorkItem.Id;
            return(Request.CreateResponse <SimpleWorkItem>(HttpStatusCode.OK, requestedWorkItem));
        }
示例#23
0
        static void Main(string[] args)
        {            // Connect to the server and the store, and get the WorkItemType object
            // for user stories from the team project where the user story will be created.
            Uri collectionUri = (args.Length < 1) ?
                                new Uri("http://localhost:8080/tfs/DefaultCollection") : new Uri(args[0]);
            TfsTeamProjectCollection tpc           = new TfsTeamProjectCollection(collectionUri);
            WorkItemStore            workItemStore = tpc.GetService <WorkItemStore>();
            Project teamProject = workItemStore.Projects["SandboxProject"];

            //WorkItemType workItemType = teamProject.WorkItemTypes["User Story"];
            WorkItemType workItemType = teamProject.WorkItemTypes["Test Plan"];

            // Create the work item.
            WorkItem userStory = new WorkItem(workItemType)
            {
                // The title is generally the only required field that doesn’t have a default value.
                // You must set it, or you can’t save the work item. If you’re working with another
                // type of work item, there may be other fields that you’ll have to set.
                Title       = "Recentlyorderedmenu",
                Description =
                    "New Test Plan"
            };

            // Save the new user story.
            userStory.Save();
        }
示例#24
0
文件: Program.cs 项目: xul8tr/CSharp
        private static void CreateFeatureTestTasks(string uri, string projectName, WorkItemType wIType, WorkItemLinkType hierarchyLinkType)
        {
            int    parentID    = 904830;
            string titlePrefix = @"LIBS-15-7 driver-instance-global connect";

            Console.WriteLine(titlePrefix + " tasks start.");
            string areaPath      = @"TIA\Development\HMI Runtime Innovation Line\IOWA Runtime Innovation Line Platform\Integrationstest\FeatureTest";
            string iterationPath = @"TIA\IOWA\Backlog";
            //            string iterationPath = @"TIA\IOWA\IOWA 2015\Inc 25 (31.08.2013)";
            string tags = "DevRelease5";
            //string tags = string.Empty;
            //string assignedTo = "Palotas Gergely";
            //  string assignedTo = "Csepe Zsombor";
            //string assignedTo = "Kiss Zoltan2-Miklos";
            string assignedTo = string.Empty;

            //  CreateTask(parentID, titlePrefix + ": KickOff meeting", wIType, hierarchyLinkType, areaPath, iterationPath, 1, 50, tags, assignedTo );
            CreateTask(parentID, titlePrefix + ": Create TestSpec.", wIType, hierarchyLinkType, areaPath, iterationPath, 24, 50, tags, assignedTo);
            CreateTask(parentID, titlePrefix + ": Review meeting TestSpec.", wIType, hierarchyLinkType, areaPath, iterationPath, 1, 50, tags, assignedTo);
            CreateTask(parentID, titlePrefix + ": Rework TestSpec. after review", wIType, hierarchyLinkType, areaPath, iterationPath, 16, 50, tags, assignedTo);
            CreateTask(parentID, titlePrefix + ": Testcase implementation Rank1 + Review", wIType, hierarchyLinkType, areaPath, iterationPath, 32, 50, tags, assignedTo);
            CreateTask(parentID, titlePrefix + ": Testcase implementation", wIType, hierarchyLinkType, areaPath, iterationPath, 32, 50, tags, assignedTo);
            CreateTask(parentID, titlePrefix + @": BranchTest/IntegrationTest", wIType, hierarchyLinkType, areaPath, iterationPath, 24, 50, tags, assignedTo);

            Console.WriteLine(titlePrefix + " tasks are ready. Press Enter to close this window.");
            Console.ReadLine();
        }
示例#25
0
文件: Program.cs 项目: xul8tr/CSharp
        /// <summary>
        ///
        /// </summary>
        /// <param name="parentID"></param>
        /// <param name="title"></param>
        /// <param name="wIType"></param>
        /// <param name="hierarchyLinkType"></param>
        private static void CreateTask(int parentID, string title, WorkItemType wIType, WorkItemLinkType hierarchyLinkType,
                                       string areaPath, string iterationPath, int workingHours, int stackRank, string tags, string assignedTo)
        {
            WorkItem workItem = new WorkItem(wIType);

            workItem.Title         = title;
            workItem.AreaPath      = areaPath;
            workItem.IterationPath = iterationPath;
            //Set user story as parent of new task
            workItem.Links.Add(new WorkItemLink(hierarchyLinkType.ReverseEnd, parentID));
            //if (String.IsNullOrEmpty(assignedTo))
            //    workItem.Fields["Assigned to"].Value = workItem.ChangedBy;
            //else
            workItem.Fields["Assigned to"].Value       = assignedTo;
            workItem.Fields["Original estimate"].Value = workingHours;
            workItem.Fields["Remaining work"].Value    = workingHours;
            workItem.Fields["Stack rank"].Value        = stackRank;
            workItem.Fields["Tags"].Value = tags;

            System.Collections.ArrayList result = workItem.Validate();
            if (result.Count > 0)
            {
                Console.WriteLine("There was an error adding this work item to the work item repository.");
            }
            else
            {
                workItem.Save();
            }
        }
        private WorkItem GetDummyWorkItem(WorkItemType type = null)
        {
            if (_targetDummyWorkItem == null)
            {
                if (_targetProject.WorkItemTypes.Count == 0)
                {
                    return(null);
                }

                if (type == null)
                {
                    type = _targetProject.WorkItemTypes["Task"];
                }
                if (type == null)
                {
                    type = _targetProject.WorkItemTypes[0];
                }

                _targetDummyWorkItem       = type.NewWorkItem();
                _targetDummyWorkItem.Title = TargetDummyWorkItemTitle;
                _targetDummyWorkItem.Save();
                Log.LogDebug("EmbededImagesRepairEnricher: Dummy workitem {id} created on the target collection.", _targetDummyWorkItem.Id);
                //_targetProject.Store.DestroyWorkItems(new List<int> { _targetDummyWorkItem.Id });
            }
            return(_targetDummyWorkItem);
        }
示例#27
0
 private WorkItem(Workspace onwer, FileInfo?file, DirectoryInfo?directory, WorkItemType type)
 {
     Onwer     = onwer;
     File      = file;
     Directory = directory;
     Type      = type;
     Id        = Guid.NewGuid();
 }
        public WorkItem GetNewWorkItem(string type)
        {
            WorkItemType workItemType = workItemProject.WorkItemTypes[type];

            return(new WorkItem(workItemType)
            {
            });
        }
示例#29
0
        /// <summary>
        /// Returns a JSON string containing all Reasons for provided state.
        /// </summary>
        public ActionResult GetReasonsForNewItem(string workItemType)
        {
            WorkItemType type = UserContext.Current.CurrentProject.WorkItemTypes.FirstOrDefault(w => w.Name.ToLower() == workItemType);

            QueryManager manager = new QueryManager();

            return(Json(manager.GetAllowedValuesForState("Reason", type), JsonRequestBehavior.AllowGet));
        }
        public void Copy_UnitTest2()
        {
            IWorkItem                instance   = GetTestWorkItem();
            WorkItemType             targetType = FindWorkItemType("Task");
            const IWorkItemCopyFlags flags      = IWorkItemCopyFlags.None;

            instance.Copy(WorkItemTypeWrapper.GetWrapper(targetType), flags);
        }
 public ComparisionDataSet(IComparable activeEntity, IComparable previousEntity, WorkItemType workItemType,
                           Guid id)
 {
     ActiveEntity   = activeEntity;
     PreviousEntity = previousEntity;
     WorkItemType   = workItemType;
     Guid           = id;
 }
示例#32
0
        private async Task<BugGuardianResponse> AddWorkItemAsync(WorkItemType workItemType, Exception ex, string message, IEnumerable<string> tags)
        {
            var exceptionHash = Helpers.ExceptionsHelper.BuildExceptionHash(ex);
            WorkItemData bugData = null;

            //Check if aready reported            
            if (Factories.ConfigurationFactory.AvoidMultipleReport)
                bugData = await Helpers.WorkItemsHelper.GetExistentWorkItemId(exceptionHash, workItemType, _account);

            //Create or Update Work Item
            if (bugData?.ID > 0)
                return await Helpers.WorkItemsHelper.UpdateWorkItem(bugData, _account);

            return await Helpers.WorkItemsHelper.CreateNewWorkItem(workItemType, ex, _account, message, tags);
        }
示例#33
0
 private float MaxPointsForType(WorkItemType type, GradeDistribution distribution)
 {
     switch(type)
     {
         case WorkItemType.Exam:
             return distribution.Exam;
         case WorkItemType.Project:
             return distribution.Project;
         case WorkItemType.Homework:
             return distribution.Homework;
         case WorkItemType.Quiz:
             return distribution.Quiz;
         case WorkItemType.Other:
             return distribution.Other;
         default:
             return 0;
     }
 }
示例#34
0
        public void QuickCreate(WorkItemType type)
        {
            var item = new WorkItem();
            item.Fields["System.Title"] = "Bug with snapshot";
            item.Fields["System.AssignedTo"] = "Ashirvad Sahu";
            item.Rev = 1;

            //create attachment
            byte[] content = GetBytesFromFile(@"C:\Users\Ashirvad\Desktop\thX4SG17TP.jpg");
            var fileRef = _workItemClient.UploadAttachment(null, null, "test.jpg", content).Result;

            // add attachment to the bug
            item.Relations.Add(new WorkItemRelation()
            {
                Url = fileRef.Url,
                Rel= "AttachedFile",
                Attributes = new RelationAttributes() { Comment = "this is a weird bug"}
            });
            item = _workItemClient.CreateWorkItem(VSOConfig.projectName, type.ToString(), item).Result;
        }
示例#35
0
        /// <summary>
        /// Create a new Work Item with the given values
        /// </summary>
        /// <param name="workItemType">The WorkItem Type (Bug or Task)</param>
        /// <param name="ex">The exception to report</param>
        /// <param name="account">Account info for VSTS/TFS</param>
        /// <param name="message">Optional message to be added to the WorkItem</param>
        /// <param name="tags">Optional tags (list separated by comma) to be added to the WorkItem</param>
        /// <returns></returns>
        public static async Task<BugGuardianResponse> CreateNewWorkItem(WorkItemType workItemType, Exception ex, Account account, string message, IEnumerable<string> tags)
        {
            //Pattern:
            //PATCH https://{account}.visualstudio.com/defaultcollection/{project}/_apis/wit/workitems/${workitemtypename}?api-version={version}
            //See https://www.visualstudio.com/integrate/api/wit/fields for the fields explanation            
            var createRequestUrl = $"{account.Url}/{account.CollectionName}/{account.ProjectName}/_apis/wit/workitems/${workItemType.ToString()}?{_apiVersion}";

            var workItemCreatePATCHData = new List<APIRequest>();

            //Title: Exception Name
            workItemCreatePATCHData.Add(
                    new WorkItemCreateRequest()
                    {
                        Operation = WITOperationType.add,
                        Path = TitleField,
                        Value = ExceptionsHelper.BuildExceptionTitle(ex)
                    });

            //Tags
            workItemCreatePATCHData.Add(
                    new WorkItemCreateRequest()
                    {
                        Operation = WITOperationType.add,
                        Path = TagsField,
                        Value = DefaultTags + (tags != null ? string.Join(";", tags) : String.Empty)
                    });
            
            if (workItemType == WorkItemType.Bug)
            {
                //BUG

                //Repro Steps: Stack Trace
                workItemCreatePATCHData.Add(
                        new WorkItemCreateRequest()
                        {
                            Operation = WITOperationType.add,
                            Path = ReproStepsField,
                            Value = ExceptionsHelper.BuildExceptionString(ex, message)  // Include custom message, if any
                    });

                //System Info
                workItemCreatePATCHData.Add(
                        new WorkItemCreateRequest()
                        {
                            Operation = WITOperationType.add,
                            Path = SystemInfoField,
                            Value = SystemInfoHelper.BuildSystemInfoString()
                        });
            }
            else
            {
                //TASK
                //Description: Stack Trace + System info
                workItemCreatePATCHData.Add(
                        new WorkItemCreateRequest()
                        {
                            Operation = WITOperationType.add,
                            Path = workItemType == WorkItemType.Bug ? ReproStepsField : DescriptionField,
                            Value = $"{ExceptionsHelper.BuildExceptionString(ex, message)}<br /><hr /><br />{SystemInfoHelper.BuildSystemInfoString()}"  // Include custom message, if any
                        });                
            }            

            //FoundIn: Hash of stack trace
            workItemCreatePATCHData.Add(
                    new WorkItemCreateRequest()
                    {
                        Operation = WITOperationType.add,
                        Path = FoundInField,
                        Value = ExceptionsHelper.BuildExceptionHash(ex)
                    });

            using (var handler = new HttpClientHandler())
            {
                if (!account.IsVSTS) //is TFS, requires NTLM
                    handler.Credentials = new System.Net.NetworkCredential(account.Username, account.Password);

                using (var client = new HttpClient(handler))
                {
                    if (account.IsVSTS)
                        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                    //Set alternate credentials
                    string credentials = $"{account.Username}:{account.Password}";

                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",
                        Convert.ToBase64String(Converters.StringToAsciiConverter.StringToAscii(credentials)));
                    try
                    {
                        var responseBody = await HttpOperationsHelper.PatchAsync(client, createRequestUrl, workItemCreatePATCHData);
                        return new BugGuardianResponse() { Success = true, Response = responseBody };
                    }
                    catch (Exception internalException)
                    {
                        return new BugGuardianResponse() { Success = false, Response = "An error occured. See the Exception.", Exception = internalException };
                    }
                }
            }
        }
示例#36
0
        public static WorkItem CreateWorkItem(WorkItemType type)
        {
            if (type == WorkItemType.Request) return new RequestWorkItem();
            if (type == WorkItemType.Response) return new ResponseWorkItem();

            throw new ArgumentException
                (
                "Creation of work item type " + type + " is not currently supported."
                );
        }
示例#37
0
        /// <summary>
        /// Check if a WorkItem of the given Type and with the same hash already exists on VSTS/TFS
        /// </summary>
        /// <param name="exceptionHash">The MD5 hash of the exception to report</param>
        /// <param name="workItemType">The WorkItem Type (Bug or Task)</param>
        /// <param name="account">Account info for VSTS/TFS</param>
        /// <returns></returns>
        public static async Task<WorkItemData> GetExistentWorkItemId(string exceptionHash, WorkItemType workItemType, Account account)
        {
            //Pattern:
            //POST https://{account}.visualstudio.com/defaultcollection/_apis/wit/wiql?api-version={version}
            var wiqlRequestUrl = $"{account.Url}/{account.CollectionName}/_apis/wit/wiql?{_apiVersion}";

            var workItemQueryPOSTData = new WorkItemWIQLRequest()
            {
                Query = $"Select [System.Id] From WorkItems Where [System.WorkItemType] = '{workItemType.ToString()}' AND [State] <> 'Done' AND [State] <> 'Removed' " +
                            $"AND [System.TeamProject] = '{account.ProjectName}' AND [Microsoft.VSTS.Build.FoundIn] = '{exceptionHash}'"
            };

            using (var handler = new HttpClientHandler())
            {
                if (!account.IsVSTS) //is TFS, requires NTLM
                    handler.Credentials = new System.Net.NetworkCredential(account.Username, account.Password);

                using (var client = new HttpClient(handler))
                {
                    if (account.IsVSTS)
                        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                    //Set alternate credentials
                    string credentials = $"{account.Username}:{account.Password}";

                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",
                        Convert.ToBase64String(Converters.StringToAsciiConverter.StringToAscii(credentials)));

                    try
                    {
                        var responseBody = await HttpOperationsHelper.PostAsync(client, wiqlRequestUrl, workItemQueryPOSTData);
                        var responseBodyObj = JsonConvert.DeserializeObject<dynamic>(responseBody);
                        var workItems = (JArray)responseBodyObj.workItems;
                        if (workItems.HasValues)
                        {
                            //Retrieve bug data
                            var id = workItems.First.Value<int>("id");

                            //Pattern:                        
                            //GET https://{account}.visualstudio.com/defaultcollection/_apis/wit/WorkItems?id={id}&api-version=1.0
                            var dataRequestUrl = $"{account.Url}/{account.CollectionName}/_apis/wit/WorkItems?id={id}&{_apiVersion}";
                            responseBody = await HttpOperationsHelper.GetAsync(client, dataRequestUrl);
                            var workItemData = JsonConvert.DeserializeObject<WorkItemData>(responseBody);

                            //Retrieve bug history
                            //Pattern:                        
                            //GET https://{account}.visualstudio.com/defaultcollection/_apis/wit/WorkItems/{id}/history
                            var historyRequestUrl = $"{account.Url}/{account.CollectionName}/_apis/wit/WorkItems/{id}/history";
                            responseBody = await HttpOperationsHelper.GetAsync(client, historyRequestUrl);
                            responseBodyObj = JsonConvert.DeserializeObject<dynamic>(responseBody);
                            var historyItems = (JArray)responseBodyObj.value;
                            if (historyItems.HasValues)
                                workItemData.History = historyItems.ToObject<List<History>>();

                            return workItemData;
                        }
                    }
                    catch (Exception ex)
                    {
                        int i = 1;
                    }

                    return null;
                }
            }
        }