<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
<style type="text/css">
/* <![CDATA[ */ @import "/branding/css/tigris.css"; /* ]]> */
</style>
  <script src="/branding/scripts/sc.js" type="text/javascript"></script>
  <link rel="stylesheet" type="text/css" href="/branding/css/print.css" media="print" />


  <title>Querying and tracking issues</title>
 </head>

 <body class="docs" onload="self.focus()">
  <div class="docs" id="ddissuesquery">
   <!--
              The contents of this file are subject to the Mozilla Public
              License Version 1.1 (the "License"); you may not use this file
              except in compliance with the License. You may obtain a copy of
              the License at http://www.mozilla.org/MPL/
             
              Software distributed under the License is distributed on an "AS
              IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
              implied. See the License for the specific language governing
              rights and limitations under the License.
             
              The Original Code is the Issuezilla Issue Tracking System.
             
              The Initial Developer of the Original Code is Netscape Communications
              Corporation. Portions created by Netscape are
              Copyright (C) 1998 Netscape Communications Corporation. All
              Rights Reserved.
             
              Contributor(s): 

              Contributor(s): Terry Weissman <terry@mozilla.org>
         -->

   <h2>Querying and tracking issues</h2>

   <h3>More help on IssueZilla: Index</h3>

   <div class="toc">
    <ul>
     <li>
      <a href="/nonav/docs/ProjectIssues.html">Project issue tracking</a> 

      <ul>
       <li><a href="/nonav/docs/ddIssues_EnterModify.html">Entering and modifying issues</a></li>

       <li>
        <strong>You are here:</strong> Querying and tracking issues 

        <ul>
         <li><a href="#queryfields">Issue query selection fields</a></li>

         <li><a href="#queryresults">Sorting/customizing query results</a></li>

         <li><a href="#customqueries">Customizing/remembering queries</a></li>

         <li><a href="#trackissue">Tracking your own issues (or by assignee)</a></li>

         <li><a href="#otherqueries">Running other queries</a></li>

         <li><a href="#browserinfo">Browser information</a></li>
        </ul>
       </li>

       <li><a href="/nonav/docs/ddIssues_Reports.html">Generating status reports about project issues</a></li>
      </ul>
     </li>
    </ul>
   </div>

   <div class="courtesylinks">
    <p><a href="/nonav/servlets/HelpTOC">Back to main Help index</a></p>
   </div>

   <h3>About querying the issue database</h3>

   <p>The IssueZilla query form allows you to call up a subset of issues from a project's issue database. If you do not select an option, the designated default values are included in the query. Submitting a query without setting any options at all, for example, returns <i>all</i> project issues with a status of NEW, STARTED, or REOPENED. You can narrow query results by selecting options and/or entering information in the query form fields. You can save your results list in your bookmark file. You can also save your query configuration to reuse later.</p>

   <h3><a id="queryfields" name="queryfields">Issue query selection fields</a></h3>

   <p>The following fields aer available for narrowing the query results.</p>

   <dl>
    <dt>Type</dt>

    <dd>the classification of issues as either <a href="/nonav/docs/ddIssues_EnterModify.html#issue_type">tasks, defects, features, or enhancements</a>.</dd>

    <dt>Component</dt>

    <dd>the part of the project associated with the issue you are querying to find. If you don't choose a component or subcomponent, the query addresses all issues for the <i>project</i>.</dd>

    <dt>Sub Component</dt>

    <dd>a subset of the component you selected in the previous field. If you don't choose a sub component, the query includes all issues for the <i>component</i>.</dd>

    <dt>Status</dt>

    <dd>default values for this fields are <a href="/nonav/docs/issue_lifecycle.html">NEW, STARTED and REOPENED</a>. When searching for issues that are UNCONFIRMED, RESOLVED, VERIFIED, or CLOSED, remember to change this status field appropriately.</dd>

    <dt>Resolution</dt>

    <dd>the qualification of issues with a status of <a href="/nonav/docs/issue_lifecycle.html#resolvedissues">RESOLVED, VERIFIED, OR CLOSED</a>. All resolved issues must be assigned one of these <a href="/nonav/docs/issue_lifecycle.html#resolvedissues">values</a>.</dd>

    <dt>Priority</dt>

    <dd>queries for issues by their rank of importance using the following scale: P1 is highest priority, given to issues that should be addressed as soon as possible; P5 is the lowest priority.</dd>

    <dt>Platform</dt>

    <dd>is the type of computer the issues is associated with. This field is most critical when searching for defects. When querying for other types of issues, it may not be necessary to make a selection in this field.</dd>

    <dt>OS</dt>

    <dd>is the type of operating system the issue is associated with. Again, when querying for other types of issues, it may not be necessary to make a selection in this field.</dd>

    <dt>Version</dt>

    <dd>The release of the software associated with this issue. Leaving this field unselected queries all versions of the selected project or component.</dd>

    <dt>Target Milestone</dt>

    <dd>queries for issues associated with different project milestones, if your project has these. Milestones typically are dates when certain features or overall versions are expected to be completed.</dd>

    <dt>Email</dt>

    <dd>
     lets you query for issues by the email address of assignee, reporter, QA contact, cc list, or added comments. A duplicate field lets you further refine queries based on this criteria. To search for issues associated with an email address: 

     <ul>
      <li>Type a portion of an email address into the text field.</li>

      <li>Select fields to query for association with that email address.</li>
     </ul>

     <p>The second field enables you to look for two different email addresses. If you specify both, then only issues matching both are returned in your query results. For example, this is useful to find issues "created by Ralph" and "assigned to Fred."</p>

     <p>You can also use the drop down menus to specify whether you want to match addresses by doing a substring match or exact match of a fully specified email address.</p>

     <ul>
      <li>Additional input fields let you further qualify queries by issue number(s), date changes, number of votes, and changes in field values.</li>

      <li>Summary is the one-line abbreviated description of the issue used by default in reports and query results.</li>

      <li>A description entry enables querying by text string from the longer, detailed issue description.</li>

      <li>URL lets you query by the web page location associated with issues, when applicable.</li>

      <li>
       Status Whiteboard is a field defined by the project owner (or users with administrative permissions in IssueZilla). Input values to query by this field thus depend upon how it is being used in a particular project. 

       <p>Those who prefer to devise their own query schemes beyond options provided in these from fields provided can <a href="booleanchart.html">set up Boolean chart queries</a>.</p>
      </li>
     </ul>
    </dd>
   </dl>

   <h3><a id="queryresults" name="queryresults">Sorting and customizing query results</a></h3>

   <p>Before submitting a query, you can select to sort by issue number, importance, or assignee. After you submitted a query during a IssueZilla login session, you have the option to "Reuse the same sort as last time."</p>

   <p>Once you view the query results, clicking on any of the column headings will sort the displayed results within that column.</p>

   <p>Using the links at the bottom of the query results page, you can also:</p>

   <ul>
    <li>Switch to "long format" view of results to display complete contents of issues.</li>

    <li>Load a new query form.</li>

    <li>Enter a new issue.</li>

    <li>Change which columns appear in query results.</li>

    <li>Change several issues at once. (This option displays a page that lets you select issues from your query results list and modify specific fields in all of these simultaneously.)</li>

    <li>Send email to owners of issues listed.</li>

    <li>Edit the configuration of the last query.</li>
   </ul>

   <p>To add the target milestone for each issue to your query results -- and you should do so when a particular issue is slated for release --</p>

   <ol>
    <li>Do a query (or click "view assigned issues").</li>

    <li>Click the "change columns" link at the bottom.</li>

    <li>Click the "target milestone" check box.</li>

    <li>Submit.</li>
   </ol>

   <p>The target milestone column will now included for all your subsequent queries because login sessions are cookie-based. You can unmark this checkbox or mark others at any time to change your customized query results.</p>

   <h3><a id="customqueries" name="customqueries">Remembered queries</a></h3>

   <p>Once you've set up a fairly complex query to ferret out certain issues, you can tell IssueZilla to "remember" your custom queries as a time saver. Using the options just above the <i>Submit query</i> button, you can save your most recent query under a unique name and reuse it anytime you are logged in to IssueZilla. You can also change and reset the default query that the query page loads during your login sessions.</p>

   <p>To include your custom, named queries in the footer of the query page, click on the "Edit prefs" link on any of the IssueZilla pages and select the "Page footer link". All of your named queries have the option to be included on every page or only on the query page.</p>

   <h3><a id="trackissue" name="trackissue">Tracking issues by assignee</a></h3>

   <p><b>To view a list of project issues assigned to you</b>, click the <i>My Issues</i> link in the Issue Tracking page.</p>

   <p>Once you have invoked IssueZilla, you can also click the <i>My issues</i> link in the secondary Issue Tracking tool bar.</p>

   <p><b>You have two options for viewing other project members' assigned issues</b>:</p>

   <ul>
    <li>Create an IssueZilla query using the "search the issue database" link and search by the "assigned to" field with the person's name entered. (The default setting for the "status" in the query screen includes NEW, STARTED, and REOPENED.)</li>

    <li>Select the "Members" link in the left navigation bar to view a list of project members by name, each with a link to their assigned project issues.</li>
   </ul>

   <p>You can also generate reports by user and create a page of project members listed by name, each with a link to their specific list of issues.</p>

   <h3><a id="otherqueries" name="otherqueries">Running queries not supported by the query fields</a></h3>

   <p>You can perform some searches that aren't supported by the query form by usine the issue list script to build queries based on the URL. You can add other criteria to these queries.</p>

   <p>For example, if you wanted to see all issues reported against the X platform and assigned to user "jwz," you could ask for all issues assign to jwz, then edit the URL in the "Location" box, adding the clause "&amp;rep_platform=X-Windows" to the URL.</p>

   <p>Here is a list of some of the field names you could use for additional unsupported searches ...</p>

   <ul>
    <li>version</li>

    <li>rep_platform</li>

    <li>op_sys</li>

    <li>reporter area</li>

    <li>issue_file_loc</li>

    <li>short_desc</li>
   </ul>

   <h3><a id="browserinfo" name="browserinfo">Browser notes</a></h3>

   <p>Because IssueZilla uses several non-standard Netscape extensions, the Lynx may cache results of a .cgi. Press CONTROL-R to reload the screen to see an update.</p>

   <div class="courtesylinks">
    <p><a href="/nonav/docs/ProjectIssues.html">Back to Project Issues help</a><br />
     <a href="/nonav/servlets/HelpTOC">Back to main Help index</a></p>
   </div>
  </div>
 </body>
</html>


