public IList <Issue> FindAllIssuesByTypeAndObjectId(Guid applicationId, IssueObjectType type, Guid objectId)
        {
            string[] paramNames  = { "applicationId", "objectType", "objectId" };
            object[] paramValues = { applicationId, (int)type, objectId };

            return(HibernateTemplate.FindByNamedQueryAndNamedParam <Issue>("Issue.FindAllIssuesByTypeAndObjectId", paramNames, paramValues));
        }
        private void DeleteIssuesForObjectId(Guid applicationId, IssueObjectType type, Guid objectId, IList <Issue> dontDeleteIssueList)
        {
            IList <Issue> foundIssues = null;

            Guid[] varIdList = null;

            if (dontDeleteIssueList == null ||
                dontDeleteIssueList.Count == 0)
            {
                varIdList = new List <Guid> {
                    Guid.Empty
                }.ToArray();
            }
            else
            {
                // Get the id's from the Issuelist
                varIdList = dontDeleteIssueList.Select(x => x.Id).ToArray();
            }

            string[] paramNames  = { "applicationId", "objectType", "objectId", "exceptionIdList" };
            object[] paramValues = { applicationId, (int)type, objectId, varIdList };

            foundIssues = HibernateTemplate.FindByNamedQueryAndNamedParam <Issue>("Issue.SelectToDeleteIssuesForObjectId", paramNames, paramValues);

            if (foundIssues != null && foundIssues.Count > 0)
            {
                foreach (Issue issue in foundIssues)
                {
                    Delete(issue);
                }
            }
        }
 public void DeleteIssues(Guid applicationId, IssueObjectType type, Guid objectId, IList <Issue> dontDeleteIssueList)
 {
     if (objectId != Guid.Empty)
     {
         DeleteIssuesForObjectId(applicationId, type, objectId, dontDeleteIssueList);
     }
     else
     {
         DeleteIssuesForObjectType(applicationId, type, dontDeleteIssueList);
     }
 }
Exemplo n.º 4
0
        public IList <Issue> GetAllIssues(IssueObjectType type)
        {
            List <Issue> allIssues = new List <Issue>();

            foreach (AnalyzeIssueNode node in IssueNodes)
            {
                allIssues.AddRange(node.GetAllIssuesBelowNode(type));
            }

            return(allIssues);
        }
        public Issue FindIssue(Guid applicationId, IssueObjectType type, Guid objectId, string title, string text)
        {
            string[] paramNames  = { "applicationId", "objectType", "objectId", "title", "text" };
            object[] paramValues = { applicationId, (int)type, objectId, title, text };

            IList <Issue> foundIssues = HibernateTemplate.FindByNamedQueryAndNamedParam <Issue>("Issue.FindIssue", paramNames, paramValues);

            if (foundIssues.Count == 1)
            {
                return(foundIssues[0]);
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 6
0
        public IList <Issue> GetAllIssuesBelowNode(IssueObjectType type)
        {
            List <Issue> issues = new List <Issue>();

            if (Children.Count > 0)
            {
                foreach (AnalyzeIssueNode childNode in Children)
                {
                    issues.AddRange(childNode.GetAllIssuesBelowNode(type));
                }
            }

            if (IssueList.Count > 0 &&
                IssueObjectType.HasValue &&
                IssueObjectType.Value == type)
            {
                issues.AddRange(IssueList);
            }

            return(issues);
        }
 public void DeleteIssues(Guid applicationId, IssueObjectType type, Guid objectId)
 {
     DeleteIssues(applicationId, type, objectId, null);
 }