Attachment #40670 for bug #136219

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.





/**
 * @author Rob Elves
 * TODO: Use of this delegate probably isn't necessary anymore
 */
public class BugzillaRemoteContextDelegate implements IRemoteContextDelegate {

	private ReportAttachment attachment;
	
	public BugzillaRemoteContextDelegate(ReportAttachment attachment) {
		this.attachment = attachment;
	}
	public Date getDate() {
		return attachment.getDateCreated();
	}

	public String getAuthor() {
		return attachment.getAuthor();
	}

	public String getComment() {
		return attachment.getDescription();
	}

	public int getId() {
		return attachment.getId();
	}
		
}

Lines 12-46 Link Here

(-)src/org/eclipse/mylar/bugzilla/core/Comment.java (-87 / +110 lines)
12	package org.eclipse.mylar.bugzilla.core;	12	package org.eclipse.mylar.bugzilla.core;
13		13
14	import java.io.Serializable;	14	import java.io.Serializable;
		15	import java.text.SimpleDateFormat;
		16	import java.util.Calendar;
15	import java.util.Date;	17	import java.util.Date;
16		18
		19	import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
		20
17		21
18	/**	22	/**
19	* A comment posted on a bug.	23	* A comment posted on a bug.
20	*/	24	*/
21	public class Comment implements Serializable {	25	public class Comment extends AttributeContainer implements Serializable {
22	/**	26
23	* Comment for <code>serialVersionUID</code>	27	private static final long serialVersionUID = -1760372869047050979L;
24	*/
25	private static final long serialVersionUID = 3978422529214199344L;
26		28
		29	/** Parser for dates in the report */
		30	public static SimpleDateFormat creation_ts_date_format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		31
27	/** Comment's bug */	32	/** Comment's bug */
28	private final BugReport bug;	33	private final AbstractRepositoryReport bug;
29		34
30	/** Comment's number */	35	/** Comment's number */
31	private final int number;	36	private final int number;
32		37
33	/** Comment's text */	38	// /** Comment's text */
34	private String text;	39	// private String text;
35		40	//
36	/** Comment's author */	41	// /** Comment's author */
37	private final String author;	42	// private final String author;
38		43	//
39	/** Author's realname, if known */	44	// /** Author's realname, if known */
40	private final String authorName;	45	// private final String authorName;
41		46
42	/** Comment's creation timestamp */	47	/** Comment's creation timestamp */
43	private final Date created;	48	private Date created;
44		49
45	/** Preceding comment */	50	/** Preceding comment */
46	private Comment previous;	51	private Comment previous;
Lines 48-87 Link Here
48	/** Following comment */	53	/** Following comment */
49	private Comment next;	54	private Comment next;
50		55
51	private boolean hasAttachment = false;	56	// private boolean hasAttachment = false;
52		57	//
53	private int attachmentId = -1;	58	// private int attachmentId = -1;
54		59	//
55	private String attachmentDescription = "";	60	// private String attachmentDescription = "";
56		61	//
57	private boolean obsolete = false;	62	// private boolean obsolete = false;
58		63
59	/**	64	public Comment(AbstractRepositoryReport report, int num) {
60	* Constructor	65	this.bug = report;
61	*	66	this.number = num;
62	* @param bug
63	* The bug that this comment is associated with
64	* @param date
65	* The date taht this comment was entered on
66	* @param author
67	* The author of the bug
68	* @param authorName
69	* The authors real name
70	*/
71	public Comment(BugReport bug, int number, Date date, String author, String authorName) {
72	this.bug = bug;
73	this.number = number;
74	this.created = date;
75	this.author = author;
76	this.authorName = authorName;
77	}	67	}
		68
		69
		70	// /**
		71	// * Constructor
		72	// *
		73	// * @param bug
		74	// * The bug that this comment is associated with
		75	// * @param date
		76	// * The date taht this comment was entered on
		77	// * @param author
		78	// * The author of the bug
		79	// * @param authorName
		80	// * The authors real name
		81	// * @depricated This use Comment(AbstractRepositoryReport report, int num) instead
		82	// */
		83	// public Comment(AbstractRepositoryReport bug, int number, Date date, String author, String authorName) {
		84	// this.bug = bug;
		85	// this.number = number;
		86	//// this.created = date;
		87	//// this.author = author;
		88	//// this.authorName = authorName;
		89	// }
78		90
79	/**	91	/**
80	* Get the bug that this comment is associated with	92	* Get the bug that this comment is associated with
81	*	93	*
82	* @return The bug that this comment is associated with	94	* @return The bug that this comment is associated with
83	*/	95	*/
84	public BugReport getBug() {	96	public AbstractRepositoryReport getBug() {
85	return bug;	97	return bug;
86	}	98	}
87		99
Lines 100-105 Link Here
100	* @return The comments creation timestamp	112	* @return The comments creation timestamp
101	*/	113	*/
102	public Date getCreated() {	114	public Date getCreated() {
		115	if(created == null) {
		116	created = Calendar.getInstance().getTime();
		117	try {
		118	created = creation_ts_date_format.parse(getAttribute(BugzillaReportElement.CREATION_TS).getValue());
		119	} catch (Exception e) {
		120	}
		121	}
103	return created;	122	return created;
104	}	123	}
105		124
Lines 108-124 Link Here
108	*	127	*
109	* @return The comments author	128	* @return The comments author
110	*/	129	*/
111	public String getAuthor() {	130	public String getAuthor() {
112	return author;	131	return getAttributeValue(BugzillaReportElement.WHO);
113	}	132	}
114		133
115	/**	134	/**
116	* Get the authors real name	135	* Get the authors real name
117	*	136	*
118	* @return Returns author's name, or <code>null</code> if not known	137	* @return Returns author's name, or <code>null</code> if not known
119	*/	138	*/
120	public String getAuthorName() {	139	public String getAuthorName() {
121	return authorName;	140	// TODO: Currently we don't get the real name from the xml.
		141	// Need retrieve these names somehow
		142	return getAuthor();
122	}	143	}
123		144
124	/**	145	/**
Lines 127-144 Link Here
127	* @return The comments text	148	* @return The comments text
128	*/	149	*/
129	public String getText() {	150	public String getText() {
130	return text;	151	return getAttributeValue(BugzillaReportElement.THETEXT);
131	}	152	}
132		153
133	/**	154	// /**
134	* Set the comments text	155	// * Set the comments text
135	*	156	// *
136	* @param text	157	// * @param text
137	* The text to set the comment to have	158	// * The text to set the comment to have
138	*/	159	// */
139	public void setText(String text) {	160	// public void setText(String text) {
140	this.text = text;	161	// this.text = text;
141	}	162	// }
142		163
143	/**	164	/**
144	* Get the next comment for the bug	165	* Get the next comment for the bug
Lines 180-215 Link Here
180	this.previous = previous;	201	this.previous = previous;
181	}	202	}
182		203
183	public void setHasAttachment(boolean b) {	204	// public void setHasAttachment(boolean b) {
184	this.hasAttachment = b;	205	// this.hasAttachment = b;
185	}	206	// }
186		207	//
187	public boolean hasAttachment() {	208	// public boolean hasAttachment() {
188	return hasAttachment;	209	// return hasAttachment;
189	}	210	// }
190		211	//
191	public void setAttachmentId(int attachmentID) {	212	// public void setAttachmentId(int attachmentID) {
192	this.attachmentId = attachmentID;	213	// this.attachmentId = attachmentID;
193	}	214	// }
		215	//
		216	// public int getAttachmentId() {
		217	// return attachmentId;
		218	// }
		219	//
		220	// public void setAttachmentDescription(String attachmentDescription) {
		221	// this.attachmentDescription = attachmentDescription;
		222	// }
		223	//
		224	// public String getAttachmentDescription() {
		225	// return attachmentDescription;
		226	// }
		227	//
		228	// public void setObsolete(boolean obsolete) {
		229	// this.obsolete = obsolete;
		230	// }
		231	//
		232	// public boolean isObsolete() {
		233	// return obsolete;
		234	// }
		235	//
194		236
195	public int getAttachmentId() {
196	return attachmentId;
197	}
198
199	public void setAttachmentDescription(String attachmentDescription) {
200	this.attachmentDescription = attachmentDescription;
201	}
202
203	public String getAttachmentDescription() {
204	return attachmentDescription;
205	}
206
207	public void setObsolete(boolean obsolete) {
208	this.obsolete = obsolete;
209	}
210
211	public boolean isObsolete() {
212	return obsolete;
213	}
214		237
215	}	238	}




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.bugzilla.core;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;

/**
 * A bug report entered in Bugzilla.
 * 
 * @author Mik Kersten (hardening of prototype)
 */
public class BugReport implements Serializable, IBugzillaBug {

	private static final String ATTR_REPORTER = "Reporter";

	private static final String ATTR_RESOLUTION = "Resolution";

	private static final String ATTR_ASSIGNED_TO = "Assigned To";

	public static final String ATTR_SUMMARY = "Summary";

	public static final String ATTR_STATUS = "Status";

	public static final String ATTR_PRIORITY = "Priority";
	
	public static final String VAL_STATUS_VERIFIED = "VERIFIED";

	public static final String VAL_STATUS_CLOSED = "CLOSED";

	public static final String VAL_STATUS_RESOLVED = "RESOLVED";

	public static final String VAL_STATUS_NEW = "NEW";

	public static final String KEY_MILESTONE = "target_milestone";

	public static final String ATTRIBUTE_URL = "URL";

	public static final String ATTRIBUTE_PRIORITY = "Priority";

	public static final String ATTRIBUTE_COMPONENT = "Component";

	public static final String ATTRIBUTE_VERSION = "Version";

	public static final String ATTRIBUTE_PLATFORM = "Platform";

	public static final String ATTRIBUTE_MILESTONE = "Target Milestone";

	public static final String ATTRIBUTE_OS = "OS";

	public static final String ATTRIBUTE_SEVERITY = "Severity";
	
	private static final long serialVersionUID = 3258693199936631348L;

	/** Bug id */
	protected final int id;

	/** The bug's server */
	protected final String repositoryUrl;

	/** Description of the bug */
	protected String description;

	/** Creation timestamp */
	protected Date created;

	/** Modification timestamp */
	protected Date lastModified = null;
	
	/** The bugs valid keywords */
	protected List<String> validKeywords;

	/** The operations that can be done on the bug */
	protected List<Operation> operations = new ArrayList<Operation>();

	/** Bug attributes (status, resolution, etc.) */
	protected HashMap<String, Attribute> attributes = new HashMap<String, Attribute>();

//	/** Attachments (Id, Description) **/
//	protected HashMap<Integer, String> attachements = new HashMap<Integer, String>();
	
	/** The keys for the bug attributes */
	protected ArrayList<String> attributeKeys = new ArrayList<String>();

	/** A list of comments */
	protected ArrayList<Comment> comments = new ArrayList<Comment>();

	/** The value for the new comment to add (text that is saved) */
	protected String newComment = "";

	/** The new value for the new comment to add (text from submit editor) */
	protected String newNewComment = "";

	/** CC list */
	protected HashSet<String> cc = new HashSet<String>();

	/** The operation that was selected to do to the bug */
	protected Operation selectedOperation = null;

	/** Whether or not this bug report is saved offline. */
	protected boolean savedOffline = false;

	protected boolean hasChanges = false;

	protected String charset = null;

	public BugReport(int id, String server) {
		this.id = id;
		this.repositoryUrl = server;
	}

	/**
	 * Get the bugs id
	 * 
	 * @return The bugs id
	 */
	public int getId() {
		return id;
	}

	public String getRepositoryUrl() {
		return repositoryUrl;
	}

	public String getLabel() {
		return id + ": " + getSummary(); 
	}

	/**
	 * Get the bugs description
	 * 
	 * @return The description of the bug
	 */
	public String getDescription() {
		return description;
	}

	/**
	 * Set the description of the bug
	 * 
	 * @param description
	 *            The description to set the bug to have
	 */
	public void setDescription(String description) {
		this.description = decodeStringFromCharset(description);
	}

	/**
	 * Get the summary for the bug
	 * 
	 * @return The bugs summary
	 */
	public String getSummary() {
		if (getAttribute(ATTR_SUMMARY) == null) {
			BugzillaPlugin.log(new Status(IStatus.ERROR, IBugzillaConstants.PLUGIN_ID, IStatus.ERROR,
					"null summary for: " + id, null));
			return "";
		}
		return getAttribute(ATTR_SUMMARY).getValue();
	}

	/**
	 * Set the summary of the bug
	 * 
	 * @param summary
	 *            The summary to set the bug to have
	 */
	public void setSummary(String summary) {
		Attribute attribute = new Attribute(ATTR_SUMMARY);
		attribute.setValue(summary);
		addAttribute(attribute);
	}

	private String decodeStringFromCharset(String string) {
		String decoded = string;
		if (charset != null && string != null && Charset.availableCharsets().containsKey(charset)) {
			try {
				decoded = new String(string.getBytes(), charset);
			} catch (UnsupportedEncodingException e) {
				// ignore
			}
		}
		return decoded;
	}

	/**
	 * Get the date that the bug was created
	 * 
	 * @return The bugs creation date
	 */
	public Date getCreated() {
		return created;
	}

	/**
	 * Set the bugs creation date
	 * 
	 * @param created
	 *            The date the the bug was created
	 */
	public void setCreated(Date created) {
		this.created = created;
	}

	public Attribute getAttribute(String key) {
		return attributes.get(key);
	}

	/**
	 * Get the list of attributes for this bug
	 * 
	 * @return An <code>ArrayList</code> of the bugs attributes
	 */
	public List<Attribute> getAttributes() {
		// create an array list to store the attributes in
		ArrayList<Attribute> attributeEntries = new ArrayList<Attribute>(attributeKeys.size());

		// go through each of the attribute keys
		for (Iterator<String> it = attributeKeys.iterator(); it.hasNext();) {
			// get the key for the attribute
			String key = it.next();

			// get the attribute and add it to the list
			Attribute attribute = attributes.get(key);
			attributeEntries.add(attribute);
		}

		// return the list of attributes for the bug
		return attributeEntries;
	}

	public Attribute getAttributeForKnobName(String knobName) {
		for (Iterator<String> it = attributeKeys.iterator(); it.hasNext();) {
			String key = it.next();

			Attribute attribute = attributes.get(key);
			if (attribute != null && attribute.getParameterName() != null
					&& attribute.getParameterName().compareTo(knobName) == 0) {
				return attribute;
			}
		}

		return null;
	}

	/**
	 * @param attribute
	 *            The attribute to add to the bug
	 */
	public void addAttribute(Attribute attribute) {
		if (!attributes.containsKey(attribute.getName())) {
			attributeKeys.add(attribute.getName());
		}

		attribute.setValue(decodeStringFromCharset(attribute.getValue()));

		// put the value of the attribute into the map, using its name as the
		// key
		attributes.put(attribute.getName(), attribute);
	}

	/**
	 * Get the comments posted on the bug
	 * 
	 * @return A list of comments for the bug
	 */
	public ArrayList<Comment> getComments() {
		return comments;
	}

	/**
	 * Add a comment to the bug
	 * 
	 * @param comment
	 *            The comment to add to the bug
	 */
	public void addComment(Comment comment) {
		Comment preceding = null;
		if (comments.size() > 0) {
			// if there are some comments, get the last comment and set the next
			// value to be the new comment
			preceding = comments.get(comments.size() - 1);
			preceding.setNext(comment);
		}
		// set the comments previous value to the preceeding one
		comment.setPrevious(preceding);

		comment.setText(decodeStringFromCharset(comment.getText()));
		// add the comment to the comment list
		comments.add(comment);
	}

	/**
	 * Get the person who reported the bug
	 * 
	 * @return The person who reported the bug
	 */
	public String getReporter() {
		return getAttribute(ATTR_REPORTER).getValue();
	}

	/**
	 * Get the person to whom this bug is assigned
	 * 
	 * @return The person who is assigned to this bug
	 */
	public String getAssignedTo() {
		return getAttribute(ATTR_ASSIGNED_TO).getValue();
	}

	/**
	 * Get the resolution of the bug
	 * 
	 * @return The resolution of the bug
	 */
	public String getResolution() {
		return getAttribute(ATTR_RESOLUTION).getValue();
	}

	/**
	 * Get the status of the bug
	 * 
	 * @return The bugs status
	 */
	public String getStatus() {
		return getAttribute(ATTR_STATUS).getValue();
	}

	/**
	 * Get the keywords for the bug
	 * 
	 * @return The keywords for the bug
	 */
	public List<String> getKeywords() {
		return validKeywords;
	}

	/**
	 * Set the keywords for the bug
	 * 
	 * @param keywords
	 *            The keywords to set the bug to have
	 */
	public void setKeywords(List<String> keywords) {
		this.validKeywords = keywords;
	}

	/**
	 * Get the set of addresses in the CC list
	 * 
	 * @return A <code>Set</code> of addresses in the CC list
	 */
	public Set<String> getCC() {
		return cc;
	}

	/**
	 * Add an email to the bugs CC list
	 * 
	 * @param email
	 *            The email address to add to the CC list
	 */
	public void addCC(String email) {
		cc.add(email);
	}

	/**
	 * Remove an address from the bugs CC list
	 * 
	 * @param email
	 *            the address to be removed from the CC list
	 * @return <code>true</code> if the email is in the set and it was removed
	 */
	public boolean removeCC(String email) {
		return cc.remove(email);
	}

	/**
	 * Get the new comment that is to be added to the bug
	 * 
	 * @return The new comment
	 */
	public String getNewComment() {
		return newComment;
	}

	/**
	 * Set the new comment that will be added to the bug
	 * 
	 * @param newComment
	 *            The new comment to add to the bug
	 */
	public void setNewComment(String newComment) {
		this.newComment = newComment;
		newNewComment = newComment;
	}

	/**
	 * @return the new value of the new NewComment.
	 */
	public String getNewNewComment() {
		return newNewComment;
	}

	/**
	 * Set the new value of the new NewComment
	 * 
	 * @param newNewComment
	 *            The new value of the new NewComment.
	 */
	public void setNewNewComment(String newNewComment) {
		this.newNewComment = newNewComment;
	}

	/**
	 * Get all of the operations that can be done to the bug
	 * 
	 * @return The operations that can be done to the bug
	 */
	public List<Operation> getOperations() {
		return operations;
	}

	/**
	 * Add an operation to the bug
	 * 
	 * @param o
	 *            The operation to add
	 */
	public void addOperation(Operation o) {
		operations.add(o);
	}

	/**
	 * Get an operation from the bug based on its display name
	 * 
	 * @param displayText
	 *            The display text for the operation
	 * @return The operation that has the display text
	 */
	public Operation getOperation(String displayText) {
		Iterator<Operation> itr = operations.iterator();
		while (itr.hasNext()) {
			Operation o = itr.next();
			String opName = o.getOperationName();
			opName = opName.replaceAll("</.*>", "");
			opName = opName.replaceAll("<.*>", "");
			if (opName.equals(displayText))
				return o;
		}
		return null;
	}

	/**
	 * Set the selected operation
	 * 
	 * @param o
	 *            The selected operation
	 */
	public void setSelectedOperation(Operation o) {
		selectedOperation = o;
	}

	/**
	 * Get the selected operation
	 * 
	 * @return The selected operation
	 */
	public Operation getSelectedOperation() {
		return selectedOperation;
	}

	public boolean isSavedOffline() {
		return savedOffline;
	}

	public boolean isLocallyCreated() {
		return false;
	}

	public void setOfflineState(boolean newOfflineState) {
		savedOffline = newOfflineState;
	}

	public boolean hasChanges() {
		return hasChanges;
	}

	public void setHasChanged(boolean b) {
		hasChanges = b;
	}

	public boolean isResolved() {
		Attribute status = getAttribute(ATTR_STATUS);
		return status != null && isResolvedStatus(getAttribute(ATTR_STATUS).getValue());
	}

	/**
	 * TODO: move?
	 */
	public static boolean isResolvedStatus(String status) {
		if (status != null) {
			return status.equals(VAL_STATUS_RESOLVED) || status.equals(VAL_STATUS_CLOSED)
					|| status.equals(VAL_STATUS_VERIFIED);
		} else {
			return false;
		}
	}

	public String getCharset() {
		return charset;
	}

	public void setCharset(String charset) {
		this.charset = charset;
	}

	public Date getLastModified() {
		return lastModified;
	}

	public void setLastModified(Date date) {
		this.lastModified = date;		
	}

	
//	public void addAttachment(int id, String description) {
//		attachements.put(id, description);
//	}
//	
//	public HashMap<Integer, String> getAttachements() {
//		return attachements;
//	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.core;

import java.io.Serializable;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Class representing a Bugzilla report attribute that can be changed on the
 * server.
 */
public class Attribute implements Serializable {
	/** Automatically generated serialVersionUID */
	private static final long serialVersionUID = 3257009873370757424L;

	private boolean hidden = false;

	/** Attribute name */
	private String name;

	/** Name of the option used when updating the attribute on the server */
	private String parameterName;

	/** Legal values of the attribute */
	private LinkedHashMap<String, String> optionValues;

	/**
	 * Attribute's value (input field or selected option; value that is saved or
	 * from the server)
	 */
	private String value;

	/** Attributes new Value (value chosen in submit editor) */
	private String newValue;

	/**
	 * Constructor
	 * 
	 * @param name
	 *            The name of the attribute
	 */
	public Attribute(String name) {
		// initialize the name and its legal values
		this.name = name;
		optionValues = new LinkedHashMap<String, String>();
	}

	/**
	 * Get the attribute's name
	 * 
	 * @return The name of the attribute
	 */
	public String getName() {
		return name;
	}

	/**
	 * Get name of the option used when updating the attribute on the server
	 * 
	 * @return The name of the option for server updates
	 */
	public String getParameterName() {
		return parameterName;
	}

	/**
	 * Get whether the attribute can be edited by the used
	 * 
	 * @return <code>true</code> if the attribute can be edited by the user
	 */
	public boolean isEditable() {
		return optionValues.size() > 0;
	}

	/**
	 * Get the legal values for the option
	 * 
	 * @return The <code>Map</code> of legal values for the option.
	 */
	public Map<String, String> getOptionValues() {
		return optionValues;
	}

	/**
	 * Get the value of the attribute
	 * 
	 * @return A <code>String</code> of the attributes value
	 */
	public String getValue() {
		return value;
	}

	/**
	 * Set the value of the attribute
	 * 
	 * @param value
	 *            The new value of the attribute
	 */
	public void setValue(String value) {
		this.value = value;
		newValue = value;
	}

	/**
	 * Set the new value of the attribute
	 * 
	 * @param newVal
	 *            The new value of the attribute
	 */
	public void setNewValue(String newVal) {
		newValue = newVal;
	}

	/**
	 * Get the new value for the attribute
	 * 
	 * @return The new value
	 */
	public String getNewValue() {
		return newValue;
	}

	/**
	 * Sets the name of the option used when updating the attribute on the
	 * server
	 * 
	 * @param parameterName
	 *            The name of the option when updating from the server
	 */
	public void setParameterName(String parameterName) {
		this.parameterName = parameterName;
	}

	/**
	 * Adds an attribute option value
	 * 
	 * @param readableValue
	 *            The value displayed on the screen
	 * @param parameterValue
	 *            The option value used when sending the form to the server
	 */
	public void addOptionValue(String readableValue, String parameterValue) {
		optionValues.put(readableValue, parameterValue);
	}

	/**
	 * Determine if the field was hidden or not
	 * 
	 * @return True if the field was hidden
	 */
	public boolean isHidden() {
		return hidden;
	}

	/**
	 * Set whether the field was hidden in the bug
	 * 
	 * @param b
	 *            Whether the field was hidden or not
	 */
	public void setHidden(boolean b) {
		hidden = b;
	}

	public String toString() {
		return "(" + getName() + " : " + getValue() + ")";
	}
}




 *******************************************************************************/
package org.eclipse.mylar.bugzilla.core;

import java.io.Serializable;
import java.util.Date;
import java.util.List;


/**
 * Interface representing a Bugzilla bug report.
 */
public interface IBugzillaBug { // extends Serializable

	// /**
	// * @return bug's id.
	// */
	// public int getId();
	//
	// /**
	// * @return the server for this bug.
	// */
	// public String getRepositoryUrl();

	/**
	 * @return the title label for this bug.

	 */
	public void setSummary(String newSummary);

	// /**
	// * Get an attribute given its key
	// *
	// * @return The value of the attribute or <code>null</code> if not present
	// */
	// public AbstractRepositoryReportAttribute getAttribute(String key);
	//
	// /**
	// * @return the attributes for this bug.
	// */
	// public List<AbstractRepositoryReportAttribute> getAttributes();

	// /**
	// * @return <code>true</code> if this bug report is saved offline.
	// */
	// public boolean isSavedOffline();

	// /**
	// * @return <code>true</code> if this bug was created locally, and does not
	// * yet exist on a bugzilla server.
	// */
	// public boolean isLocallyCreated();

	// /**
	// * Sets whether or not this bug is saved offline.
	// *
	// * @param newOfflineState
	// * <code>true</code> if this bug is saved offline
	// */
	// public void setOfflineState(boolean newOfflineState);

	// public boolean hasChanges();

	public void addCC(String email);

	public void addOperation(Operation o);

	public String getAssignedTo();

	public List<String> getCC();

	public List<String> getKeywords();
	 * @return the attributes for this bug.
	 */
	public List<Attribute> getAttributes();

	public String getNewComment();
	 * @return <code>true</code> if this bug report is saved offline.
	 */
	public boolean isSavedOffline();

	// public String getNewNewComment();
	public void setNewComment(String newComment);
	 *         yet exist on a bugzilla server.
	 */
	public boolean isLocallyCreated();

	// public void setNewNewComment(String newNewComment);
	 * Sets whether or not this bug is saved offline.
	 * 
	 * @param newOfflineState
	 *            <code>true</code> if this bug is saved offline
	 */
	public void setOfflineState(boolean newOfflineState);

	//public Operation getOperation(String displayText);

	public List<Operation> getOperations();

	public String getReporter();

	public String getResolution();

	public void setSelectedOperation(Operation o);

	public Operation getSelectedOperation();

	public String getStatus();

	public boolean isResolved();

	public void removeCC(String email);

	// public void setCreated(Date created);
	public void setKeywords(List<String> keywords);

	// public void setLastModified(Date date);
	public String getProduct();

	/**
	 * Get the date that the bug was created

Lines 62-67 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/core/internal/SaxConfigurationContentHandler.java (+11 lines)
62	private static final String ELEMENT_SEVERITY = "severity";	62	private static final String ELEMENT_SEVERITY = "severity";
63		63
64	private static final String ELEMENT_PRIORITY = "priority";	64	private static final String ELEMENT_PRIORITY = "priority";
		65
		66	private static final String ELEMENT_KEYWORD = "keyword";
65		67
66	private static final String ELEMENT_OP_SYS = "op_sys";	68	private static final String ELEMENT_OP_SYS = "op_sys";
67		69
Lines 108-113 Link Here
108	private static final int IN_STATUS_OPEN = 1 << 17;	110	private static final int IN_STATUS_OPEN = 1 << 17;
109		111
110	private static final int IN_RESOLUTION = 1 << 18;	112	private static final int IN_RESOLUTION = 1 << 18;
		113
		114	private static final int IN_KEYWORD = 1 << 19;
111		115
112	private int state = EXPECTING_ROOT;	116	private int state = EXPECTING_ROOT;
113		117
Lines 183-188 Link Here
183	case IN_RESOLUTION \| IN_LI:	187	case IN_RESOLUTION \| IN_LI:
184	configuration.addResolution(String.copyValueOf(ch, start, length));	188	configuration.addResolution(String.copyValueOf(ch, start, length));
185	break;	189	break;
		190	case IN_KEYWORD \| IN_LI:
		191	configuration.addKeyword(String.copyValueOf(ch, start, length));
		192	break;
186	case IN_STATUS_OPEN \| IN_LI:	193	case IN_STATUS_OPEN \| IN_LI:
187	configuration.addOpenStatusValue(String.copyValueOf(ch, start, length));	194	configuration.addOpenStatusValue(String.copyValueOf(ch, start, length));
188	break;	195	break;
Lines 234-239 Link Here
234	state = state \| IN_STATUS_OPEN;	241	state = state \| IN_STATUS_OPEN;
235	} else if (localName.equals(ELEMENT_RESOLUTION)) {	242	} else if (localName.equals(ELEMENT_RESOLUTION)) {
236	state = state \| IN_RESOLUTION;	243	state = state \| IN_RESOLUTION;
		244	} else if (localName.equals(ELEMENT_KEYWORD)) {
		245	state = state \| IN_KEYWORD;
237	}	246	}
238		247
239	}	248	}
Lines 345-350 Link Here
345	state = state & ~IN_STATUS_OPEN;	354	state = state & ~IN_STATUS_OPEN;
346	} else if (localName.equals(ELEMENT_RESOLUTION)) {	355	} else if (localName.equals(ELEMENT_RESOLUTION)) {
347	state = state & ~IN_RESOLUTION;	356	state = state & ~IN_RESOLUTION;
		357	} else if (localName.equals(ELEMENT_KEYWORD)) {
		358	state = state & ~IN_KEYWORD;
348	}	359	}
349		360
350	}	361	}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.bugzilla.core.internal;

import java.io.IOException;
import java.io.Reader;
import java.text.ParseException;

import javax.security.auth.login.LoginException;

import org.eclipse.mylar.bugzilla.core.Attribute;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.NewBugModel;
import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer.Token;

/**
 * @author Shawn Minto
 * 
 * This class parses the valid attribute values for a new bug
 */
public class NewBugParser {
	/** Tokenizer used on the stream */
	private HtmlStreamTokenizer tokenizer;

	/** Flag for whether we need to try to get the product or not */
	private static boolean getProd = false;

	public NewBugParser(Reader in) {
		tokenizer = new HtmlStreamTokenizer(in, null);
	}

	/**
	 * Parse the new bugs valid attributes
	 * 
	 * @param nbm
	 *            A reference to a NewBugModel where all of the information is
	 *            stored
	 * @throws IOException
	 * @throws ParseException
	 * @throws LoginException
	 */
	public void parseBugAttributes(NewBugModel nbm, boolean retrieveProducts) throws IOException, ParseException,
			LoginException {
		nbm.attributes.clear(); // clear any attriubtes in bug model from a
		// previous product

		NewBugParser.getProd = retrieveProducts;

		// create a new bug report and set the parser state to the start state
		ParserState state = ParserState.START;
		String attribute = null;

		boolean isTitle = false;
		boolean possibleBadLogin = false;
		boolean isErrorState = false;
		String title = "";
		// Default error message
		String errorMsg = "Bugzilla could not get the needed bug attribute since your login name or password is incorrect.  Please check your settings in the bugzilla preferences.";

		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			// make sure that bugzilla doesn't want us to login
			if (token.getType() == Token.TAG && ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.TITLE
					&& !((HtmlTag) (token.getValue())).isEndTag()) {
				isTitle = true;
				continue;
			}

			if (isTitle) {
				// get all of the data in the title tag to compare with
				if (token.getType() != Token.TAG) {
					title += ((StringBuffer) token.getValue()).toString().toLowerCase() + " ";
					continue;
				} else if (token.getType() == Token.TAG
						&& ((HtmlTag) token.getValue()).getTagType() == HtmlTag.Type.TITLE
						&& ((HtmlTag) token.getValue()).isEndTag()) {
					// check if the title looks like we may have a problem with
					// login
					if (title.indexOf("login") != -1) {
						possibleBadLogin = true; // generic / default msg
						// passed to constructor re:
						// bad login
					}
					if ((title.indexOf("invalid") != -1 && title.indexOf("password") != -1)
							|| title.indexOf("check e-mail") != -1 || title.indexOf("error") != -1) {
						possibleBadLogin = true;
						isErrorState = true; // set flag so appropriate msg
						// is provide for the exception
						errorMsg = ""; // error message will be parsed from
						// error page
					}

					isTitle = false;
					title = "";
				}
				continue;
			}

			// we have found the start of an attribute name
			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();				
				if (tag.getTagType() == HtmlTag.Type.TD && "right".equalsIgnoreCase(tag.getAttribute("align"))) {
					// parse the attribute's name
					attribute = parseAttributeName();
					if(attribute != null && attribute.contains(IBugzillaConstants.INVALID_2201_ATTRIBUTE_IGNORED)) {
						continue;
					}					
					if (attribute == null)
						continue;
					state = ParserState.ATT_VALUE;
					continue;
				}

				if (tag.getTagType() == HtmlTag.Type.TD && "#ff0000".equalsIgnoreCase(tag.getAttribute("bgcolor"))) {
					state = ParserState.ERROR;
					continue;
				}
			}

			// we have found the start of attribute values
			if (state == ParserState.ATT_VALUE && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD) {
					// parse the attribute values
					parseAttributeValue(nbm, attribute);

					state = ParserState.ATT_NAME;
					attribute = null;
					continue;
				}
			}
			// page being parsed contains an Error message
			// parse error message so it can be given to the constructor of the
			// exception
			// so an appropriate error message is displayed
			if (state == ParserState.ERROR && isErrorState) {
				// tag should be text token, not a tag
				// get the error message
				if (token.getType() == Token.TEXT) {
					// get string value of next token to add to error messgage
					// unescape the string so any escape sequences parsed appear
					// unescaped in the details pane
					errorMsg += HtmlStreamTokenizer.unescape(((StringBuffer) token.getValue()).toString()) + " ";
				}
				// expect </font> tag to indicate end of error end msg
				// set next state to continue parsing remainder of page
				else if (token.getType() == Token.TAG
						&& ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.FONT
						&& ((HtmlTag) (token.getValue())).isEndTag()) {
					state = ParserState.ATT_NAME;
				}
				continue;
			}

			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.INPUT && tag.getAttribute("type") != null
						&& "hidden".equalsIgnoreCase(tag.getAttribute("type").trim())) {
					Attribute a = new Attribute(tag.getAttribute("name"));
					a.setParameterName(tag.getAttribute("name"));
					a.setValue(tag.getAttribute("value"));
					a.setHidden(true);
					nbm.attributes.put(a.getName(), a);
					continue;
				}
			}
		}

		if (possibleBadLogin && (nbm.getAttributes() == null || nbm.getAttributes().size() == 0)) {
			throw new LoginException(errorMsg);
		}
	}

	/**
	 * Parse the case where we have found an attribute name
	 * 
	 * @param tokenizer
	 *            The tokenizer to use to find the name
	 * @return The name of the attribute
	 * @throws IOException
	 * @throws ParseException
	 */
	private String parseAttributeName() throws IOException, ParseException {
		StringBuffer sb = new StringBuffer();

		parseTableCell(sb);
		HtmlStreamTokenizer.unescape(sb);
		// remove the colon if there is one
		if (sb.length() == 0)
			return null;
		if (sb.charAt(sb.length() - 1) == ':') {
			sb.deleteCharAt(sb.length() - 1);
		}
		return sb.toString();
	}

	/**
	 * Reads text into a StringBuffer until it encounters a close table cell tag
	 * (&lt;/TD&gt;) or start of another cell. The text is appended to the
	 * existing value of the buffer. <b>NOTE:</b> Does not handle nested cells!
	 * 
	 * @param tokenizer
	 * @param sb
	 * @throws IOException
	 * @throws ParseException
	 */
	private void parseTableCell(StringBuffer sb) throws IOException, ParseException {
		boolean noWhitespace = false;
		for (HtmlStreamTokenizer.Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer
				.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD) {
					if (!tag.isEndTag()) {
						tokenizer.pushback(token);
					}
					break;
				}
				noWhitespace = token.getWhitespace().length() == 0;
			} else if (token.getType() == Token.TEXT) {
				// if there was no whitespace between the tag and the
				// preceding text, don't insert whitespace before this text
				// unless it is there in the source
				if (!noWhitespace && token.getWhitespace().length() > 0 && sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
	}

	/**
	 * Parse the case where we have found attribute values
	 * 
	 * @param nbm
	 *            The NewBugModel that is to contain information about a new bug
	 * @param attributeName
	 *            The name of the attribute that we are parsing
	 * @param tokenizer
	 *            The tokenizer to use for parsing
	 * @throws IOException
	 * @throws ParseException
	 */
	private void parseAttributeValue(NewBugModel nbm, String attributeName) throws IOException, ParseException {

		HtmlStreamTokenizer.Token token = tokenizer.nextToken();
		if (token.getType() == Token.TAG) {
			HtmlTag tag = (HtmlTag) token.getValue();
			if (tag.getTagType() == HtmlTag.Type.SELECT && !tag.isEndTag()) {
				String parameterName = tag.getAttribute("name");
				parseSelect(nbm, attributeName, parameterName);
			} else if (tag.getTagType() == HtmlTag.Type.INPUT && !tag.isEndTag()) {
				parseInput(nbm, attributeName, tag);
			} else if (!tag.isEndTag()) {
				parseAttributeValueCell(nbm, attributeName);
			}
		} else {
			StringBuffer sb = new StringBuffer();
			if (token.getType() == Token.TEXT) {
				sb.append((StringBuffer) token.getValue());
				parseAttributeValueCell(nbm, attributeName, sb);
			}
		}
	}

	/**
	 * Parse the case where the attribute value is just text in a table cell
	 * 
	 * @param attributeName
	 *            The name of the attribute we are parsing
	 * @param tokenizer
	 *            The tokenizer to use for parsing
	 * @throws IOException
	 * @throws ParseException
	 */
	private void parseAttributeValueCell(NewBugModel nbm, String attributeName) throws IOException, ParseException {
		StringBuffer sb = new StringBuffer();

		parseAttributeValueCell(nbm, attributeName, sb);
	}

	private void parseAttributeValueCell(NewBugModel nbm, String attributeName, StringBuffer sb) throws IOException,
			ParseException {

		parseTableCell(sb);
		HtmlStreamTokenizer.unescape(sb);

		// if we need the product we will get it
		if (getProd && attributeName.equalsIgnoreCase("product")) {
			nbm.setProduct(sb.toString());
		}
	}

	/**
	 * Parse the case where the attribute value is an input
	 * 
	 * @param nbm
	 *            The new bug model to add information that we get to
	 * @param attributeName
	 *            The name of the attribute that we are parsing
	 * @param tag
	 *            The HTML tag that we are currently on
	 * @throws IOException
	 */
	private static void parseInput(NewBugModel nbm, String attributeName, HtmlTag tag) throws IOException {

		Attribute a = new Attribute(attributeName);
		a.setParameterName(tag.getAttribute("name"));
		String value = tag.getAttribute("value");
		if (value == null)
			value = "";

		// if we found the summary, add it to the bug report
		if (attributeName.equalsIgnoreCase("summary")) {
			nbm.setSummary(value);
		} else if (attributeName.equalsIgnoreCase("Attachments")) {
			// do nothing - not a problem after 2.14
		} else if (attributeName.equalsIgnoreCase("add cc")) {
			// do nothing
		} else if (attributeName.toLowerCase().startsWith("cc")) {
			// do nothing cc's are options not inputs
		} else {
			// otherwise just add the attribute
			a.setValue(value);
			nbm.attributes.put(attributeName, a);
		}
	}

	/**
	 * Parse the case where the attribute value is an option
	 * 
	 * @param nbm
	 *            The NewBugModel that we are storing information in
	 * @param attributeName
	 *            The name of the attribute that we are parsing
	 * @param parameterName
	 *            The SELECT tag's name
	 * @param tokenizer
	 *            The tokenizer that we are using for parsing
	 * @throws IOException
	 * @throws ParseException
	 */
	private void parseSelect(NewBugModel nbm, String attributeName, String parameterName) throws IOException,
			ParseException {

		boolean first = false;
		Attribute a = new Attribute(attributeName);
		a.setParameterName(parameterName);

		HtmlStreamTokenizer.Token token = tokenizer.nextToken();
		while (token.getType() != Token.EOF) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.SELECT && tag.isEndTag())
					break;
				if (tag.getTagType() == HtmlTag.Type.OPTION && !tag.isEndTag()) {
					String optionName = tag.getAttribute("value");
					boolean selected = tag.hasAttribute("selected");
					StringBuffer optionText = new StringBuffer();
					for (token = tokenizer.nextToken(); token.getType() == Token.TEXT; token = tokenizer.nextToken()) {
						if (optionText.length() > 0) {
							optionText.append(' ');
						}
						optionText.append((StringBuffer) token.getValue());
					}
					a.addOptionValue(optionText.toString(), optionName);

					if (selected || first) {
						a.setValue(optionText.toString());
						first = false;
					}
				} else {
					token = tokenizer.nextToken();
				}
			} else {
				token = tokenizer.nextToken();
			}
		}

		if (!(nbm.attributes).containsKey(attributeName)) {
			(nbm.attributes).put(attributeName, a);
		}
	}

	/**
	 * Enum class for describing current state of Bugzilla report parser.
	 */
	private static class ParserState {
		/** An instance of the start state */
		protected static final ParserState START = new ParserState("start");

		/** An instance of the state when the parser found an attribute name */
		protected static final ParserState ATT_NAME = new ParserState("att_name");

		/** An instance of the state when the parser found an attribute value */
		protected static final ParserState ATT_VALUE = new ParserState("att_value");

		/** An instance of the state when an error page is found */
		protected static final ParserState ERROR = new ParserState("error");

		/** State's human-readable name */
		private String name;

		/**
		 * Constructor
		 * 
		 * @param description -
		 *            The states human readable name
		 */
		private ParserState(String description) {
			this.name = description;
		}

		@Override
		public String toString() {
			return name;
		}
	}
}




import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.compare.BugzillaCompareInput;

 * Class to persist the data for the offline reports list
 */
public class OfflineReportsFile {

	public enum BugzillaOfflineStatus {
		SAVED, SAVED_WITH_OUTGOING_CHANGES, DELETED, SAVED_WITH_INCOMMING_CHANGES, CONFLICT, ERROR
	}

	
	/** The file that the offline reports are written to */
	private File file;

	/** The directory to where the file is located */
	/** A list of offline reports */
	private ArrayList<BugzillaReport> list = new ArrayList<BugzillaReport>();

	/** Sort by bug ID */
	public static final int ID_SORT = 0;

	 * @throws IOException
	 *             Error opening or closing the offline reports file
	 * @throws ClassNotFoundException
	 * @throws ClassNotFoundException
	 *             Error deserializing objects from the offline reports file
	 */
	public OfflineReportsFile(File file) throws IOException, ClassNotFoundException {
		this.file = file;
		if (file.exists()) {
			readFile();

	 * @param entry
	 *            The bug to add
	 */
	public BugzillaOfflineStatus add(BugzillaReport entry, boolean saveChosen) throws CoreException {

		BugzillaOfflineStatus status = BugzillaOfflineStatus.SAVED;

		try {

			// check for bug and do a compare
			int index = -1;
			if ((index = find(entry.getRepositoryUrl(), entry.getId())) >= 0) {
				BugzillaReport oldBug = list.get(index);
				if (oldBug instanceof BugzillaReport && entry instanceof BugzillaReport && !saveChosen) {
					CompareConfiguration config = new CompareConfiguration();
					config.setLeftEditable(false);
					config.setRightEditable(false);

					config.setRightImage(PlatformUI.getWorkbench().getSharedImages().getImage(
							ISharedImages.IMG_OBJ_ELEMENT));
					final BugzillaCompareInput in = new BugzillaCompareInput(config);
					in.setLeft((BugzillaReport) oldBug);
					in.setRight((BugzillaReport) entry);
					in.setTitle("Bug #" + oldBug.getId());

					try {

					} catch (InvocationTargetException x) {
						BugzillaPlugin.log(x);
						MessageDialog.openError(null, "Compare Failed", x.getTargetException().getMessage());
						return BugzillaOfflineStatus.ERROR;
					}

					if (in.getCompareResult() == null) {
						status = BugzillaOfflineStatus.SAVED;
					} else if (oldBug.hasChanges()) {
						if (!MessageDialog
								.openQuestion(
										null,

										"Local copy of Bug# "
												+ entry.getId()
												+ " Has Changes.\nWould you like to override local changes? Note: if you select No, your added comment will be saved with the updated bug, but all other changes will be lost.")) {
							((BugzillaReport) entry).setNewComment(((BugzillaReport) oldBug).getNewComment());
							((BugzillaReport) entry).setHasChanged(true);
							status = BugzillaOfflineStatus.CONFLICT;
						} else {
							((BugzillaReport) entry).setHasChanged(false);
							status = BugzillaOfflineStatus.SAVED;
						}
					} else {
						DiffNode node = (DiffNode) in.getCompareResult();
						IDiffElement[] children = node.getChildren();
						if (children.length != 0) {

								}
							}
						} else {
							status = BugzillaOfflineStatus.SAVED; // do we
							// ever get
							// here?
						}
					}


			}
			// add the entry to the list and write the file to disk
			list.add(entry);
			writeFile();
		} catch (Exception e) {
			e.printStackTrace();
			IStatus runtimestatus = new Status(IStatus.ERROR, IBugzillaConstants.PLUGIN_ID, IStatus.OK,
					"failed to add offline report", e);
			throw new CoreException(runtimestatus);
		}
		return status;

	 */
	public int find(String repositoryUrl, int id) {
		for (int i = 0; i < list.size(); i++) {
			BugzillaReport currBug = list.get(i);
			if (currBug != null && currBug.getRepositoryUrl() != null
					&& (currBug.getRepositoryUrl().equals(repositoryUrl) && currBug.getId() == id)
					&& !currBug.isLocallyCreated())
				return i;
		}
		return -1;
	}

	public static BugzillaReport findBug(String repositoryUrl, int bugId) {
		int location = BugzillaPlugin.getDefault().getOfflineReports().find(repositoryUrl, bugId);
		if (location != -1) {
			return BugzillaPlugin.getDefault().getOfflineReports().elements().get(location);

	 * 
	 * @return The list of offline reports
	 */
	public ArrayList<BugzillaReport> elements() {
		return list;
	}



			// write each element in the array list
			for (int i = 0; i < list.size(); i++) {
				BugzillaReport item = list.get(i);
				try {
					out.writeObject(item);
				} catch (IOException e) {

	 * @throws IOException
	 *             Error opening or closing the offline reports file
	 * @throws ClassNotFoundException
	 * @throws ClassNotFoundException
	 *             Error deserializing objects from the offline reports file
	 */
	private void readFile() throws IOException, ClassNotFoundException {

		ObjectInputStream in = null;
		try {
			in = new ObjectInputStream(new FileInputStream(file));

			// get the number of offline reports in the file
			int size = in.readInt();

			// get the bug id of the most recently created offline report
			latestNewBugId = in.readInt();

			// read in each of the offline reports in the file
			for (int nX = 0; nX < size; nX++) {
				// try {
				BugzillaReport item = (BugzillaReport) in.readObject();
				// add the offline report to the offlineReports list
				list.add(item);
				// } catch (ClassNotFoundException e) {
				//				
				// // // ignore this since we can't do anything
				// // BugzillaPlugin.log(new Status(Status.ERROR,
				// // IBugzillaConstants.PLUGIN_ID, Status.ERROR,
				// // "Unable to read bug object", e));
				//				
				// }
			}

		} finally {
			in.close();
		}
		in.close();
	}

	/**

	 * @param indicesToRemove
	 *            An array of the indicies of the bugs to be removed
	 */
	public void remove(List<BugzillaReport> sel) {
		list.removeAll(sel);

		// rewrite the file so that the data is persistant

	}

}
// /**
// * Function to sort the offline reports list
// * @param sortOrder The way to sort the bugs in the offline reports list
// */
// public void sort(int sortOrder) {
// IBugzillaBug[] a = list.toArray(new IBugzillaBug[list.size()]);
//		
// // decide which sorting method to use and sort the offline reports
// switch(sortOrder) {
// case ID_SORT:
// Arrays.sort(a, new SortID());
// lastSel = ID_SORT;
// break;
// case TYPE_SORT:
// Arrays.sort(a, new SortType());
// lastSel = TYPE_SORT;
// break;
// }
//		
// // remove all of the elements from the list so that we can re-add
// // them in a sorted order
// list.clear();
//		
// // add the sorted elements to the list and the table
// for (int j = 0; j < a.length; j++) {
// add(a[j]);
// }
// }

// /**
// * Inner class to sort by bug id
// */
// private class SortID implements Comparator<IBugzillaBug> {
// public int compare(IBugzillaBug f1, IBugzillaBug f2) {
// Integer id1 = f1.getId();
// Integer id2 = f2.getId();
//
// if(id1 != null && id2 != null)
// return id1.compareTo(id2);
// else if(id1 == null && id2 != null)
// return -1;
// else if(id1 != null && id2 == null)
// return 1;
// else
// return 0;
// }
// }
//
// /**
// * Inner class to sort by bug type (locally created or from the server)
// */
// private class SortType implements Comparator<IBugzillaBug> {
// public int compare(IBugzillaBug f1, IBugzillaBug f2) {
// boolean isLocal1 = f1.isLocallyCreated();
// boolean isLocal2 = f2.isLocallyCreated();
//			
// if (isLocal1 && !isLocal2) {
// return -1;
// }
// else if (!isLocal1 && isLocal2) {
// return 1;
// }
//			
// // If they are both the same type, sort by ID
// Integer id1 = f1.getId();
// Integer id2 = f2.getId();
//
// if(id1 != null && id2 != null)
// return id1.compareTo(id2);
// else if(id1 == null && id2 != null)
// return -1;
// else if(id1 != null && id2 == null)
// return 1;
// else
// return 0;
// }
// }

// /**
// * Saves the given report to the offlineReportsFile, or, if it already
// * exists in the file, updates it.
// *
// * @param bug
// * The bug to add/update.
// */
// public static void saveOffline(IBugzillaBug bug, boolean saveChosen) throws
// CoreException {
// OfflineReportsFile file = BugzillaPlugin.getDefault().getOfflineReports();
// // If there is already an offline report for this bug, update the file.
// if (bug.isSavedOffline()) {
// file.update();
// }
// // If this bug has not been saved offline before, add it to the file.
// else {
// int index = -1;
// // If there is already an offline report with the same id, don't
// // save this report.
// if ((index = file.find(bug.getId())) >= 0) {
// removeReport(getOfflineBugs().get(index));
// // MessageDialog.openInformation(null, "Bug's Id is already
// // used.", "There is already a bug saved offline with an
// // identical id.");
// // return;
// }
// file.add(bug, saveChosen);
// bug.setOfflineState(true);
// // file.sort(OfflineReportsFile.lastSel);
// }
// }

// public static List<IBugzillaBug> getOfflineBugs() {
// OfflineReportsFile file = BugzillaPlugin.getDefault().getOfflineReports();
// return file.elements();
// }
//
// /**
// * Removes the given report from the offlineReportsFile.
// *
// * @param bug
// * The report to remove.
// */
// public static void removeReport(IBugzillaBug bug) {
// ArrayList<IBugzillaBug> bugList = new ArrayList<IBugzillaBug>();
// bugList.add(bug);
// BugzillaPlugin.getDefault().getOfflineReports().remove(bugList);
// }




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.bugzilla.core.internal;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.net.URL;
import java.net.URLConnection;

import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;

/**
 * Reads bugzilla product configuration from config.cgi on server in RDF format.
 * 
 * @author Rob Elves
 */
public class ServerConfigurationFactory {

	private static final String CONFIG_RDF_URL = "/config.cgi?ctype=rdf";

	private static ServerConfigurationFactory instance;

	private ServerConfigurationFactory() {
		// no initial setup needed
	}

	public static ServerConfigurationFactory getInstance() {
		if (instance == null) {
			instance = new ServerConfigurationFactory();
		}
		return instance;
	}

	public RepositoryConfiguration getConfiguration(String server) throws IOException {
		URL serverURL = new URL(server + CONFIG_RDF_URL);
		URLConnection c = serverURL.openConnection();
		BufferedReader in = new BufferedReader(new InputStreamReader(c.getInputStream()));

		SaxConfigurationContentHandler contentHandler = new SaxConfigurationContentHandler();

		try {
			StringBuffer result = XmlCleaner.clean(in);
			StringReader strReader = new StringReader(result.toString());
			XMLReader reader = XMLReaderFactory.createXMLReader();
			reader.setErrorHandler(new SaxErrorHandler());
			reader.setContentHandler(contentHandler);
			reader.parse(new InputSource(strReader));
		} catch (SAXException e) {
			throw new IOException("Unable to read server configuration.");
		}
		return contentHandler.getConfiguration();

	}

	class SaxErrorHandler implements ErrorHandler {

		public void error(SAXParseException exception) throws SAXException {
			MylarStatusHandler.fail(exception, "ServerConfigurationFactory: " + exception.getLocalizedMessage(), false);
		}

		public void fatalError(SAXParseException exception) throws SAXException {
			MylarStatusHandler.fail(exception, "ServerConfigurationFactory: " + exception.getLocalizedMessage(), false);

		}

		public void warning(SAXParseException exception) throws SAXException {
			// ignore
		}

	}

}

Lines 43-48 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/core/internal/RepositoryConfiguration.java (-2 / +47 lines)
43		43
44	private List<String> resolutionValues = new ArrayList<String>();	44	private List<String> resolutionValues = new ArrayList<String>();
45		45
		46	private List<String> keywords = new ArrayList<String>();
		47
46	// master lists	48	// master lists
47		49
48	private List<String> versions = new ArrayList<String>();	50	private List<String> versions = new ArrayList<String>();
Lines 88-94 Link Here
88	*/	90	*/
89	public List<String> getProducts() {	91	public List<String> getProducts() {
90	ArrayList<String> productList = new ArrayList<String>(products.keySet());	92	ArrayList<String> productList = new ArrayList<String>(products.keySet());
91	Collections.sort(productList);	93	Collections.sort(productList);
92	return productList;	94	return productList;
93	}	95	}
94		96
Lines 214-226 Link Here
214	// }	216	// }
215	// }	217	// }
216		218
		219	public void addKeyword(String keyword) {
		220	keywords.add(keyword);
		221	}
		222
		223	public List<String> getKeywords() {
		224	return keywords;
		225	}
		226
217	public void addPlatform(String platform) {	227	public void addPlatform(String platform) {
218	platforms.add(platform);	228	platforms.add(platform);
219	}	229	}
220		230
221	public void addPriority(String priority) {	231	public void addPriority(String priority) {
222	priorities.add(priority);	232	priorities.add(priority);
223
224	}	233	}
225		234
226	public void addSeverity(String severity) {	235	public void addSeverity(String severity) {
Lines 323-326 Link Here
323	return versions;	332	return versions;
324	}	333	}
325		334
		335	/*
		336	* Intermediate step until configuration is made generic.
		337	*/
		338
		339	public List<String> getOptionValues(BugzillaReportElement element, String product) {
		340	switch (element) {
		341	case PRODUCT:
		342	return getProducts();
		343	case TARGET_MILESTONE:
		344	// return getTargetMilestones();
		345	return getTargetMilestones(product);
		346	case BUG_STATUS:
		347	return getStatusValues();
		348	case VERSION:
		349	// return getVersions();
		350	return getVersions(product);
		351	case COMPONENT:
		352	// return getComponents();
		353	return getComponents(product);
		354	case REP_PLATFORM:
		355	return getPlatforms();
		356	case OP_SYS:
		357	return getOSs();
		358	case PRIORITY:
		359	return getPriorities();
		360	case BUG_SEVERITY:
		361	return getSeverities();
		362	case KEYWORDS:
		363	return getKeywords();
		364	case RESOLUTION:
		365	return getResolutions();
		366	default:
		367	return new ArrayList<String>();
		368	}
		369	}
		370
326	}	371	}

Lines 14-20 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/core/internal/Favorite.java (-2 / +2 lines)
14	import java.util.Date;	14	import java.util.Date;
15	import java.util.Map;	15	import java.util.Map;
16		16
17	import org.eclipse.mylar.bugzilla.core.BugReport;	17	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
18	import org.eclipse.mylar.internal.bugzilla.core.search.BugzillaSearchResultCollector;	18	import org.eclipse.mylar.internal.bugzilla.core.search.BugzillaSearchResultCollector;
19		19
20	/**	20	/**
Lines 48-54 Link Here
48	* @param bug	48	* @param bug
49	* The bug this favorite represents.	49	* The bug this favorite represents.
50	*/	50	*/
51	public Favorite(BugReport bug) {	51	public Favorite(BugzillaReport bug) {
52	this(bug.getRepositoryUrl(), bug.getId(), bug.getSummary(), "", BugzillaSearchResultCollector.getAttributeMap(bug));	52	this(bug.getRepositoryUrl(), bug.getId(), bug.getSummary(), "", BugzillaSearchResultCollector.getAttributeMap(bug));
53	}	53	}
54		54




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.internal.bugzilla.core.internal;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import javax.security.auth.login.LoginException;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylar.bugzilla.core.Attribute;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.bugzilla.core.Operation;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer.Token;

/**
 * @author Shawn Minto
 * @author Mik Kersten (hardening of prototype)
 * @author Rob Elves (attachments) This class parses bugs so that they can be
 *         displayed using the bug editor
 */
public class BugParser {

	private static final String VALUE_ATTACHMENT_OBSOLETE = "bz_obsolete";

	private static final String ATTRIBUTE_CLASS = "class";

	private static final String TAG_SPAN = "span";

	private static final String ATTRIBUTE_ID_TITLE = "title";

	private static final String ATTRIBUTE_ID_HREF = "href";

	private static final String ATTACHMENT_CGI_ID = "attachment.cgi?id=";

	private static final String KEY_BUG_NUM = "Bug#";

	private static final String KEY_RESOLUTION = "resolution";

	private static final String KEY_VALUE = "value";

	private static final String KEY_NAME = "name";

	private static final String ATTR_CHARSET = "charset";

	/** Parser for dates in the report */
	private static SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");

	private static final String keywordsUrl = "describekeywords.cgi";

	/**
	 * Parse the case where we have found an attribute name
	 * 
	 * @param in
	 *            The input stream for the bug
	 * @return The name of the attribute that we are parsing
	 * @throws IOException
	 */
	private static String parseAttributeName(HtmlStreamTokenizer tokenizer) throws IOException, ParseException {
		StringBuffer sb = new StringBuffer();

		parseTableCell(tokenizer, sb);
		HtmlStreamTokenizer.unescape(sb);
		// remove the colon if there is one
		if (sb.length() > 0 && sb.charAt(sb.length() - 1) == ':') {
			sb.deleteCharAt(sb.length() - 1);
		}
		return sb.toString();
	}

	/**
	 * Parse the case where we have found attribute values
	 * 
	 * @param in
	 *            The input stream of the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @param attribute
	 *            The name of the attribute
	 * @throws IOException
	 */
	private static void parseAttributeValue(BugReport bug, String originalAttributeName, HtmlStreamTokenizer tokenizer,
			String serverUrl, String userName, String password) throws IOException, ParseException {

		// NOTE: special rule to deal with change in 2.20.1
		String attributeName = originalAttributeName;
		if (attributeName.endsWith(KEY_BUG_NUM) && attributeName.length() > KEY_BUG_NUM.length()) {
			attributeName = originalAttributeName.substring(attributeName.length() - KEY_BUG_NUM.length(),
					attributeName.length());
		}

		Token token = tokenizer.nextToken();
		if (token.getType() == Token.TAG) {
			HtmlTag tag = (HtmlTag) token.getValue();

			// make sure that we are on a tag that we care about, not a label
			// fix added so that we can parse the mozilla bug pages
			if (tag.getTagType() == HtmlTag.Type.LABEL) {
				token = tokenizer.nextToken();
				if (token.getType() == Token.TAG)
					tag = (HtmlTag) token.getValue();
				else {
					StringBuffer sb = new StringBuffer();
					if (token.getType() == Token.TEXT) {
						sb.append((StringBuffer) token.getValue());
						parseAttributeValueCell(bug, attributeName, tokenizer, sb);
					}
				}
			}

			if (tag.getTagType() == HtmlTag.Type.SELECT && !tag.isEndTag()) {
				String parameterName = tag.getAttribute(KEY_NAME);
				parseSelect(bug, attributeName, parameterName, tokenizer);
			} else if (tag.getTagType() == HtmlTag.Type.INPUT && !tag.isEndTag()) {
				parseInput(bug, attributeName, tag, serverUrl, userName, password);
			} else if (!tag.isEndTag() || attributeName.equalsIgnoreCase(KEY_RESOLUTION)) {
				if (tag.isEndTag() && attributeName.equalsIgnoreCase(KEY_RESOLUTION)) {
					Attribute a = new Attribute(attributeName);
					a.setValue("");
					bug.addAttribute(a);
				}
				parseAttributeValueCell(bug, attributeName, tokenizer);
			}
		} else {
			StringBuffer sb = new StringBuffer();
			if (token.getType() == Token.TEXT) {
				sb.append((StringBuffer) token.getValue());
				parseAttributeValueCell(bug, attributeName, tokenizer, sb);
			}
		}
	}

	/**
	 * Parse the case where the attribute value is just text in a table cell
	 * 
	 * @param in
	 *            The input stream of the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @param attributeName
	 *            The name of the attribute that we are parsing
	 * @throws IOException
	 */
	private static void parseAttributeValueCell(BugReport bug, String attributeName, HtmlStreamTokenizer tokenizer)
			throws IOException, ParseException {
		StringBuffer sb = new StringBuffer();
		parseAttributeValueCell(bug, attributeName, tokenizer, sb);
	}

	private static void parseAttributeValueCell(BugReport bug, String attributeName, HtmlStreamTokenizer tokenizer,
			StringBuffer sb) throws IOException, ParseException {

		parseTableCell(tokenizer, sb);
		HtmlStreamTokenizer.unescape(sb);

		// create a new attribute and set its value to the value that we
		// retrieved
		Attribute a = new Attribute(attributeName);
		a.setValue(sb.toString());

		// if we found an attachment attribute, forget about it, else add the
		// attribute to the bug report
		if (attributeName.toLowerCase().startsWith("attachments")) {
			// do nothing
		} else {
			if (attributeName.equals(KEY_BUG_NUM))
				a.setValue(a.getValue().replaceFirst("alias:", ""));
			bug.addAttribute(a);
		}
	}

	/**
	 * Reads text into a StringBuffer until it encounters a close table cell tag
	 * (&lt;/TD&gt;) or start of another cell. The text is appended to the
	 * existing value of the buffer. <b>NOTE:</b> Does not handle nested cells!
	 * 
	 * @param tokenizer
	 * @param sb
	 * @throws IOException
	 * @throws ParseException
	 */
	private static void parseTableCell(HtmlStreamTokenizer tokenizer, StringBuffer sb) throws IOException,
			ParseException {
		boolean noWhitespace = false;
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD) {
					if (!tag.isEndTag()) {
						tokenizer.pushback(token);
					}
					break;
				}
				noWhitespace = token.getWhitespace().length() == 0;
			} else if (token.getType() == Token.TEXT) {
				// if there was no whitespace between the tag and the
				// preceding text, don't insert whitespace before this text
				// unless it is there in the source
				if (!noWhitespace && token.getWhitespace().length() > 0 && sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
	}

	/**
	 * Parse the case where the attribute value is an option
	 * 
	 * @param in
	 *            The input stream for the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @param attribute
	 *            The name of the attribute that we are parsing
	 * @param parameterName
	 *            the SELECT tag's name
	 * @throws IOException
	 */
	private static void parseSelect(BugReport bug, String attributeName, String parameterName,
			HtmlStreamTokenizer tokenizer) throws IOException, ParseException {

		boolean first = false;
		Attribute a = new Attribute(attributeName);
		a.setParameterName(parameterName);

		Token token = tokenizer.nextToken();
		while (token.getType() != Token.EOF) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.SELECT && tag.isEndTag())
					break;
				if (tag.getTagType() == HtmlTag.Type.OPTION && !tag.isEndTag()) {
					String optionName = tag.getAttribute(KEY_VALUE);
					boolean selected = tag.hasAttribute("selected");
					StringBuffer optionText = new StringBuffer();
					for (token = tokenizer.nextToken(); token.getType() == Token.TEXT; token = tokenizer.nextToken()) {
						if (optionText.length() > 0) {
							optionText.append(' ');
						}
						optionText.append((StringBuffer) token.getValue());
					}
					a.addOptionValue(optionText.toString(), optionName);
					if (selected || first) {
						a.setValue(optionText.toString());
						first = false;
					}
				} else {
					token = tokenizer.nextToken();
				}
			} else {
				token = tokenizer.nextToken();
			}
		}

		// if we parsed the cc field add the e-mails to the bug report else add
		// the attribute to the bug report
		if (attributeName.toLowerCase().startsWith("cc")) {
			for (Iterator<String> it = a.getOptionValues().keySet().iterator(); it.hasNext();) {
				String email = it.next();
				bug.addCC(HtmlStreamTokenizer.unescape(email));
			}
		} else {
			bug.addAttribute(a);
		}
	}

	/**
	 * Parse the case where the attribute value is an input
	 * 
	 * @param bug
	 *            The bug report for the current bug
	 * @param attributeName
	 *            The name of the attribute
	 * @param tag
	 *            The INPUT tag
	 * @throws IOException
	 */
	private static void parseInput(BugReport bug, String attributeName, HtmlTag tag, String serverUrl, String userName,
			String password) throws IOException {

		Attribute a = new Attribute(attributeName);
		a.setParameterName(tag.getAttribute(KEY_NAME));
		String name = tag.getAttribute(KEY_NAME);
		String value = tag.getAttribute(KEY_VALUE);
		if (value == null)
			value = "";

		// if we found the summary, add it to the bug report
		if (name.equalsIgnoreCase("short_desc")) {
			bug.setSummary(value);
		} else if (name.equalsIgnoreCase("bug_file_loc")) {
			a.setValue(value);
			bug.addAttribute(a);
		} else if (name.equalsIgnoreCase("newcc")) {
			a.setValue(value);
			bug.addAttribute(a);
		} else {
			// otherwise just add the attribute
			a.setValue(value);
			bug.addAttribute(a);

			if (attributeName.equalsIgnoreCase("keywords") && serverUrl != null) {

				BufferedReader input = null;
				try {

					String urlText = "";

					// if we have a user name, may as well log in just in case
					// it is required
					if (userName != null && !userName.equals("") && password != null && !password.equals("")) {
						/*
						 * The UnsupportedEncodingException exception for
						 * URLEncoder.encode() should not be thrown, since every
						 * implementation of the Java platform is required to
						 * support the standard charset "UTF-8"
						 */
						urlText += "?GoAheadAndLogIn=1&Bugzilla_login=" + URLEncoder.encode(userName, "UTF-8")
								+ "&Bugzilla_password=" + URLEncoder.encode(password, "UTF-8");
					}

					// connect to the bugzilla server to get the keyword list
					URL url = new URL(serverUrl + "/" + keywordsUrl + urlText);
					URLConnection urlConnection = BugzillaPlugin.getDefault().getUrlConnection(url);
					input = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));

					// parse the valid keywords and add them to the bug
					List<String> keywords = new KeywordParser(input).getKeywords();
					bug.setKeywords(keywords);

				} catch (Exception e) {
					// throw an exception if there is a problem reading the bug
					// from the server
					throw new IOException("Exception while fetching the list of keywords from the server: "
							+ e.getMessage());
				} finally {
					try {
						if (input != null)
							input.close();
					} catch (IOException e) {
						BugzillaPlugin.log(new Status(IStatus.ERROR, IBugzillaConstants.PLUGIN_ID, IStatus.ERROR,
								"Problem closing the stream", e));
					}
				}
			}
		}
	}

	/**
	 * Parse the case where we are dealing with the description
	 * 
	 * @param bug
	 *            The bug report for the bug
	 * @throws IOException
	 */
	private static void parseDescription(BugReport bug, HtmlStreamTokenizer tokenizer) throws IOException,
			ParseException {

		StringBuffer sb = new StringBuffer();
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (sb.length() > 0) {
					sb.append(token.getWhitespace());
				}
				if (tag.getTagType() == HtmlTag.Type.PRE && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (sb.length() > 0) {
					sb.append(token.getWhitespace());
				}
				sb.append((StringBuffer) token.getValue());
			}
		}

		// set the bug to have the description we retrieved
		String text = HtmlStreamTokenizer.unescape(sb).toString();
		bug.setDescription(text);
	}

	// /**
	// * parses the description of an attachment on the report
	// */
	// private static String parseAttachementDescription(HtmlStreamTokenizer
	// tokenizer) throws IOException,
	// ParseException {
	//
	// StringBuffer sb = new StringBuffer();
	// for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF;
	// token = tokenizer.nextToken()) {
	// if (token.getType() == Token.TAG) {
	// HtmlTag tag = (HtmlTag) token.getValue();
	// if (tag.getTagType() == HtmlTag.Type.A && tag.isEndTag())
	// break;
	// } else if (token.getType() == Token.TEXT) {
	// if (sb.length() > 0) {
	// sb.append(token.getWhitespace());
	// }
	// sb.append((StringBuffer) token.getValue());
	// }
	// }
	//
	// // set the bug to have the description we retrieved
	// String text = HtmlStreamTokenizer.unescape(sb).toString();
	// return text;
	// }

	/**
	 * Parse the case where we have found the start of a comment
	 * 
	 * @param in
	 *            The input stream of the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @return The comment that we have created with the information
	 * @throws IOException
	 * @throws ParseException
	 */
	private static Comment parseCommentHead(BugReport bug, HtmlStreamTokenizer tokenizer) throws IOException,
			ParseException {
		int number = 0;
		Date date = null;
		String author = null;
		String authorName = null;

		// get the comment's number
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.A) {
					String href = tag.getAttribute(ATTRIBUTE_ID_HREF);
					if (href != null) {
						int index = href.toLowerCase().indexOf("#c");
						if (index == -1)
							continue;
						token = tokenizer.nextToken();
						number = Integer.parseInt(((StringBuffer) token.getValue()).toString().substring(1));
						break;
					}
				}
			}
		}

		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.A) {
					String href = tag.getAttribute(ATTRIBUTE_ID_HREF);
					if (href != null) {
						int index = href.toLowerCase().indexOf("mailto");
						if (index == -1)
							continue;
						author = href.substring(index + 7);
						break;
					}
				}
			}
		}

		// get the author's real name
		StringBuffer sb = new StringBuffer();
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.A && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
		authorName = sb.toString();

		// get the comment's date
		sb.setLength(0);
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.I && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
		try {
			if (sb.length() >= 16) {
				date = df.parse(sb.substring(0, 16));
			}
		} catch (Exception e) {
			date = Calendar.getInstance().getTime(); // XXX: could not
			// determine date
		}
		return new Comment(bug, number, date, author, authorName);
	}

	/**
	 * Parse the case where we have comment text
	 * 
	 * @param in
	 *            The input stream for the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @param comment
	 *            The comment to add the text to
	 * @throws IOException
	 */
	private static void parseCommentText(BugReport bug, Comment comment, HtmlStreamTokenizer tokenizer)
			throws IOException, ParseException {

		StringBuffer commentStringBuffer = new StringBuffer();
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagName().equals(TAG_SPAN)) {
					if(tag.hasAttribute(ATTRIBUTE_CLASS) && tag.getAttribute(ATTRIBUTE_CLASS).equals("")) {
						parseAttachment(commentStringBuffer, comment, tokenizer, false);
						continue;
					} else if(tag.hasAttribute(ATTRIBUTE_CLASS) && tag.getAttribute(ATTRIBUTE_CLASS).equals(VALUE_ATTACHMENT_OBSOLETE)) {
						parseAttachment(commentStringBuffer, comment, tokenizer, true);
						continue;
					}
				}
				// added to ensure whitespace is not
				// lost if adding a tag within a tag
				if (commentStringBuffer.length() > 0) {
					commentStringBuffer.append(token.getWhitespace());
				}
				if (tag.getTagType() == HtmlTag.Type.PRE && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (commentStringBuffer.length() > 0) {
					commentStringBuffer.append(token.getWhitespace());
				}
				commentStringBuffer.append((StringBuffer) token.getValue());
			}
			// remove attachment description from comment body
			if (comment.hasAttachment() && commentStringBuffer.indexOf(comment.getAttachmentDescription()) == 0) {
				commentStringBuffer = new StringBuffer();
			}
		}

		HtmlStreamTokenizer.unescape(commentStringBuffer);
		comment.setText(commentStringBuffer.toString());
		bug.addComment(comment);
	}

	private static void parseAttachment(StringBuffer stringBuffer, Comment comment, HtmlStreamTokenizer tokenizer, boolean obsolete)
			throws IOException, ParseException {

		int attachmentID = -1;
		String attachmentDescription = "";
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();

				if (tag.getTagType() == HtmlTag.Type.A && !comment.hasAttachment()) {
					if (tag.getAttribute(ATTRIBUTE_ID_HREF) != null) {
						String link = tag.getAttribute(ATTRIBUTE_ID_HREF);
						if (link.startsWith(ATTACHMENT_CGI_ID)) {
							try {
								int endIndex = link.indexOf("&");
								if (endIndex > 0 && endIndex < link.length()) {
									attachmentID = Integer.parseInt(link
											.substring(ATTACHMENT_CGI_ID.length(), endIndex));
								}
							} catch (NumberFormatException e) {
								return;
							}
						}
						if (tag.getAttribute(ATTRIBUTE_ID_TITLE) != null) {
							attachmentDescription = tag.getAttribute(ATTRIBUTE_ID_TITLE);
						}
						if (attachmentID > 0) {
							comment.setHasAttachment(true);
							comment.setAttachmentId(attachmentID);
							comment.setAttachmentDescription(attachmentDescription);
							comment.setObsolete(obsolete);
						}

					}
				}
				if (tag.getTagName().equals(TAG_SPAN) && tag.isEndTag())
					break;
			}
		}
	}

	/**
	 * Parse the full html version of the bug
	 * 
	 * @param in -
	 *            the input stream for the bug
	 * @param id -
	 *            the id of the bug that is to be parsed
	 * @return A bug report for the bug that was parsed
	 * @throws IOException
	 * @throws ParseException
	 */
	public static BugReport parseBug(Reader in, int id, String serverUrl, boolean is218, String userName,
			String password, String contentType) throws IOException, ParseException, LoginException {
		// create a new bug report and set the parser state to the start state
		BugReport bug = new BugReport(id, serverUrl);
		boolean contentTypeResolved = false;
		if (contentType != null) {
			String charsetFromContentType = getCharsetFromString(contentType);
			if (charsetFromContentType != null) {
				bug.setCharset(charsetFromContentType);
				contentTypeResolved = true;
			}
		}
		ParserState state = ParserState.START;
		Comment comment = null;
		String attribute = null;

		HtmlStreamTokenizer tokenizer = new HtmlStreamTokenizer(in, null);

		boolean isTitle = false;
		boolean possibleBadLogin = false;
		boolean checkBody = false;
		String title = "";
		StringBuffer body = new StringBuffer();

		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {

			// get the charset from the HTML if not specified
			if (!contentTypeResolved) {
				if (token.getType() == Token.TAG && ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.META
						&& !((HtmlTag) (token.getValue())).isEndTag()) {
					String charsetFromHtml = getCharsetFromString(token.toString());
					if (charsetFromHtml != null)
						bug.setCharset(charsetFromHtml);
				}
			}

			// make sure that bugzilla doesn't want us to login
			if (token.getType() == Token.TAG && ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.TITLE
					&& !((HtmlTag) (token.getValue())).isEndTag()) {
				isTitle = true;
				continue;
			}

			if (isTitle) {
				// get all of the data in the title tag
				if (token.getType() != Token.TAG) {
					title += ((StringBuffer) token.getValue()).toString().toLowerCase() + " ";
					continue;
				} else if (token.getType() == Token.TAG
						&& ((HtmlTag) token.getValue()).getTagType() == HtmlTag.Type.TITLE
						&& ((HtmlTag) token.getValue()).isEndTag()) {
					// check and see if the title seems as though we have wrong
					// login info
					if (title.indexOf("login") != -1
							|| (title.indexOf("invalid") != -1 && title.indexOf("password") != -1)
							|| title.indexOf("check e-mail") != -1)
						possibleBadLogin = true; // we possibly have a bad
					// login

					// if the title starts with error, we may have a login
					// problem, or
					// there is a problem with the bug (doesn't exist), so we
					// must do
					// some more checks
					if (title.startsWith("error"))
						checkBody = true;

					isTitle = false;
					title = "";
				}
				continue;
			}

			// if we have to add all of the text so that we can check it later
			// for problems with the username and password
			if (checkBody && token.getType() == Token.TEXT) {
				body.append((StringBuffer) token.getValue());
				body.append(" ");
			}

			// we have found the start of an attribute name
			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD && "right".equalsIgnoreCase(tag.getAttribute("align"))) {
					// parse the attribute's name
					attribute = parseAttributeName(tokenizer);
					if (attribute != null && attribute.contains(IBugzillaConstants.INVALID_2201_ATTRIBUTE_IGNORED)) {
						continue;
					}
					if (attribute.toLowerCase().startsWith("opened")) {
						// find the colon so we can get the date
						int index = attribute.toLowerCase().indexOf(":");
						String date;
						if (index != -1)
							date = attribute.substring(index + 1).trim();
						else
							date = attribute.substring(6).trim();

						// set the bugs opened date to be the date we parsed
						bug.setCreated(df.parse(date));
						state = ParserState.ATT_NAME;
						continue;
					}

					// in 2.18, the last modified looks like the opened so we
					// need to parse it differently
					if (attribute.toLowerCase().startsWith("last modified") && is218) {
						// find the colon so we can get the date
						int index = attribute.toLowerCase().indexOf(":");
						String date;
						if (index != -1)
							date = attribute.substring(index + 1).trim();
						else
							date = attribute.substring(6).trim();

						// create a new attribute and set the date
						Attribute t = new Attribute("Last Modified");
						t.setValue(date);

						// add the attribute to the bug report
						bug.addAttribute(t);
						bug.setLastModified(df.parse(date));
						state = ParserState.ATT_NAME;
						continue;
					}

					state = ParserState.ATT_VALUE;
					continue;
				} else if (tag.getTagType() == HtmlTag.Type.INPUT && "radio".equalsIgnoreCase(tag.getAttribute("type"))
						&& "knob".equalsIgnoreCase(tag.getAttribute(KEY_NAME))) {
					// we found a radio button
					parseOperations(bug, tokenizer, tag, is218);
				}
			}

			// we have found the start of attribute values
			if (state == ParserState.ATT_VALUE && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD) {
					// parse the attribute values
					parseAttributeValue(bug, attribute, tokenizer, serverUrl, userName, password);

					state = ParserState.ATT_NAME;
					attribute = null;
					continue;
				}
			}

			// we have found the start of a comment
			if (state == ParserState.DESC_START && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.I) {
					// parse the comment's start
					comment = parseCommentHead(bug, tokenizer);

					state = ParserState.DESC_VALUE;
					continue;
				}
			}

			// we have found the start of the comment text
			if (state == ParserState.DESC_VALUE && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.PRE) {
					// parse the text of the comment
					parseCommentText(bug, comment, tokenizer);

					comment = null;
					state = ParserState.DESC_START;
					continue;
				}
			}
			
			// last modification date
			if (bug.getCreated() == null && (state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.DIV && tag.getAttribute("id") != null && "header".equalsIgnoreCase(tag.getAttribute("id"))) {
					StringBuffer sb = new StringBuffer();
					parseLastModified(sb, tokenizer);					
					if(sb.length() > 0) {
						int index = sb.indexOf(":");
						String date;
						if (index != -1)
							date = sb.substring(index + 1).trim();
						else
							date = sb.substring(6).trim();

						// create a new attribute and set the date
						Attribute t = new Attribute("Last Modified");
						t.setValue(date);

						// add the attribute to the bug report
						bug.setLastModified(df.parse(date));
						bug.addAttribute(t);
					}
					continue;
				}
			}
			

			// look for date opened field
			if (bug.getCreated() == null && (state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD && tag.getAttribute("align") != null && "left".equalsIgnoreCase(tag.getAttribute("align")) && tag.getAttribute("width") != null && "30%".equals(tag.getAttribute("width"))) {
					StringBuffer sb = new StringBuffer();
					parseDateOpened(sb, tokenizer);					
					if(sb.length() > 0) {
						int index = sb.indexOf(":");
						String date;
						if (index != -1)
							date = sb.substring(index + 1).trim();
						else
							date = sb.substring(6).trim();

						// set the bugs opened date to be the date we parsed
						bug.setCreated(df.parse(date));
					}
					continue;
				}
			}

			// we have found the description of the bug
			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.PRE) {
					// parse the description for the bug
					parseDescription(bug, tokenizer);

					state = ParserState.DESC_START;
					continue;
				}
			}

			// parse hidden fields

			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.INPUT && tag.getAttribute("type") != null
						&& "hidden".equalsIgnoreCase(tag.getAttribute("type").trim())) {

					Attribute a = new Attribute(tag.getAttribute(KEY_NAME));
					a.setParameterName(tag.getAttribute(KEY_NAME));
					a.setValue(tag.getAttribute(KEY_VALUE));
					a.setHidden(true);
					bug.addAttribute(a);
					continue;
				}
			}

			// // parse out attachments
			// if(token.getType() == Token.TAG) {
			// HtmlTag tag = (HtmlTag) token.getValue();
			// if(tag.getTagType() == HtmlTag.Type.A && tag.getAttribute("href")
			// != null) {
			// String link = tag.getAttribute("href");
			// if(link.startsWith("attachment.cgi?id=") &&
			// !link.contains("action")) {
			// int attachmentID = Integer.parseInt(link.substring(18));
			// String description = parseAttachementDescription(tokenizer);
			// bug.addAttachment(attachmentID, description);
			// }
			// }
			// }

		}

		// if we are to check the body, make sure that there wasn't a bad login
		if (checkBody) {
			String b = body.toString();
			if (b.indexOf("login") != -1
					|| ((b.indexOf("invalid") != -1 || b.indexOf("not valid") != -1) && b.indexOf("password") != -1)
					|| b.indexOf("check e-mail") != -1)
				possibleBadLogin = true; // we possibly have a bad login
		}

		// if there is no summary or created date, we expect that
		// the bug doesn't exist, so set it to null

		// if the bug seems like it doesn't exist, and we suspect a login
		// problem, assume that there was a login problem
		if (bug.getCreated() == null && bug.getAttributes().isEmpty()) {
			if (possibleBadLogin) {
				throw new LoginException(IBugzillaConstants.MESSAGE_LOGIN_FAILURE);
			} else {
				return null;
			}
		}
		// we are done...return the bug
		return bug;
	}

	private static void parseDateOpened(StringBuffer sb, HtmlStreamTokenizer tokenizer) throws IOException, ParseException {
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
		
	}
	
	private static void parseLastModified(StringBuffer sb, HtmlStreamTokenizer tokenizer) throws IOException, ParseException {
		boolean inH3 = false;
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();				
				if (tag.getTagType() == HtmlTag.Type.H3 && !tag.isEndTag()) {
					inH3 = true;
					continue;
				} else if (tag.getTagType() == HtmlTag.Type.DIV && tag.isEndTag()) {
					break;
				}
			} else if (token.getType() == Token.TEXT && inH3) {
				if (sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
		
	}

	public static String getCharsetFromString(String string) {
		int charsetStartIndex = string.indexOf(ATTR_CHARSET);
		if (charsetStartIndex != -1) {
			int charsetEndIndex = string.indexOf("\"", charsetStartIndex); // TODO:
			// could
			// be
			// space
			// after?
			if (charsetEndIndex == -1) {
				charsetEndIndex = string.length();
			}
			String charsetString = string.substring(charsetStartIndex + 8, charsetEndIndex);
			if (Charset.availableCharsets().containsKey(charsetString)) {
				return charsetString;
			}
		}
		return null;
	}

	/**
	 * Parse the operations that are allowed on the bug (Assign, Re-open, fix)
	 * 
	 * @param bug
	 *            The bug to add the operations to
	 * @param tokenizer
	 *            The stream tokenizer for the bug
	 * @param tag
	 *            The last tag that we were on
	 */
	private static void parseOperations(BugReport bug, HtmlStreamTokenizer tokenizer, HtmlTag tag, boolean is218)
			throws ParseException, IOException {

		String knobName = tag.getAttribute(KEY_VALUE);
		boolean isChecked = false;
		if (tag.getAttribute("checked") != null && tag.getAttribute("checked").equals("checked"))
			isChecked = true;
		StringBuffer sb = new StringBuffer();

		Token lastTag = null;

		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				tag = (HtmlTag) token.getValue();

				if (!(tag.getTagType() == HtmlTag.Type.A || tag.getTagType() == HtmlTag.Type.B
						|| tag.getTagType() == HtmlTag.Type.STRONG || tag.getTagType() == HtmlTag.Type.LABEL)) {
					lastTag = token;
					break;
				} else {

					if (is218 && tag.getTagType() == HtmlTag.Type.LABEL) {
						continue;
					} else if (tag.getTagType() == HtmlTag.Type.A || tag.getTagType() == HtmlTag.Type.B
							|| tag.getTagType() == HtmlTag.Type.STRONG) {
						sb.append(tag.toString().trim() + " ");
					} else {
						break;
					}
				}
			} else if (token.getType() == Token.TEXT && !token.toString().trim().equals("\n"))
				sb.append(token.toString().trim() + " ");
		}

		String displayName = HtmlStreamTokenizer.unescape(sb).toString();
		Operation o = new Operation(knobName, displayName);
		o.setChecked(isChecked);

		if (lastTag != null) {
			tag = (HtmlTag) lastTag.getValue();
			if (tag.getTagType() != HtmlTag.Type.SELECT) {
				tokenizer.pushback(lastTag);
				if (tag.getTagType() == HtmlTag.Type.INPUT
						&& !("radio".equalsIgnoreCase(tag.getAttribute("type")) && "knob".equalsIgnoreCase(tag
								.getAttribute(KEY_NAME)))) {
					o.setInputName(((HtmlTag) lastTag.getValue()).getAttribute(KEY_NAME));
					o.setInputValue(((HtmlTag) lastTag.getValue()).getAttribute(KEY_VALUE));
				}
			} else {
				Token token = tokenizer.nextToken();
				// parse the options

				tag = (HtmlTag) token.getValue();
				o.setUpOptions(((HtmlTag) lastTag.getValue()).getAttribute(KEY_NAME));

				while (token.getType() != Token.EOF) {
					if (token.getType() == Token.TAG) {
						tag = (HtmlTag) token.getValue();
						if (tag.getTagType() == HtmlTag.Type.SELECT && tag.isEndTag())
							break;
						if (tag.getTagType() == HtmlTag.Type.OPTION && !tag.isEndTag()) {
							String optionName = tag.getAttribute(KEY_VALUE);
							StringBuffer optionText = new StringBuffer();
							for (token = tokenizer.nextToken(); token.getType() == Token.TEXT; token = tokenizer
									.nextToken()) {
								if (optionText.length() > 0) {
									optionText.append(' ');
								}
								optionText.append((StringBuffer) token.getValue());
							}
							o.addOption(optionText.toString(), optionName);
						} else {
							token = tokenizer.nextToken();
						}
					} else {
						token = tokenizer.nextToken();
					}
				}
			}
		}

		bug.addOperation(o);
	}

	/**
	 * Enum class for describing current state of Bugzilla report parser.
	 */
	private static class ParserState {
		/** An instance of the start state */
		protected static final ParserState START = new ParserState("start");

		/** An instance of the state when the parser found an attribute name */
		protected static final ParserState ATT_NAME = new ParserState("att_name");

		/** An instance of the state when the parser found an attribute value */
		protected static final ParserState ATT_VALUE = new ParserState("att_value");

		/** An instance of the state when the parser found a description */
		protected static final ParserState DESC_START = new ParserState("desc_start");

		/** An instance of the state when the parser found a description value */
		protected static final ParserState DESC_VALUE = new ParserState("desc_value");

		/** State's human-readable name */
		private String name;

		/**
		 * Constructor
		 * 
		 * @param description -
		 *            The states human readable name
		 */
		private ParserState(String description) {
			this.name = description;
		}

		@Override
		public String toString() {
			return name;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.bugzilla.core.internal;

/**
 * Bugzilla XML element enum. Each enum has the field name
 * and associated xml element tag name.
 * 
 * @author Rob Elves
 */
public enum BugReportElement {
	
	// Format: ENUM ( "pretty name", "xml key" )
	
	BUGZILLA ("bugzilla", "bugzilla"),
	BUG ("bug","bug"),
	BUG_ID ("Bug", "bug_id"),
	CREATION_TS ("Creation Date", "creation_ts"),
	SHORT_DESC ("Summary", "short_desc"),
	DELTA_TS ("Last Modification", "delta_ts"),
	REPORTER_ACCESSIBLE ("reporter_accessible", "reporter_accessible"),
	CCLIST_ACCESSIBLE ("cclist_accessible", "cclist_accessible"),
	CLASSIFICATION_ID ("Classification ID", "classification_id"),
	CLASSIFICATION ("Classification", "classification"),
	PRODUCT ("Product", "product"),
	COMPONENT ("Component", "component"),
	VERSION ("Version", "version"),
	REP_PLATFORM ("Platform", "rep_platform"),
	OP_SYS ("OS", "op_sys"),
	BUG_STATUS ("Status", "bug_status"),
	PRIORITY ("Priority", "priority"),
	BUG_SEVERITY ("Severity", "bug_severity"),
	TARGET_MILESTONE ("Target Milestone", "target_milestone"), 
	EVERCONFIRMED ("everconfirmed", "everconfirmed"), 
	REPORTER ("Reporter", "reporter"), 
	ASSIGNED_TO ("Assigned To", "assigned_to"), 
	CC ("CC", "cc"), 
	LONG_DESC ("Description", "long_desc"),
	WHO ("who", "who"),
	BUG_WHEN ("bug_when", "bug_when"), 
	THETEXT ("thetext", "thetext"), 
	ATTACHMENT ("attachment", "attachment"), 
	ATTACHID ("attachid", "attachid"), 
	DATE ("Date", "date"), 
	DESC ("desc", "desc"), 
	FILENAME ("filename", "filename"), 
	TYPE ("type", "type"), 
	DATA ("data", "data"),
	BUG_FILE_LOC ("URL", "bug_file_loc"),
	UNKNOWN ("UNKNOWN", "UNKNOWN");
	
	private final String prettyName;
	private final String keyString;

	BugReportElement(String prettyName, String fieldName) {		
		this.prettyName = prettyName;
		keyString = fieldName;
	}

	public String getKeyString() {
		return keyString;
	}

	public String toString() {
		return prettyName;
	}

//	public BugReportElementTag fromString(String str) {
//		for (BugReportElementTag tag : BugReportElementTag.values()) {
//			if (tag.toString().equals(str)) {
//				return tag;
//			}
//		}
//		return UNKNOWN;
//	}
}




import org.eclipse.compare.ITypedElement;
import org.eclipse.compare.structuremergeviewer.IStructureComparator;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.ISharedImages;

	 *            The <code>BugReport</code> that needs parsing.
	 * @return The tree of <code>BugzillaCompareNode</code>'s.
	 */
	public static BugzillaCompareNode parseBugReport(BugzillaReport bug) {
		Image defaultImage = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_DEF_VIEW);
		BugzillaCompareNode topNode = new BugzillaCompareNode("Bug #" + bug.getId(), null, defaultImage);
		Date creationDate = bug.getCreated();


		Image attributeImage = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT);
		BugzillaCompareNode attributes = new BugzillaCompareNode("Attributes", null, attributeImage);
		for (Iterator<AbstractRepositoryReportAttribute> iter = bug.getAttributes().iterator(); iter.hasNext();) {
			AbstractRepositoryReportAttribute attribute = iter.next();
			if (attribute.getName().compareTo("delta_ts") == 0 || attribute.getName().compareTo("Last Modified") == 0
					|| attribute.getName().compareTo("longdesclength") == 0)
				continue;

			// attribute's new
			// value, which is what is in the submit viewer.
			
			attributes.addChild(new BugzillaCompareNode(attribute.getName(), attribute.getValue(), attributeImage));
		}
		topNode.addChild(attributes);


		BugzillaCompareNode comments = new BugzillaCompareNode("Comments", null, defaultImage);
		for (Iterator<Comment> iter = bug.getComments().iterator(); iter.hasNext();) {
			Comment comment = iter.next();
			String bodyString = "Comment from " + comment.getAuthorName() + ":\n\n" + comment.getText();			
			comments.addChild(new BugzillaCompareNode(comment.getCreated().toString(), bodyString, defaultImage));
		}
		topNode.addChild(comments);

		topNode.addChild(new BugzillaCompareNode("New Comment", bug.getNewComment(), defaultImage));

		BugzillaCompareNode ccList = new BugzillaCompareNode("CC List", null, defaultImage);
		for (Iterator<String> iter = bug.getCC().iterator(); iter.hasNext();) {




import org.eclipse.compare.structuremergeviewer.Differencer;
import org.eclipse.compare.structuremergeviewer.IStructureComparator;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;

/**
 * A two-way or three-way compare for <code>BugReport</code> objects.

	 * @param newAncestor
	 *            The new original object.
	 */
	public void setAncestor(BugzillaReport newAncestor) {
		threeWay = (newAncestor != null);
		BugzillaStructureCreator structureCreator = new BugzillaStructureCreator();
		ancestor = structureCreator.getStructure(newAncestor);

	 * @param newLeft
	 *            The new local object.
	 */
	public void setLeft(BugzillaReport newLeft) {
		BugzillaStructureCreator structureCreator = new BugzillaStructureCreator();
		left = structureCreator.getStructure(newLeft);
	}

	 * @param newRight
	 *            The new online object.
	 */
	public void setRight(BugzillaReport newRight) {
		BugzillaStructureCreator structureCreator = new BugzillaStructureCreator();
		right = structureCreator.getStructure(newRight);
	}

Lines 14-20 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/core/compare/BugzillaStructureCreator.java (-3 / +3 lines)
14	import org.eclipse.compare.structuremergeviewer.IStructureComparator;	14	import org.eclipse.compare.structuremergeviewer.IStructureComparator;
15	import org.eclipse.compare.structuremergeviewer.IStructureCreator;	15	import org.eclipse.compare.structuremergeviewer.IStructureCreator;
16	import org.eclipse.jface.util.Assert;	16	import org.eclipse.jface.util.Assert;
17	import org.eclipse.mylar.bugzilla.core.BugReport;	17	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
18		18
19	/**	19	/**
20	* This implementation of the <code>IStructureCreator</code> interface makes	20	* This implementation of the <code>IStructureCreator</code> interface makes
Lines 38-45 Link Here
38	}	38	}
39		39
40	public IStructureComparator getStructure(Object input) {	40	public IStructureComparator getStructure(Object input) {
41	if (input instanceof BugReport) {	41	if (input instanceof BugzillaReport) {
42	BugReport bugReport = (BugReport) input;	42	BugzillaReport bugReport = (BugzillaReport) input;
43	return BugzillaCompareNode.parseBugReport(bugReport);	43	return BugzillaCompareNode.parseBugReport(bugReport);
44	} else {	44	} else {
45	return null;	45	return null;




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.internal.bugzilla.core;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.mylar.bugzilla.core.Attribute;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;

/**
 * This class is used to store data about the new bug that is being created
 * while the wizard is being used
 * 
 * @author Eric Booth
 */
public class NewBugModel implements Serializable, IBugzillaBug {

	/** Automatically generated serialVersionUID */
	private static final long serialVersionUID = 3977859587934335283L;

	/** Whether the attributes have been parsed yet or not */
	protected boolean hasParsedAttributes = false;

	/** Whether the products have been parsed yet or not */
	protected boolean hasParsedProducts = false;

	/** The bug's id */
	protected final int id;

	/** The product that the bug is for */
	protected String product;

	/** A list of the attributes that can be changed for the new bug */
	public Map<String, Attribute> attributes = new LinkedHashMap<String, Attribute>();

	/** The summary for the bug */
	protected String summary = "";

	/** The description for the bug */
	protected String description = "";
	
	/**
	 * Flag to indicate status of connection to Bugzilla server to identify
	 * whether ProductConfiguration should be used instead
	 */
	protected boolean connected = true;

	/** Whether or not this bug report is saved offline. */
	protected boolean savedOffline = false;

	/**
	 * Creates a new <code>NewBugModel</code>. The id chosen for this bug is
	 * based on the id of the last <code>NewBugModel</code> that was created.
	 */
	public NewBugModel() {
		super();
		id = BugzillaPlugin.getDefault().getOfflineReports().getNextOfflineBugId();
	}

	public Attribute getAttribute(String key) {
		return attributes.get(key);
	}

	/**
	 * Get the list of attributes for this model
	 * 
	 * @return An <code>ArrayList</code> of the models attributes
	 */
	public List<Attribute> getAttributes() {
		// create an array list to store the attributes in
		ArrayList<Attribute> attributeEntries = new ArrayList<Attribute>(attributes.keySet().size());

		// go through each of the attribute keys
		for (Iterator<String> it = attributes.keySet().iterator(); it.hasNext();) {
			// get the key for the attribute
			String key = it.next();

			// get the attribute and add it to the list
			Attribute attribute = attributes.get(key);
			attributeEntries.add(attribute);
		}

		// return the list of attributes for the bug
		return attributeEntries;
	}

	public int getId() {
		return id;
	}

	public String getRepositoryUrl() {
		return BugzillaTools.OFFLINE_SERVER_DEFAULT;
	}

	public String getLabel() {
		return "New Bug #" + id;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String newDescription) {
		description = newDescription;
	}

	public String getSummary() {
		return summary;
	}

	public void setSummary(String newSummary) {
		summary = newSummary;
	}

	/**
	 * @return The product that the bug is for.
	 */
	public String getProduct() {
		return product;
	}

	/**
	 * Sets the product that the bug is for.
	 * 
	 * @param product
	 *            The product.
	 */
	public void setProduct(String product) {
		this.product = product;
	}

	/**
	 * @return Flag to indicate status of connection to Bugzilla server (to
	 *         identify whether ProductConfiguration should be used instead)
	 */
	public boolean isConnected() {
		return connected;
	}

	/**
	 * Sets the value of the flag to indicate status of connection to Bugzilla
	 * server (to identify whether ProductConfiguration should be used instead)
	 * 
	 * @param newConnectionStatus
	 *            <code>true</code> if the bug is connected.
	 */
	public void setConnected(boolean newConnectionStatus) {
		connected = newConnectionStatus;
	}

	/**
	 * @return Returns whether the attributes have been parsed yet or not.
	 */
	public boolean hasParsedAttributes() {
		return hasParsedAttributes;
	}

	/**
	 * Sets whether the attributes have been parsed yet or not.
	 * 
	 * @param hasParsedAttributes
	 *            <code>true</code> if the attributes have been parsed.
	 */
	public void setParsedAttributesStatus(boolean hasParsedAttributes) {
		this.hasParsedAttributes = hasParsedAttributes;
	}

	/**
	 * @return Returns whether the products have been parsed yet or not.
	 */
	public boolean hasParsedProducts() {
		return hasParsedProducts;
	}

	/**
	 * Sets whether the products have been parsed yet or not.
	 * 
	 * @param hasParsedProducts
	 *            <code>true</code> if the products have been parsed.
	 */
	public void setParsedProductsStatus(boolean hasParsedProducts) {
		this.hasParsedProducts = hasParsedProducts;
	}

	public boolean isSavedOffline() {
		return savedOffline;
	}

	public boolean isLocallyCreated() {
		return true;
	}

	public void setOfflineState(boolean newOfflineState) {
		savedOffline = newOfflineState;
	}

	public boolean hasChanges() {
		return true;
	}

	/** returns null */
	public Date getCreated() {		
		return null;
	}

	public Date getLastModified() {
		return null;
	}

}

Lines 58-66 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/core/IBugzillaConstants.java (-4 / +26 lines)
58	static final String HIT_MARKER_ATTR_OWNER = "owner";	58	static final String HIT_MARKER_ATTR_OWNER = "owner";
59		59
60	static final String HIT_MARKER_ATTR_QUERY = "query";	60	static final String HIT_MARKER_ATTR_QUERY = "query";
		61
61		62
62	// Error code	63
63	static final int ERROR_CODE = 1;	64	// Error response from bugzilla server upon bug request
		65	static final String ERROR_INVALID_BUG_ID = "InvalidBugId";
		66	static final String ERROR_INVALID_USERNAME_OR_PASSWORD = "Invalid Username Or Password";
		67	// static final int ERROR_CODE = 1;
64		68
65	// Bugzilla Preferences keys	69	// Bugzilla Preferences keys
66	// static final String BUGZILLA_SERVER = "BUGZILLA_SERVER";	70	// static final String BUGZILLA_SERVER = "BUGZILLA_SERVER";
Lines 146-153 Link Here
146		150
147	static final String[] DEFAULT_PRESELECTED_STATUS_VALUES = { "New", "Assigned", "Reopened" };	151	static final String[] DEFAULT_PRESELECTED_STATUS_VALUES = { "New", "Assigned", "Reopened" };
148		152
149	static final String[] DEFAULT_RESOLUTION_VALUES = { "Fixed", "Invalid", "Wontfix", "Later", "Remind", "Duplicate",	153	// static final String[] DEFAULT_RESOLUTION_VALUES = { "Fixed", "Invalid",
150	"Worksforme", "Moved" };	154	// "Wontfix", "Later", "Remind", "Duplicate",
		155	// "Worksforme", "Moved" };
151		156
152	static final String[] DEFAULT_SEVERITY_VALUES = { "blocker", "critical", "major", "normal", "minor", "trivial",	157	static final String[] DEFAULT_SEVERITY_VALUES = { "blocker", "critical", "major", "normal", "minor", "trivial",
153	"enhancement" };	158	"enhancement" };
Lines 176-179 Link Here
176		181
177	public static final String INVALID_2201_ATTRIBUTE_IGNORED = "EclipsebugsBugzilla2.20.1";	182	public static final String INVALID_2201_ATTRIBUTE_IGNORED = "EclipsebugsBugzilla2.20.1";
178		183
		184	public static final String VALUE_STATUS_RESOLVED = "RESOLVED";
		185	public static final String VALUE_STATUS_NEW = "NEW";
		186	public static final String VALUE_STATUS_CLOSED = "CLOSED";
		187	public static final String VALUE_STATUS_ASSIGNED = "ASSIGNED";
		188	public static final String VALUE_RESOLUTION_LATER = "LATER";
		189
		190	public static enum BUGZILLA_OPERATION {
		191	none, accept, resolve, duplicate, reassign, reassignbycomponent, reopen, verify, close;
		192	}
		193
		194	public static enum BUGZILLA_REPORT_STATUS {
		195	UNCONFIRMED, NEW, ASSIGNED, REOPENED, RESOLVED, VERIFIED, CLOSED;
		196	}
		197
		198	public static enum BUGZILLA_RESOLUTION {
		199	FIXED, INVALID, WONTFIX, LATER, REMIND, WORKSFORME;
		200	}
179	}	201	}




import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;

import javax.security.auth.login.LoginException;

import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.BugzillaReportAttribute;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
import org.eclipse.mylar.bugzilla.core.Operation;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants.BUGZILLA_OPERATION;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants.BUGZILLA_REPORT_STATUS;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants.BUGZILLA_RESOLUTION;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.mylar.internal.bugzilla.core.internal.OfflineReportsFile;
import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryConfiguration;
import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryConfigurationFactory;
import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryReportFactory;
import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
import org.eclipse.mylar.internal.core.util.ZipFileUtil;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;


/**
 * @author Mik Kersten (some rewriting)
 * @author Rob Elves
 */
public class BugzillaRepositoryUtil {

	private static final String ATTR_CHARSET = "charset";
	
	private static final String OPERATION_INPUT_ASSIGNED_TO = "assigned_to";

	private static final String OPERATION_INPUT_DUP_ID = "dup_id";

	private static final String OPERATION_OPTION_RESOLUTION = "resolution";

	private static final String OPERATION_LABEL_CLOSE = "Mark bug as CLOSED";

	private static final String OPERATION_LABEL_VERIFY = "Mark bug as VERIFIED";

	private static final String OPERATION_LABEL_REOPEN = "Reopen bug";

	private static final String OPERATION_LABEL_REASSIGN_DEFAULT = "Reassign bug to default assignee of selected component";

	private static final String OPERATION_LABEL_REASSIGN = "Reassign bug to";

	private static final String OPERATION_LABEL_DUPLICATE = "Resolve bug, mark it as duplicate of bug #";

	private static final String OPERATION_LABEL_RESOLVE = "Resolve bug, changing resolution to";

	private static final String OPERATION_LABEL_ACCEPT = "Accept bug (change status to ASSIGNED)";

	private static final String BUG_STATUS_NEW = "NEW";

	private static final String ATTACHMENT_DOWNLOAD_FAILED = "Attachment download FAILED.";

	private static final String VALUE_CONTENTTYPEMETHOD_MANUAL = "manual";

	private static final String VALUE_ISPATCH = "1";


	private static final String POST_ARGS_LOGIN = "GoAheadAndLogIn=1&Bugzilla_login=";

	// public static BugReport getBug(String repositoryUrl, int id) throws
	// IOException, MalformedURLException,
	// LoginException {
	//
	// BufferedReader in = null;
	// try {
	//
	// // create a new input stream for getting the bug
	// TaskRepository repository =
	// MylarTaskListPlugin.getRepositoryManager().getRepository(
	// BugzillaPlugin.REPOSITORY_KIND, repositoryUrl);
	// if (repository == null) {
	// PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
	// public void run() {
	// MessageDialog.openInformation(Display.getDefault().getActiveShell(),
	// IBugzillaConstants.TITLE_MESSAGE_DIALOG,
	// TaskRepositoryManager.MESSAGE_NO_REPOSITORY);
	// }
	// });
	// return null;
	// }
	//
	// String url = repositoryUrl + POST_ARGS_SHOW_BUG + id;
	//
	// url = addCredentials(repository, url);
	//
	// URL bugUrl = new URL(url);
	// URLConnection connection =
	// BugzillaPlugin.getDefault().getUrlConnection(bugUrl);
	// if (connection != null) {
	// InputStream input = connection.getInputStream();
	// if (input != null) {
	// in = new BufferedReader(new InputStreamReader(input));
	// // BugReport bugReport = new BugReport(id,
	// // repository.getUrl());
	// // setupExistingBugAttributes2(repository.getUrl(),
	// // bugReport);
	// RepositoryReportFactory reportFactory =
	// RepositoryReportFactory.getInstance();
	// AbstractRepositoryReport report = reportFactory.readReport(id,
	// repository);
	//
	// BugReport bugReport = null;
	// if (report != null && report instanceof BugReport) {
	// bugReport = (BugReport) report;
	// setupExistingBugAttributes(repository.getUrl(), bugReport);
	// addValidOperations(bugReport);
	// return bugReport;
	// }
	// // get the actual bug from the server and return it
	// // BugReport bugReport = BugParser.parseBug(in, id,
	// // repository.getUrl(), true, repository.getUserName(),
	// // repository
	// // .getPassword(), connection.getContentType());
	// // return bugReport;
	// }
	// }
	// // TODO handle the error
	// return null;
	// } catch (MalformedURLException e) {
	// throw e;
	// } catch (IOException e) {
	// throw e;
	// } catch (LoginException e) {
	// throw e;
	// } catch (Exception e) {
	// // BugzillaPlugin.log(new Status(IStatus.ERROR,
	// // IBugzillaConstants.PLUGIN_ID, IStatus.ERROR,
	// // "Problem getting report:\n"+e.getMessage(), e));
	// MylarStatusHandler.fail(e, "Problem getting report:\n" + e.getMessage(),
	// false);
	// return null;
	// } finally {
	// try {
	// if (in != null)
	// in.close();
	// } catch (IOException e) {
	// BugzillaPlugin.log(new Status(IStatus.ERROR,
	// IBugzillaConstants.PLUGIN_ID, IStatus.ERROR,
	// "Problem closing the stream", e));
	// }
	// }
	// }

	public static BugzillaReport getBug(String repositoryUrl, int id) throws IOException, MalformedURLException,
			LoginException {

		BufferedReader in = null;


			String url = repositoryUrl + POST_ARGS_SHOW_BUG + id;

			url = addCredentials(repository, url);
				url += "&" + POST_ARGS_LOGIN
						+ URLEncoder.encode(repository.getUserName(), BugzillaPlugin.ENCODING_UTF_8)
						+ POST_ARGS_PASSWORD
						+ URLEncoder.encode(repository.getPassword(), BugzillaPlugin.ENCODING_UTF_8);
			}

			URL bugUrl = new URL(url);
			URLConnection connection = BugzillaPlugin.getDefault().getUrlConnection(bugUrl);

				InputStream input = connection.getInputStream();
				if (input != null) {
					in = new BufferedReader(new InputStreamReader(input));
					BugzillaReport bugReport = new BugzillaReport(id, repository.getUrl());

					setupExistingBugAttributes(repository.getUrl(), bugReport);

					RepositoryReportFactory reportFactory = RepositoryReportFactory.getInstance();
					reportFactory.populateReport(bugReport, repository);
					updateBugAttributeOptions(repository, bugReport);
					addValidOperations(bugReport);

					// BugReportFactory reportFactory =
					// BugReportFactory.getInstance();
					// BugReport bugReport = reportFactory.readReport(in, id,
					// repository, connection.getContentType());
					// get the actual bug from the server and return it
					BugReport bugReport = BugParser.parseBug(in, id, repository.getUrl(), true, repository.getUserName(), repository
							.getPassword(), connection.getContentType());
					return bugReport;

				}
			}
			// TODO handle the error

		} catch (LoginException e) {
			throw e;
		} catch (Exception e) {
			// BugzillaPlugin.log(new Status(IStatus.ERROR,
			// IBugzillaConstants.PLUGIN_ID, IStatus.ERROR,
			// "Problem getting report:\n"+e.getMessage(), e));
			MylarStatusHandler.fail(e, "Problem getting report:\n" + e.getMessage(), false);
			return null;
		} finally {
			try {

		}
	}

	public static String addCredentials(TaskRepository repository, String url) throws UnsupportedEncodingException {
		if (repository.hasCredentials()) {
			url += "&" + POST_ARGS_LOGIN + URLEncoder.encode(repository.getUserName(), BugzillaPlugin.ENCODING_UTF_8)
					+ POST_ARGS_PASSWORD + URLEncoder.encode(repository.getPassword(), BugzillaPlugin.ENCODING_UTF_8);
		}
		return url;
	}

	/**
	 * Get a bug from the server. If a bug with the given id is saved offline,
	 * the offline version is returned instead.

	 * @throws IOException,
	 *             MalformedURLException, LoginException
	 */
	public static BugzillaReport getCurrentBug(String repositoryUrl, int id) throws MalformedURLException, LoginException,
			IOException {
		// Look among the offline reports for a bug with the given id.
		OfflineReportsFile reportsFile = BugzillaPlugin.getDefault().getOfflineReports();

		// If an offline bug was found, return it if possible.
		if (offlineId != -1) {
			IBugzillaBug bug = reportsFile.elements().get(offlineId);
			if (bug instanceof BugzillaReport) {
				return (BugzillaReport) bug;
			}
		}


	 */
	public static List<String> getProductList(TaskRepository repository) throws IOException, LoginException, Exception {

		return BugzillaPlugin.getDefault().getProductConfiguration(repository).getProducts();

		// BugzillaQueryPageParser parser = new
		// BugzillaQueryPageParser(repository, new NullProgressMonitor());


	}

//	public static List<String> getValidKeywords(String repositoryURL) {
//		return BugzillaPlugin.getDefault().getProductConfiguration(repositoryURL).getKeywords();
//	}

	// /**
	// * Get the attribute values for a new bug
	// *

	// } catch (IOException e) {
	// BugzillaPlugin.log(new Status(IStatus.ERROR,
	// IBugzillaConstants.PLUGIN_ID, IStatus.ERROR,
	// "Problem closing the stream", e));
	// }
	// }
	// }

	/**
	 * Adds bug attributes to new bug model and sets defaults
	 */
	public static void setupNewBugAttributes(TaskRepository repository, NewBugzillaReport newReport) {

		// // order is important
		// BugReportElement[] newBugElements = { BugReportElement.PRODUCT,
		// BugReportElement.BUG_STATUS,
		// BugReportElement.VERSION,
		// BugReportElement.COMPONENT,
		// BugReportElement.TARGET_MILESTONE,
		// BugReportElement.REP_PLATFORM,
		// BugReportElement.OP_SYS,
		// BugReportElement.PRIORITY,
		// BugReportElement.BUG_SEVERITY,
		// BugReportElement.ASSIGNED_TO,
		// // NOT USED BugReportElement.CC,
		// BugReportElement.BUG_FILE_LOC,
		// //NOT USED BugReportElement.SHORT_DESC,
		// //NOT USED BugReportElement.LONG_DESC
		// };

		// HashMap<String, AbstractRepositoryReportAttribute> attributes = new
		// LinkedHashMap<String, AbstractRepositoryReportAttribute>();

		AbstractRepositoryReportAttribute a = new BugzillaReportAttribute(BugzillaReportElement.PRODUCT);
		List<String> optionValues = BugzillaPlugin.getDefault().getProductConfiguration(repository).getProducts();
//				BugReportElement.TARGET_MILESTONE,
//				BugReportElement.REP_PLATFORM,				
//				BugReportElement.OP_SYS,
//				BugReportElement.PRIORITY,
//				BugReportElement.BUG_SEVERITY,
//				BugReportElement.ASSIGNED_TO,
//// NOT USED	BugReportElement.CC,
//				BugReportElement.BUG_FILE_LOC,
// //NOT USED		BugReportElement.SHORT_DESC,
// //NOT USED		BugReportElement.LONG_DESC
//		};

				
		
		
		HashMap<String, Attribute> attributes = new LinkedHashMap<String, Attribute>();

		Attribute a = new Attribute(BugReportElement.PRODUCT.toString());
		a.setParameterName(BugReportElement.PRODUCT.getKeyString());
		List<String> optionValues = BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getProducts();
		for (String option : optionValues) {
			a.addOptionValue(option, option);
		}
		a.setValue(newReport.getProduct());
		newReport.addAttribute(BugzillaReportElement.PRODUCT, a);
		// attributes.put(a.getName(), a);

		a = new BugzillaReportAttribute(BugzillaReportElement.BUG_STATUS);
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(repository).getStatusValues();
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getStatusValues();
		for (String option : optionValues) {
			a.addOptionValue(option, option);
		}
		a.setValue(BUG_STATUS_NEW);
		newReport.addAttribute(BugzillaReportElement.BUG_STATUS, a);
		// attributes.put(a.getName(), a);

		a = new BugzillaReportAttribute(BugzillaReportElement.VERSION);
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(repository).getVersions(
				newReport.getProduct());
		for (String option : optionValues) {
			a.addOptionValue(option, option);
		}
		if (optionValues != null && optionValues.size() > 0) {
			a.setValue(optionValues.get(optionValues.size() - 1));
		
		a = new Attribute(BugReportElement.COMPONENT.toString());
		a.setParameterName(BugReportElement.COMPONENT.getKeyString());
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getComponents(model.getProduct());
		for (String option : optionValues) {
			a.addOptionValue(option, option);
		}
		newReport.addAttribute(BugzillaReportElement.VERSION, a);
		// attributes.put(a.getName(), a);

		a = new BugzillaReportAttribute(BugzillaReportElement.COMPONENT);
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(repository).getComponents(
				newReport.getProduct());
		for (String option : optionValues) {
			a.addOptionValue(option, option);
		}
		newReport.addAttribute(BugzillaReportElement.COMPONENT, a);

		a = new BugzillaReportAttribute(BugzillaReportElement.REP_PLATFORM);
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(repository).getPlatforms();
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getOSs();
		for (String option : optionValues) {
			a.addOptionValue(option, option);
		}
		newReport.addAttribute(BugzillaReportElement.REP_PLATFORM, a);
		// attributes.put(a.getName(), a);

		a = new BugzillaReportAttribute(BugzillaReportElement.OP_SYS);
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(repository).getOSs();
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getPriorities();
		for (String option : optionValues) {
			a.addOptionValue(option, option);
		}
		newReport.addAttribute(BugzillaReportElement.OP_SYS, a);
		// attributes.put(a.getName(), a);

		a = new BugzillaReportAttribute(BugzillaReportElement.PRIORITY);
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(repository).getPriorities();
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getSeverities();
		for (String option : optionValues) {
			a.addOptionValue(option, option);
		}
		a.setValue(optionValues.get((optionValues.size() / 2)));
		newReport.addAttribute(BugzillaReportElement.PRIORITY, a);
		// attributes.put(a.getName(), a);

		a = new BugzillaReportAttribute(BugzillaReportElement.BUG_SEVERITY);
		optionValues = BugzillaPlugin.getDefault().getProductConfiguration(repository).getSeverities();
		for (String option : optionValues) {
			a.addOptionValue(option, option);
		}
		a.setValue(optionValues.get((optionValues.size() / 2)));
		newReport.addAttribute(BugzillaReportElement.BUG_SEVERITY, a);
		// attributes.put(a.getName(), a);

		// a = new
		// BugzillaReportAttribute(BugzillaReportElement.TARGET_MILESTONE);
		// optionValues =
		// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getTargetMilestones(
		// newReport.getProduct());
		// for (String option : optionValues) {
		// a.addOptionValue(option, option);
		// }
		// if(optionValues.size() > 0) {
		// // new bug posts will fail if target_milestone element is included
		// // and there are no milestones on the server
		// newReport.addAttribute(BugzillaReportElement.TARGET_MILESTONE, a);
		// }

		a = new BugzillaReportAttribute(BugzillaReportElement.ASSIGNED_TO);
		a.setParameterName(BugReportElement.ASSIGNED_TO.getKeyString());
		a.setValue("");
		newReport.addAttribute(BugzillaReportElement.ASSIGNED_TO, a);
		// attributes.put(a.getName(), a);

		a = new BugzillaReportAttribute(BugzillaReportElement.BUG_FILE_LOC);
		a.setValue("http://");
		a.setHidden(false);
		newReport.addAttribute(BugzillaReportElement.BUG_FILE_LOC, a);
		// attributes.put(a.getName(), a);

		// newReport.attributes = attributes;
	}

	// /**
	// * Adds bug attributes to new bug model and sets defaults
	// */
	// public static void setupExistingBugAttributes(String serverUrl, BugReport
	// existingReport) {
	//
	// // // order is important
	// // BugReportElement[] newBugElements = { BugReportElement.PRODUCT,
	// // BugReportElement.BUG_STATUS,
	// // BugReportElement.VERSION,
	// // BugReportElement.COMPONENT,
	// // BugReportElement.TARGET_MILESTONE,
	// // BugReportElement.REP_PLATFORM,
	// // BugReportElement.OP_SYS,
	// // BugReportElement.PRIORITY,
	// // BugReportElement.BUG_SEVERITY,
	// // BugReportElement.ASSIGNED_TO,
	// // // NOT USED BugReportElement.CC,
	// // BugReportElement.BUG_FILE_LOC,
	// // //NOT USED BugReportElement.SHORT_DESC,
	// // //NOT USED BugReportElement.LONG_DESC
	// // };
	//
	// // HashMap<String, AbstractRepositoryReportAttribute> attributes = new
	// // LinkedHashMap<String, AbstractRepositoryReportAttribute>();
	// List<String> optionValues;
	// AbstractRepositoryReportAttribute a =
	// existingReport.getAttribute(BugzillaReportElement.PRODUCT);
	// if (a != null) {
	// optionValues =
	// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getProducts();
	// for (String option : optionValues) {
	// a.addOptionValue(option, option);
	// }
	// }
	// // existingReport.addAttribute(BugzillaReportElement.PRODUCT, a);
	//
	// a = existingReport.getAttribute(BugzillaReportElement.BUG_STATUS);
	// if (a != null) {
	// optionValues =
	// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getStatusValues();
	// for (String option : optionValues) {
	// a.addOptionValue(option, option);
	// }
	// }
	// // existingReport.addAttribute(BugzillaReportElement.BUG_STATUS, a);
	//
	// a = existingReport.getAttribute(BugzillaReportElement.VERSION);
	// if (a != null) {
	// optionValues =
	// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getVersions(
	// existingReport.getProduct());
	// for (String option : optionValues) {
	// a.addOptionValue(option, option);
	// }
	// }
	// // existingReport.addAttribute(BugzillaReportElement.VERSION, a);
	//
	// a = existingReport.getAttribute(BugzillaReportElement.COMPONENT);
	// if (a != null) {
	// optionValues =
	// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getComponents(
	// existingReport.getProduct());
	// for (String option : optionValues) {
	// a.addOptionValue(option, option);
	// }
	// }
	// // existingReport.addAttribute(BugzillaReportElement.COMPONENT, a);
	//
	// a = existingReport.getAttribute(BugzillaReportElement.REP_PLATFORM);
	// if (a != null) {
	// optionValues =
	// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getPlatforms();
	// for (String option : optionValues) {
	// a.addOptionValue(option, option);
	// }
	// }
	// // existingReport.addAttribute(BugzillaReportElement.REP_PLATFORM, a);
	//
	// a = existingReport.getAttribute(BugzillaReportElement.OP_SYS);
	// if (a != null) {
	// optionValues =
	// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getOSs();
	// for (String option : optionValues) {
	// a.addOptionValue(option, option);
	// }
	// }
	// // existingReport.addAttribute(BugzillaReportElement.OP_SYS, a);
	//
	// a = existingReport.getAttribute(BugzillaReportElement.PRIORITY);
	// if (a != null) {
	// optionValues =
	// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getPriorities();
	// for (String option : optionValues) {
	// a.addOptionValue(option, option);
	// }
	// }
	// // existingReport.addAttribute(BugzillaReportElement.PRIORITY, a);
	//
	// a = existingReport.getAttribute(BugzillaReportElement.BUG_SEVERITY);
	// if (a != null) {
	// optionValues =
	// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getSeverities();
	// for (String option : optionValues) {
	// a.addOptionValue(option, option);
	// }
	// }
	// // existingReport.addAttribute(BugzillaReportElement.BUG_SEVERITY, a);
	//
	// a = existingReport.getAttribute(BugzillaReportElement.TARGET_MILESTONE);
	// if (a != null) {
	// optionValues =
	// BugzillaPlugin.getDefault().getProductConfiguration(serverUrl).getTargetMilestones(
	// existingReport.getProduct());
	// for (String option : optionValues) {
	// a.addOptionValue(option, option);
	// }
	// }
	// // existingReport.addAttribute(BugzillaReportElement.TARGET_MILESTONE,
	// // a);
	//
	// // a = new BugzillaReportAttribute(BugzillaReportElement.ASSIGNED_TO);
	// // existingReport.addAttribute(BugzillaReportElement.ASSIGNED_TO, a);
	// //
	// // a = new BugzillaReportAttribute(BugzillaReportElement.BUG_FILE_LOC);
	// // existingReport.addAttribute(BugzillaReportElement.BUG_FILE_LOC, a);
	//
	// // Add fields that may not be present in xml but required for ui and
	// // submission. NOTE: Perhaps the bug reports should be set up with all
	// // valid attributes
	// // and then passed to the parser to populate the appropriate fields
	// // rather than
	//
	// a = existingReport.getAttribute(BugzillaReportElement.CC);
	// if (a == null) {
	// existingReport
	// .addAttribute(BugzillaReportElement.CC, new
	// BugzillaReportAttribute(BugzillaReportElement.CC));
	// }
	// a = existingReport.getAttribute(BugzillaReportElement.RESOLUTION);
	// if (a == null) {
	// existingReport.addAttribute(BugzillaReportElement.RESOLUTION, new
	// BugzillaReportAttribute(
	// BugzillaReportElement.RESOLUTION));
	// }
	// a = existingReport.getAttribute(BugzillaReportElement.BUG_FILE_LOC);
	// if (a == null) {
	// existingReport.addAttribute(BugzillaReportElement.BUG_FILE_LOC, new
	// BugzillaReportAttribute(
	// BugzillaReportElement.BUG_FILE_LOC));
	// }
	// a = existingReport.getAttribute(BugzillaReportElement.NEWCC);
	// if (a == null) {
	// existingReport.addAttribute(BugzillaReportElement.NEWCC, new
	// BugzillaReportAttribute(
	// BugzillaReportElement.NEWCC));
	// }
	//
	// // Special hidden fields required when existing bug is submitted to
	// // bugzilla
	// a = existingReport.getAttribute(BugzillaReportElement.LONGDESCLENGTH);
	// if (a == null) {
	// a = new BugzillaReportAttribute(BugzillaReportElement.LONGDESCLENGTH);
	// a.setValue("" + existingReport.getComments().size());
	// existingReport.addAttribute(BugzillaReportElement.LONGDESCLENGTH, a);
	// }
	//
	// }

	public static void setupExistingBugAttributes(String serverUrl, BugzillaReport existingReport) {
		// ordered list of elements as they appear in UI
		// and additional elements that may not appear in the incoming xml
		// stream but need to be present for bug submission
		BugzillaReportElement[] reportElements = { BugzillaReportElement.BUG_STATUS, BugzillaReportElement.RESOLUTION,
				BugzillaReportElement.BUG_ID, BugzillaReportElement.REP_PLATFORM, BugzillaReportElement.PRODUCT,
				BugzillaReportElement.OP_SYS, BugzillaReportElement.COMPONENT, BugzillaReportElement.VERSION,
				BugzillaReportElement.PRIORITY, BugzillaReportElement.BUG_SEVERITY, BugzillaReportElement.ASSIGNED_TO,
				BugzillaReportElement.TARGET_MILESTONE, BugzillaReportElement.REPORTER, BugzillaReportElement.DEPENDSON, BugzillaReportElement.BLOCKED,
				BugzillaReportElement.BUG_FILE_LOC, BugzillaReportElement.NEWCC, BugzillaReportElement.KEYWORDS};

		for (BugzillaReportElement element : reportElements) {
			AbstractRepositoryReportAttribute reportAttribute = new BugzillaReportAttribute(element);
			existingReport.addAttribute(element, reportAttribute);
		}
	}

	private static void updateBugAttributeOptions(TaskRepository repository, BugzillaReport existingReport) {
		String product = existingReport.getAttributeValue(BugzillaReportElement.PRODUCT);
		for (AbstractRepositoryReportAttribute attribute : existingReport.getAttributes()) {			
			BugzillaReportElement element = BugzillaReportElement.valueOf(attribute.getID().trim().toUpperCase());			
			attribute.clearOptions();
			List<String> optionValues = BugzillaPlugin.getDefault().getProductConfiguration(repository).getOptionValues(
					element, product);
			if (element == BugzillaReportElement.TARGET_MILESTONE && optionValues.isEmpty()) {
				existingReport.removeAttribute(BugzillaReportElement.TARGET_MILESTONE);
				continue;
			}
			for (String option : optionValues) {
				attribute.addOptionValue(option, option);
			}
		}

	}

	public static void addValidOperations(BugzillaReport bugReport) {
		BUGZILLA_REPORT_STATUS status = BUGZILLA_REPORT_STATUS.valueOf(bugReport.getStatus());
		switch (status) {
		case UNCONFIRMED:
		case REOPENED:
		case NEW:
			addOperation(bugReport, BUGZILLA_OPERATION.none);
			addOperation(bugReport, BUGZILLA_OPERATION.accept);
			addOperation(bugReport, BUGZILLA_OPERATION.resolve);
			addOperation(bugReport, BUGZILLA_OPERATION.duplicate);
			addOperation(bugReport, BUGZILLA_OPERATION.reassign);
			addOperation(bugReport, BUGZILLA_OPERATION.reassignbycomponent);
			break;
		case ASSIGNED:
			addOperation(bugReport, BUGZILLA_OPERATION.none);
			addOperation(bugReport, BUGZILLA_OPERATION.resolve);
			addOperation(bugReport, BUGZILLA_OPERATION.duplicate);
			addOperation(bugReport, BUGZILLA_OPERATION.reassign);
			addOperation(bugReport, BUGZILLA_OPERATION.reassignbycomponent);
			break;
		case RESOLVED:
			addOperation(bugReport, BUGZILLA_OPERATION.none);
			addOperation(bugReport, BUGZILLA_OPERATION.reopen);
			addOperation(bugReport, BUGZILLA_OPERATION.verify);
			addOperation(bugReport, BUGZILLA_OPERATION.close);
			break;
		case CLOSED:
			addOperation(bugReport, BUGZILLA_OPERATION.none);
			addOperation(bugReport, BUGZILLA_OPERATION.reopen);
			break;
		case VERIFIED:
			addOperation(bugReport, BUGZILLA_OPERATION.none);
			addOperation(bugReport, BUGZILLA_OPERATION.reopen);
			addOperation(bugReport, BUGZILLA_OPERATION.close);
		}
	}

	public static void addOperation(BugzillaReport bugReport, BUGZILLA_OPERATION opcode) {
		Operation newOperation = null;
		switch (opcode) {
		case none:
			newOperation = new Operation(opcode.toString(), "Leave as " + bugReport.getStatus() + " "
					+ bugReport.getResolution());
			newOperation.setChecked(true);
			break;
		case accept:
			newOperation = new Operation(opcode.toString(), OPERATION_LABEL_ACCEPT);
			break;
		case resolve:
			newOperation = new Operation(opcode.toString(), OPERATION_LABEL_RESOLVE);
			newOperation.setUpOptions(OPERATION_OPTION_RESOLUTION);
			for (BUGZILLA_RESOLUTION resolution: BUGZILLA_RESOLUTION.values()) {
				newOperation.addOption(resolution.toString(), resolution.toString());
			}			
			break;
		case duplicate:
			newOperation = new Operation(opcode.toString(), OPERATION_LABEL_DUPLICATE);
			newOperation.setInputName(OPERATION_INPUT_DUP_ID);
			newOperation.setInputValue("");
			break;
		case reassign:
			TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(
					BugzillaPlugin.REPOSITORY_KIND, bugReport.getRepositoryUrl());
			String localUser = repository.getUserName();
			newOperation = new Operation(opcode.toString(), OPERATION_LABEL_REASSIGN);
			newOperation.setInputName(OPERATION_INPUT_ASSIGNED_TO);
			newOperation.setInputValue(localUser);
			break;
		case reassignbycomponent:
			newOperation = new Operation(opcode.toString(), OPERATION_LABEL_REASSIGN_DEFAULT);
			break;
		case reopen:
			newOperation = new Operation(opcode.toString(), OPERATION_LABEL_REOPEN);
			break;
		case verify:
			newOperation = new Operation(opcode.toString(), OPERATION_LABEL_VERIFY);
			break;
		case close:
			newOperation = new Operation(opcode.toString(), OPERATION_LABEL_CLOSE);
			break;
		default:
			MylarStatusHandler.log("Unknown bugzilla operation code recieved", BugzillaRepositoryUtil.class);
		}
		if (newOperation != null) {
			bugReport.addOperation(newOperation);
		}
	}

	public static String getBugUrl(String repositoryUrl, int id) {

				BugzillaPlugin.REPOSITORY_KIND, repositoryUrl);
		String url = repository.getUrl() + POST_ARGS_SHOW_BUG + id;
		try {
			url = addCredentials(repository, url);
				url += "&" + POST_ARGS_LOGIN
						+ URLEncoder.encode(repository.getUserName(), BugzillaPlugin.ENCODING_UTF_8)
						+ POST_ARGS_PASSWORD
						+ URLEncoder.encode(repository.getPassword(), BugzillaPlugin.ENCODING_UTF_8);
			}
		} catch (UnsupportedEncodingException e) {
			return "";
		}

		// if (!parser.wasSuccessful())
		// return;

		RepositoryConfiguration config = RepositoryConfigurationFactory.getInstance().getConfiguration(repository);

		// get the preferences store so that we can change the data in it
		IPreferenceStore prefs = BugzillaPlugin.getDefault().getPreferenceStore();

		FileOutputStream outStream = null;
		try {
			String url = repository.getUrl() + POST_ARGS_ATTACHMENT_DOWNLOAD + id;
			url = addCredentials(repository, url);
				url += "&" + POST_ARGS_LOGIN
						+ URLEncoder.encode(repository.getUserName(), BugzillaPlugin.ENCODING_UTF_8)
						+ POST_ARGS_PASSWORD
						+ URLEncoder.encode(repository.getPassword(), BugzillaPlugin.ENCODING_UTF_8);
			}
			URL downloadUrl = new URL(url);
			URLConnection connection = BugzillaPlugin.getDefault().getUrlConnection(downloadUrl);
			if (connection != null) {

		return uploadResult;
	}

	
	public static String getCharsetFromString(String string) {
		int charsetStartIndex = string.indexOf(ATTR_CHARSET);
		if (charsetStartIndex != -1) {
			int charsetEndIndex = string.indexOf("\"", charsetStartIndex); // TODO:
			// could
			// be
			// space
			// after?
			if (charsetEndIndex == -1) {
				charsetEndIndex = string.length();
			}
			String charsetString = string.substring(charsetStartIndex + 8, charsetEndIndex);
			if (Charset.availableCharsets().containsKey(charsetString)) {
				return charsetString;
			}
		}
		return null;
	}
	
}

/**




import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.FavoritesFile;
import org.eclipse.mylar.internal.bugzilla.core.internal.OfflineReportsFile;
import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryConfiguration;
import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryConfigurationFactory;
import org.eclipse.mylar.internal.bugzilla.core.search.IBugzillaResultEditorMatchAdapter;
import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;

		Authenticator.setDefault(authenticator);

		// Removed since not repository specific
		// setDefaultQueryOptions();

		readFavoritesFile();
		readOfflineReportsFile();

		// final Set<TaskRepository> repositories =
		// MylarTaskListPlugin.getRepositoryManager().getRepositories(
		// REPOSITORY_KIND);
		// for (TaskRepository repository : repositories) {
		// readCachedProductConfiguration(repository.getUrl());
		// }

		migrateOldAuthenticationData();
	}

	
	@SuppressWarnings("unchecked")
	private void migrateOldAuthenticationData() {
		String OLD_PREF_SERVER = "BUGZILLA_SERVER";

					password = pwd;
			}
			TaskRepository repository;
			// try {
			repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, serverUrl);
			repository.setAuthenticationCredentials(user, password);
			MylarTaskListPlugin.getRepositoryManager().addRepository(repository);
			BugzillaPlugin.getDefault().getPreferenceStore().setValue(OLD_PREF_SERVER, "");
			// } catch (MalformedURLException e) {
			// MylarStatusHandler.fail(e, "could not create default repository",
			// true);
			// }
			try {
				// reset the authorization
				Platform.addAuthorizationInfo(BugzillaPreferencePage.FAKE_URL, "Bugzilla",

		BugzillaPreferencePage.initDefaults(store);
	}

	// /**
	// * // * Get the name of the bugzilla server // * // *
	// *
	// * @return A string containing the prefered name of the bugzilla server //
	// */
	// // public String getServerName() {
	// // return
	// //
	// plugin.getPreferenceStore().getString(IBugzillaConstants.BUGZILLA_SERVER);
	// // }
	// public boolean isServerCompatability218() {
	// return
	// IBugzillaConstants.SERVER_218.equals(getPreferenceStore().getString(IBugzillaConstants.SERVER_VERSION))
	// || IBugzillaConstants.SERVER_220.equals(getPreferenceStore().getString(
	// IBugzillaConstants.SERVER_VERSION));
	// }
	//
	// public boolean isServerCompatability220() {
	// return
	// IBugzillaConstants.SERVER_220.equals(getPreferenceStore().getString(IBugzillaConstants.SERVER_VERSION));
	// }

	/**
	 * Get the most recent query key for the preferences

		return plugin.getPreferenceStore().getString(IBugzillaConstants.MOST_RECENT_QUERY);
	}

	public RepositoryConfiguration getProductConfiguration(TaskRepository repository) {
		if (!repositoryConfigurations.containsKey(repository.getUrl())) {
			try {
				repositoryConfigurations.put(repository.getUrl(), RepositoryConfigurationFactory.getInstance().getConfiguration(
						repository));
			} catch (IOException e) {
				MessageDialog.openInformation(null, "Retrieval of Bugzilla Configuration",
						"Bugzilla configuration retrieval failed.");
						null,
						"Retrieval of Bugzilla Configuration", "Bugzilla configuration retrieval failed.");
			}
		}

		return repositoryConfigurations.get(repository.getUrl());
	}

	
//	public RepositoryConfiguration getProductConfiguration(String serverUrl) {
//		if (!repositoryConfigurations.containsKey(serverUrl)) {
//			try {
//				repositoryConfigurations.put(serverUrl, RepositoryConfigurationFactory.getInstance().getConfiguration(
//						serverUrl));
//			} catch (IOException e) {
//				MessageDialog.openInformation(null, "Retrieval of Bugzilla Configuration",
//						"Bugzilla configuration retrieval failed.");
//			}
//		}
//
//		return repositoryConfigurations.get(serverUrl);
//	}

	protected void setProductConfiguration(String serverUrl, RepositoryConfiguration repositoryConfiguration) {
		repositoryConfigurations.put(serverUrl, repositoryConfiguration);
		// this.productConfiguration = productConfiguration;

		try {
			offlineReportsFile = new OfflineReportsFile(offlineReportsPath.toFile());
		} catch (Exception e) {
			MylarStatusHandler.fail(e, "could not restore offline Bugzilla reports file, creating new one", false);
			// logAndShowExceptionDetailsDialog(e, "occurred while restoring
			// saved offline Bugzilla reports.",
			// "Bugzilla Offline Reports Error");
			if (offlineReportsPath.toFile().delete()) {
				try {
					offlineReportsFile = new OfflineReportsFile(offlineReportsPath.toFile());
				} catch (Exception e1) {
					MylarStatusHandler.fail(e, "could not reset offline Bugzilla reports file", true);
				}
			} else {
				MylarStatusHandler.fail(null, "reset of Bugzilla offline reports file failed", true);
			}
		}
	}

		return configFile;
	}

	// /**
	// * Reads cached product configuration and stores it in the
	// * <code>productConfiguration</code> field.
	// *
	// * TODO remove this?
	// */
	// private void readCachedProductConfiguration(String serverUrl) {
	// IPath configFile = getProductConfigurationCachePath(serverUrl);
	//
	// try {
	// productConfigurations.put(serverUrl,
	// ServerConfigurationFactory.getInstance().readConfiguration(
	// configFile.toFile()));
	// } catch (IOException ex) {
	// try {
	// log(ex);
	// productConfigurations.put(serverUrl,
	// ServerConfigurationFactory.getInstance().getConfiguration(
	// serverUrl));
	// } catch (IOException e) {
	// log(e);
	// MessageDialog
	// .openInformation(
	// null,
	// "Bugzilla product attributes check",
	// "An error occurred while restoring saved Bugzilla product attributes:
	// \n\n"
	// + ex.getMessage()
	// + "\n\nUpdating them from the server also caused an error:\n\n"
	// + e.getMessage()
	// + "\n\nCheck the server URL in Bugzila preferences.\n"
	// + "Offline submission of new bugs will be disabled until valid product
	// attributes have been loaded.");
	// }
	// }
	// }

	/**
	 * Returns the path to the file cacheing the product configuration.

	/**
	 * @return a list of the BugReports saved offline.
	 */
	public List<BugzillaReport> getSavedBugReports() {
		return offlineReportsFile.elements();
	}


		return getPreferenceStore().getInt(IBugzillaConstants.MAX_RESULTS);
	}

	// private void setDefaultQueryOptions() {
	// // get the preferences store for the bugzilla preferences
	// IPreferenceStore prefs = getPreferenceStore();
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_STATUS, BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_STATUS_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUSE_STATUS_PRESELECTED,
	// BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_PRESELECTED_STATUS_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_RESOLUTION,
	// BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_RESOLUTION_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_SEVERITY,
	// BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_SEVERITY_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_PRIORITY,
	// BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_PRIORITY_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_HARDWARE,
	// BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_HARDWARE_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_OS, BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_OS_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_PRODUCT,
	// BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_PRODUCT_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_COMPONENT,
	// BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_COMPONENT_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_VERSION,
	// BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_VERSION_VALUES));
	//
	// prefs.setDefault(IBugzillaConstants.VALUES_TARGET, BugzillaRepositoryUtil
	// .queryOptionsToString(IBugzillaConstants.DEFAULT_TARGET_VALUES));
	// }

}

Lines 32-46 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/core/BugzillaReportSubmitForm.java (-42 / +54 lines)
32		32
33	import org.eclipse.core.runtime.IStatus;	33	import org.eclipse.core.runtime.IStatus;
34	import org.eclipse.core.runtime.Status;	34	import org.eclipse.core.runtime.Status;
35	import org.eclipse.mylar.bugzilla.core.Attribute;	35	import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
36	import org.eclipse.mylar.bugzilla.core.BugReport;	36	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
		37	import org.eclipse.mylar.bugzilla.core.BugzillaReportAttribute;
37	import org.eclipse.mylar.bugzilla.core.Operation;	38	import org.eclipse.mylar.bugzilla.core.Operation;
38	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants.BugzillaServerVersion;	39	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants.BugzillaServerVersion;
39	import org.eclipse.mylar.internal.bugzilla.core.internal.BugReportElement;	40	import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
40	import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer;	41	import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer;
41	import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlTag;	42	import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlTag;
42	import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer.Token;	43	import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer.Token;
43	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
44	import org.eclipse.mylar.provisional.tasklist.TaskRepository;	44	import org.eclipse.mylar.provisional.tasklist.TaskRepository;
45		45
46	/**	46	/**
Lines 57-62 Link Here
57		57
58	// private static final String KEY_PRODUCT = "product";	58	// private static final String KEY_PRODUCT = "product";
59		59
		60	private static final String KEY_ID = "id";
		61
60	private static final String VAL_TRUE = "true";	62	private static final String VAL_TRUE = "true";
61		63
62	private static final String KEY_REMOVECC = "removecc";	64	private static final String KEY_REMOVECC = "removecc";
Lines 71-78 Link Here
71		73
72	private static final String METHOD_POST = "POST";	74	private static final String METHOD_POST = "POST";
73		75
74	private static final String KEY_NEWCC = "newcc";
75
76	private static final String KEY_BUGZILLA_PASSWORD = "Bugzilla_password";	76	private static final String KEY_BUGZILLA_PASSWORD = "Bugzilla_password";
77		77
78	private static final String KEY_BUGZILLA_LOGIN = "Bugzilla_login";	78	private static final String KEY_BUGZILLA_LOGIN = "Bugzilla_login";
Lines 95-102 Link Here
95		95
96	private static final String KEY_SHORT_DESC = "short_desc";	96	private static final String KEY_SHORT_DESC = "short_desc";
97		97
98	private static final String KEY_ASSIGNED_TO = "Assigned To";
99
100	// private static final String KEY_ASSIGN_TO = "Assign To";	98	// private static final String KEY_ASSIGN_TO = "Assign To";
101	//	99	//
102	// private static final String KEY_URL = "URL";	100	// private static final String KEY_URL = "URL";
Lines 209-215 Link Here
209	// return bugzillaReportSubmitForm;	207	// return bugzillaReportSubmitForm;
210	// }	208	// }
211		209
212	public static BugzillaReportSubmitForm makeNewBugPost(TaskRepository repository, NewBugModel model) {	210	public static BugzillaReportSubmitForm makeNewBugPost(TaskRepository repository, NewBugzillaReport model) {
213	BugzillaReportSubmitForm form = new BugzillaReportSubmitForm();	211	BugzillaReportSubmitForm form = new BugzillaReportSubmitForm();
214	form.setPrefix(BugzillaReportSubmitForm.FORM_PREFIX_BUG_218);	212	form.setPrefix(BugzillaReportSubmitForm.FORM_PREFIX_BUG_218);
215	form.setPrefix2(BugzillaReportSubmitForm.FORM_PREFIX_BUG_220);	213	form.setPrefix2(BugzillaReportSubmitForm.FORM_PREFIX_BUG_220);
Lines 220-229 Link Here
220	setURL(form, repository, POST_BUG_CGI);	218	setURL(form, repository, POST_BUG_CGI);
221	// go through all of the attributes and add them to	219	// go through all of the attributes and add them to
222	// the bug post	220	// the bug post
223	Iterator<Attribute> itr = model.getAttributes().iterator();	221	Iterator<AbstractRepositoryReportAttribute> itr = model.getAttributes().iterator();
224	while (itr.hasNext()) {	222	while (itr.hasNext()) {
225	Attribute a = itr.next();	223	AbstractRepositoryReportAttribute a = itr.next();
226	if (a != null && a.getParameterName() != null && a.getParameterName().compareTo("") != 0 && !a.isHidden()) {	224	if (a != null && a.getID() != null && a.getID().compareTo("") != 0) { // &&
		225	// !a.isHidden()
227	// String key = a.getName();	226	// String key = a.getName();
228	String value = null;	227	String value = null;
229		228
Lines 259-278 Link Here
259	// && a.isHidden()) {	258	// && a.isHidden()) {
260	// // we have a hidden attribute, add it to the	259	// // we have a hidden attribute, add it to the
261	// // posting	260	// // posting
262	value = a.getValue();	261	value = a.getValue();
263	if (value == null)	262	if (value == null)
264	continue;	263	continue;
265	form.add(a.getParameterName(), value);	264	form.add(a.getID(), value);
266	}	265	}
267	}	266	}
268		267
269	// form.add(KEY_BUG_FILE_LOC, "");	268	// form.add(KEY_BUG_FILE_LOC, "");
270		269
271	// specify the product	270	// specify the product
272	form.add(BugReportElement.PRODUCT.getKeyString(), model.getProduct());	271	form.add(BugzillaReportElement.PRODUCT.getKeyString(), model.getProduct());
273		272
274	// add the summary to the bug post	273	// add the summary to the bug post
275	form.add(BugReportElement.SHORT_DESC.getKeyString(), model.getSummary());	274	form.add(BugzillaReportElement.SHORT_DESC.getKeyString(), model.getSummary());
276		275
277	// BugzillaServerVersion bugzillaServerVersion =	276	// BugzillaServerVersion bugzillaServerVersion =
278	// IBugzillaConstants.BugzillaServerVersion.fromString(repository	277	// IBugzillaConstants.BugzillaServerVersion.fromString(repository
Lines 304-310 Link Here
304	*	303	*
305	* @param removeCC	304	* @param removeCC
306	*/	305	*/
307	public static BugzillaReportSubmitForm makeExistingBugPost(BugReport bug, TaskRepository repository,	306	public static BugzillaReportSubmitForm makeExistingBugPost(BugzillaReport bug, TaskRepository repository,
308	Set<String> removeCC) {	307	Set<String> removeCC) {
309		308
310	BugzillaReportSubmitForm bugReportPostHandler = new BugzillaReportSubmitForm();	309	BugzillaReportSubmitForm bugReportPostHandler = new BugzillaReportSubmitForm();
Lines 317-335 Link Here
317	}	316	}
318		317
319	// go through all of the attributes and add them to the bug post	318	// go through all of the attributes and add them to the bug post
320	for (Iterator<Attribute> it = bug.getAttributes().iterator(); it.hasNext();) {	319	for (Iterator<AbstractRepositoryReportAttribute> it = bug.getAttributes().iterator(); it.hasNext();) {
321	Attribute a = it.next();	320	AbstractRepositoryReportAttribute a = it.next();
322	if (a != null && a.getParameterName() != null && a.getParameterName().compareTo("") != 0 && !a.isHidden()) {	321
323	String value = a.getNewValue();	322	if (a != null && a.getID() != null && a.getID().compareTo("") != 0 && !a.isHidden()) {
		323	String value = a.getValue();
324	// add the attribute to the bug post	324	// add the attribute to the bug post
325	bugReportPostHandler.add(a.getParameterName(), value != null ? value : "");	325	bugReportPostHandler.add(a.getID(), value != null ? value : "");
326	} else if (a != null && a.getParameterName() != null && a.getParameterName().compareTo("") != 0	326	} else if (a != null && a.getID() != null && a.getID().compareTo("") != 0 && a.isHidden()) {
327	&& a.isHidden()) {
328	// we have a hidden attribute and we should send it back.	327	// we have a hidden attribute and we should send it back.
329	bugReportPostHandler.add(a.getParameterName(), a.getValue());	328	bugReportPostHandler.add(a.getID(), a.getValue());
330	}	329	}
331	}	330	}
332		331
		332	// when posting the bug id is encoded in a hidden field named 'id'
		333	bugReportPostHandler.add(KEY_ID, bug.getAttributeValue(BugzillaReportElement.BUG_ID));
		334
333	// add the operation to the bug post	335	// add the operation to the bug post
334	Operation o = bug.getSelectedOperation();	336	Operation o = bug.getSelectedOperation();
335	if (o == null)	337	if (o == null)
Lines 345-358 Link Here
345	}	347	}
346	}	348	}
347	bugReportPostHandler.add(KEY_FORM_NAME, VAL_PROCESS_BUG);	349	bugReportPostHandler.add(KEY_FORM_NAME, VAL_PROCESS_BUG);
348	bug.setNewNewComment(formatTextToLineWrap(bug.getNewNewComment(), repository));	350	// bug.setNewNewComment(formatTextToLineWrap(bug.getNewComment(),
349	if (bug.getAttribute(BugReport.ATTR_SUMMARY) != null) {	351	// repository));
350	bugReportPostHandler.add(KEY_SHORT_DESC, bug.getAttribute(BugReport.ATTR_SUMMARY).getNewValue());	352	if (bug.getAttribute(BugzillaReportElement.SHORT_DESC) != null) {
		353	bugReportPostHandler.add(KEY_SHORT_DESC, bug.getAttribute(BugzillaReportElement.SHORT_DESC).getValue());
351	}	354	}
352		355
353	// add the new comment to the bug post if there is some text in it	356	// add the new comment to the bug post if there is some text in it
354	if (bug.getNewNewComment().length() != 0) {	357	if (bug.getNewComment().length() != 0) {
355	bugReportPostHandler.add(KEY_COMMENT, bug.getNewNewComment());	358	bugReportPostHandler.add(KEY_COMMENT, bug.getNewComment());
356	}	359	}
357		360
358	if (removeCC != null && removeCC.size() > 0) {	361	if (removeCC != null && removeCC.size() > 0) {
Lines 431-436 Link Here
431	}	434	}
432	postConnection.setRequestProperty(REQUEST_PROPERTY_CONTENT_TYPE, contentTypeString);	435	postConnection.setRequestProperty(REQUEST_PROPERTY_CONTENT_TYPE, contentTypeString);
433	// get the url for the update with all of the changed values	436	// get the url for the update with all of the changed values
		437
		438	// Used to debug posted report
		439	// System.err.println(getPostBody());
		440
434	byte[] body = getPostBody().getBytes();	441	byte[] body = getPostBody().getBytes();
435	postConnection.setRequestProperty(REQUEST_PROPERTY_CONTENT_LENGTH, String.valueOf(body.length));	442	postConnection.setRequestProperty(REQUEST_PROPERTY_CONTENT_LENGTH, String.valueOf(body.length));
436		443
Lines 455-461 Link Here
455		462
456	String aString = in.readLine();	463	String aString = in.readLine();
457		464
458	// while(aString != null) {	465	// Used to debug reponse from bugzilla server
		466	// while (aString != null) {
459	// System.err.println(aString);	467	// System.err.println(aString);
460	// aString = in.readLine();	468	// aString = in.readLine();
461	// }	469	// }
Lines 631-657 Link Here
631		639
632	/**	640	/**
633	* Sets the cc field to the user's address if a cc has not been specified to	641	* Sets the cc field to the user's address if a cc has not been specified to
634	* ensure that commenters are on the cc list.	642	* ensure that commenters are on the cc list. TODO: Review this mechanism
635	*	643	*
636	* @author Wesley Coelho	644	* @author Wesley Coelho
637	*/	645	*/
638	private static void setDefaultCCValue(BugReport bug, TaskRepository repository) {	646	private static void setDefaultCCValue(BugzillaReport bug, TaskRepository repository) {
639	Attribute newCCattr = bug.getAttributeForKnobName(KEY_NEWCC);	647	// AbstractRepositoryReportAttribute newCCattr =
640	Attribute owner = bug.getAttribute(KEY_ASSIGNED_TO);	648	// bug.getAttributeForKnobName(KEY_NEWCC);
		649	AbstractRepositoryReportAttribute owner = bug.getAttribute(BugzillaReportElement.ASSIGNED_TO);
641		650
642	// Don't add the cc if the user is the bug owner	651	// Don't add the cc if the user is the bug owner
643	if (repository.getUserName() == null	652	if (repository.getUserName() == null
644	\|\| (owner != null && owner.getValue().indexOf(repository.getUserName()) != -1)) {	653	\|\| (owner != null && owner.getValue().indexOf(repository.getUserName()) != -1)) {
645	MylarStatusHandler.log("Could not determine CC value for repository: " + repository, null);	654	// MylarStatusHandler.log("Could not determine CC value for
		655	// repository: " + repository, null);
646	return;	656	return;
647	}	657	}
648		658	// Don't add cc if already there
649	// Add the user to the cc list	659	AbstractRepositoryReportAttribute ccAttribute = bug.getAttribute(BugzillaReportElement.CC);
650	if (newCCattr != null) {	660	if (ccAttribute != null && ccAttribute.getValues().contains(repository.getUserName())) {
651	if (newCCattr.getNewValue().equals("")) {	661	return;
652	newCCattr.setNewValue(repository.getUserName());
653	}
654	}	662	}
		663	BugzillaReportAttribute newCCattr = new BugzillaReportAttribute(BugzillaReportElement.NEWCC);
		664	// Add the user to the cc list
		665	newCCattr.setValue(repository.getUserName());
		666	bug.addAttribute(BugzillaReportElement.NEWCC, newCCattr);
655	}	667	}
656		668
657	/**	669	/**




 *******************************************************************************/
package org.eclipse.mylar.internal.bugzilla.core;

import org.eclipse.mylar.bugzilla.core.BugzillaReport;

/**
 * Miscellaneous constants and functions for this plugin.

		return name;
	}

	public static String getHandle(BugzillaReport bug) {
		return getHandle(bug.getRepositoryUrl(), bug.getId());
	}


		return server + ";" + id;
	}

	public static String getName(BugzillaReport bug) {
		return bug.getRepositoryUrl() + ": Bug#: " + bug.getId() + ": " + bug.getSummary();
	}





import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.search.ui.NewSearchUI;
import org.eclipse.search.ui.text.Match;


	 * Returns a map where BugReport's attributes are entered into a Map using
	 * the same key/value pairs as those created on a search hit marker.
	 */
	public static Map<String, Object> getAttributeMap(BugzillaReport bug) {
		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put(IBugzillaConstants.HIT_MARKER_ATTR_ID, new Integer(bug.getId()));
		map.put(IBugzillaConstants.HIT_MARKER_ATTR_REPOSITORY, bug.getRepositoryUrl());
		map.put(IBugzillaConstants.HIT_MARKER_ATTR_DESC, bug.getDescription());
		map.put(IBugzillaConstants.HIT_MARKER_ATTR_SEVERITY,
				mapValue(bug.getAttribute(BugzillaReportElement.BUG_SEVERITY).getValue(), severity));
		map.put(IBugzillaConstants.HIT_MARKER_ATTR_PRIORITY,
				mapValue(bug.getAttribute(BugzillaReportElement.PRIORITY).getValue(), priority));
		map.put(IBugzillaConstants.HIT_MARKER_ATTR_PLATFORM, bug.getAttribute("Hardware").getValue());
		map.put(IBugzillaConstants.HIT_MARKER_ATTR_STATE, mapValue(bug.getStatus(), state));
		map.put(IBugzillaConstants.HIT_MARKER_ATTR_RESULT, mapValue(bug.getResolution(), result));




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.bugzilla.core.internal;

/**
 * Bugzilla XML element enum. Each enum has the attribute name
 * and associated xml element tag name.
 * 
 * @author Rob Elves
 */
public enum BugzillaReportElement {
	// Format: ENUM ( "pretty name", "xml key", <hidden: true/false>, <multivalued: true/false>)
	// Hidden elements are not automatically displayed in ui	
	ASSIGNED_TO ("Assigned to:", "assigned_to"),
	ATTACHID ("attachid", "attachid"),
	ATTACHMENT ("attachment", "attachment"),
	BLOCKED ("Bug blocks:", "blocked"),
	BUG ("bug","bug", true),
	BUG_FILE_LOC ("URL:", "bug_file_loc", true),
	BUG_ID ("Bug:", "bug_id", true),
	BUG_SEVERITY ("Severity:", "bug_severity", false),
	BUG_STATUS ("Status:", "bug_status", false, true),
	BUG_WHEN ("bug_when", "bug_when", true, true),
	BUGZILLA ("bugzilla", "bugzilla", true),
	CC ("CC:", "cc", true, true),
	CCLIST_ACCESSIBLE ("cclist_accessible", "cclist_accessible", true),
	CLASSIFICATION ("Classification:", "classification", true),
	CLASSIFICATION_ID ("Classification ID:", "classification_id", true),
	COMPONENT ("Component:", "component", false),
	CREATION_TS ("Creation date:", "creation_ts", true),
	CTYPE ("Content Type", "ctype"),
	DATA ("data", "data"), 
	DATE ("Date", "date"), 
	DELTA_TS ("Last Modification", "delta_ts", true), 
	DEPENDSON ("Bug depends on:", "dependson"), 
	DESC ("desc", "desc"), 
	EVERCONFIRMED ("everconfirmed", "everconfirmed", true),
	FILENAME ("filename", "filename"),
	IS_OBSOLETE ("Obsolete", "isobsolete", true), 
	KEYWORDS ("Keywords:", "keywords", true), 
	LONG_DESC ("Description:", "long_desc"), 
	LONGDESCLENGTH ("Number of comments", "longdesclength", true), 
	NEWCC ("Add CC:", "newcc", true), 
	OP_SYS ("OS:", "op_sys", false), 
	PRIORITY ("Priority:", "priority", false), 
	PRODUCT ("Product:", "product", false), 
	REP_PLATFORM ("Platform:", "rep_platform", false),
	REPORTER ("Reporter:", "reporter", false, true),
	REPORTER_ACCESSIBLE ("reporter_accessible", "reporter_accessible", true),
	RESOLUTION ("Resolution:", "resolution", false, true), // Exiting bug field, new cc
	SHORT_DESC ("Summary:", "short_desc", true),
	TARGET_MILESTONE ("Target milestone:", "target_milestone", false),
	THETEXT ("thetext", "thetext"),
	TYPE ("type", "type"),
	UNKNOWN ("UNKNOWN", "UNKNOWN"),
	VERSION ("Version:", "version", false),
	VOTES ("Votes:", "votes", false, true),
	WHO ("who", "who");
	

	
	private final boolean isHidden;
	private final boolean isReadOnly;
	private final String keyString;
	private final String prettyName;

	BugzillaReportElement(String prettyName, String fieldName) {		
		this(prettyName, fieldName, false, false);
	}
	
	BugzillaReportElement(String prettyName, String fieldName, boolean hidden) {		
		this(prettyName, fieldName, hidden, false);
	}
	
	BugzillaReportElement(String prettyName, String fieldName, boolean hidden, boolean readonly) {		
		this.prettyName = prettyName;
		this.keyString = fieldName;
		this.isHidden = hidden;
		this.isReadOnly = readonly;
	}

	public String getKeyString() {
		return keyString;
	}

	public boolean isHidden() {
		return isHidden;
	}	
	
	public boolean isReadOnly() {
		return isReadOnly;
	}
	
	public String toString() {
		return prettyName;
	}
}




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.internal.bugzilla.core;

import java.io.Serializable;
import java.util.Date;

import org.eclipse.mylar.bugzilla.core.BugzillaReport;

/**
 * This class is used to store data about the new bug that is being created
 * while the wizard is being used
 * 
 * @author Eric Booth
 * @author Rob Elves
 */
public class NewBugzillaReport extends BugzillaReport implements Serializable { 

	/** Automatically generated serialVersionUID */
	private static final long serialVersionUID = 3977859587934335283L;

	/** Whether the attributes have been parsed yet or not */
	protected boolean hasParsedAttributes = false;

	/** Whether the products have been parsed yet or not */
	protected boolean hasParsedProducts = false;
//
//	// /** The bug's id */
//	// protected final int id;
//
	/** The product that the bug is for */
	protected String product;
//
//	// /** A list of the attributes that can be changed for the new bug */
//	// public Map<String, AbstractRepositoryReportAttribute> attributes = new
//	// LinkedHashMap<String, AbstractRepositoryReportAttribute>();
//
	/** The summary for the bug */
	protected String summary = "";

	/** The description for the bug */
	protected String description = "";

	/**
	 * Flag to indicate status of connection to Bugzilla server to identify
	 * whether ProductConfiguration should be used instead
	 */
	protected boolean connected = true;

	/** Whether or not this bug report is saved offline. */
	protected boolean savedOffline = false;

	/**
	 * Creates a new <code>NewBugModel</code>. The id chosen for this bug is
	 * based on the id of the last <code>NewBugModel</code> that was created.
	 */
	public NewBugzillaReport(String repositoryURL) {
		super(BugzillaPlugin.getDefault().getOfflineReports().getNextOfflineBugId(), repositoryURL);
		// id =
		// BugzillaPlugin.getDefault().getOfflineReports().getNextOfflineBugId();
	}

	// public AbstractRepositoryReportAttribute getAttribute(String key) {
	// return attributes.get(key);
	// }

	// /**
	// * Get the list of attributes for this model
	// *
	// * @return An <code>ArrayList</code> of the models attributes
	// */
	// public List<AbstractRepositoryReportAttribute> getAttributes() {
	// // create an array list to store the attributes in
	// ArrayList<AbstractRepositoryReportAttribute> attributeEntries = new
	// ArrayList<AbstractRepositoryReportAttribute>(attributes.keySet().size());
	//
	// // go through each of the attribute keys
	// for (Iterator<String> it = attributes.keySet().iterator(); it.hasNext();)
	// {
	// // get the key for the attribute
	// String key = it.next();
	//
	// // get the attribute and add it to the list
	// AbstractRepositoryReportAttribute attribute = attributes.get(key);
	// attributeEntries.add(attribute);
	// }
	//
	// // return the list of attributes for the bug
	// return attributeEntries;
	// }

	// public int getId() {
	// return id;
	// }
	//
	// public String getRepositoryUrl() {
	// return BugzillaTools.OFFLINE_SERVER_DEFAULT;
	// }

	public String getLabel() {
		return "New Bug #" + getId();
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String newDescription) {
		description = newDescription;
	}

	public String getSummary() {
		return summary;
	}

	public void setSummary(String newSummary) {
		summary = newSummary;
	}

	/**
	 * @return The product that the bug is for.
	 */
	public String getProduct() {
		return product;
	}

	/**
	 * Sets the product that the bug is for.
	 * 
	 * @param product
	 *            The product.
	 */
	public void setProduct(String product) {
		this.product = product;
	}

	/**
	 * @return Flag to indicate status of connection to Bugzilla server (to
	 *         identify whether ProductConfiguration should be used instead)
	 */
	public boolean isConnected() {
		return connected;
	}

	/**
	 * Sets the value of the flag to indicate status of connection to Bugzilla
	 * server (to identify whether ProductConfiguration should be used instead)
	 * 
	 * @param newConnectionStatus
	 *            <code>true</code> if the bug is connected.
	 */
	public void setConnected(boolean newConnectionStatus) {
		connected = newConnectionStatus;
	}

	/**
	 * @return Returns whether the attributes have been parsed yet or not.
	 */
	public boolean hasParsedAttributes() {
		return hasParsedAttributes;
	}

	/**
	 * Sets whether the attributes have been parsed yet or not.
	 * 
	 * @param hasParsedAttributes
	 *            <code>true</code> if the attributes have been parsed.
	 */
	public void setParsedAttributesStatus(boolean hasParsedAttributes) {
		this.hasParsedAttributes = hasParsedAttributes;
	}

	/**
	 * @return Returns whether the products have been parsed yet or not.
	 */
	public boolean hasParsedProducts() {
		return hasParsedProducts;
	}

	/**
	 * Sets whether the products have been parsed yet or not.
	 * 
	 * @param hasParsedProducts
	 *            <code>true</code> if the products have been parsed.
	 */
	public void setParsedProductsStatus(boolean hasParsedProducts) {
		this.hasParsedProducts = hasParsedProducts;
	}

	public boolean isSavedOffline() {
		return savedOffline;
	}

	public boolean isLocallyCreated() {
		return true;
	}

	public void setOfflineState(boolean newOfflineState) {
		savedOffline = newOfflineState;
	}

	public boolean hasChanges() {
		return true;
	}

	/** returns null */
	public Date getCreated() {
		return null;
	}

	public Date getLastModified() {
		return null;
	}

}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.core;

import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;

/**
 * @author Rob Elves
 */
public class BugzillaAttributeFactory extends AbstractAttributeFactory {

	@Override
	public AbstractRepositoryReportAttribute createAttribute(Object key) {
		return new BugzillaReportAttribute((BugzillaReportElement) key);
	}

}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.core;

/**
 * @author Rob Elves
 */
public abstract class AbstractAttributeFactory {

	public abstract AbstractRepositoryReportAttribute createAttribute(Object key);
	
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.core;

import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;

/**
 * TODO: Make generic. This currently represents Bugzilla attachments only
 * @author relves
 */
public class ReportAttachment extends AttributeContainer implements Serializable {

	private static final long serialVersionUID = -9123545810321250785L;
	
	/** Parser for dates in the report */
	private static SimpleDateFormat creation_ts_date_format = new SimpleDateFormat("yyyy-MM-dd HH:mm");

	private boolean isObsolete = false;

	private Date created;
	
	public boolean isObsolete() {
		return isObsolete;
	}

	public void setObsolete(boolean isObsolete) {
		this.isObsolete = isObsolete;
	}
	

	/** 
	 * may return null if date is unknown/unparseable
	 */
	public Date getDateCreated() {
		if(created == null) {
			//created = Calendar.getInstance().getTime();
			try {
				created = creation_ts_date_format.parse(getAttributeValue(BugzillaReportElement.DATE));
			} catch (Exception e) {
			}			
		}
		return created;
	}

	/**
	 * Currently returns empty string. XML from bugzilla
	 * doesn't include who attached directly in attachment data
	 * TODO: Retrieve from associated comment
	 * @return
	 */
	public String getAuthor() {
		return "";
	}

	public String getDescription() {
		//System.err.println(getAttributeValue(BugzillaReportElement.DESC));
		return getAttributeValue(BugzillaReportElement.DESC);
	}

	public int getId() {
		try {
			return Integer.parseInt(getAttributeValue(BugzillaReportElement.ATTACHID));
		} catch (NumberFormatException e) {
			return -1;
		}
	}

	public Object getContentType() {
		return getAttributeValue(BugzillaReportElement.CTYPE);
	}
	
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.core;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

/**
 * @author Mik Kersten
 * @author Rob Elves
 */
public abstract class AbstractRepositoryReport extends AttributeContainer implements Serializable {

	private String charset = null;

	private int reportID;

	private String repositoryURL;

	private List<Comment> comments = new ArrayList<Comment>();

	private List<ReportAttachment> attachments = new ArrayList<ReportAttachment>();

	private boolean hasChanges = false;

	public AbstractRepositoryReport(int id, String repositoryURL) {
		super();
		this.reportID = id;
		this.repositoryURL = repositoryURL;
	}

	public void addComment(Comment comment) {
		Comment preceding = null;
		if (comments.size() > 0) {
			// if there are some comments, get the last comment and set the next
			// value to be the new comment
			preceding = comments.get(comments.size() - 1);
			preceding.setNext(comment);
		}
		// set the comments previous value to the preceeding one
		comment.setPrevious(preceding);

		// comment.setText(decodeStringFromCharset(comment.getText()));
		// add the comment to the comment list
		comments.add(comment);
	}

	public List<Comment> getComments() {
		return comments;
	}

	public void addAttachment(ReportAttachment attachment) {
		attachments.add(attachment);
	}

	public List<ReportAttachment> getAttachments() {
		return attachments;
	}

	public int getId() {
		return reportID;
	}

	/**
	 * @return the server for this report
	 */
	public String getRepositoryUrl() {
		return repositoryURL;
	}

	public String getCharset() {
		return charset;
	}

	public void setCharset(String charset) {
		this.charset = charset;
	}

	public boolean hasChanges() {
		return hasChanges ;
	}

	public void setHasChanged(boolean b) {
		hasChanges = b;
	}
	
	/**
	 * @return <code>true</code> if this report was created locally, and does not
	 *         yet exist on a server.
	 */
	public abstract boolean isLocallyCreated();
	
	/**
	 * @return <code>true</code> if this report is saved offline.
	 */
	public abstract boolean isSavedOffline();

	/**
	 * Sets whether or not this report is saved offline.
	 * 
	 * @param newOfflineState
	 *            <code>true</code> if this bug is saved offline
	 */
	public abstract void setOfflineState(boolean newOfflineState);

//	public String getAttributeValue(Object key) {
//		AbstractRepositoryReportAttribute attribute = getAttribute(key);
//		if(attribute != null) {
//			return attribute.getValue();
//		}
//		return "";
//	}
	
	public List<String> getAttributeValues(Object key) {
		AbstractRepositoryReportAttribute attribute = getAttribute(key);
		if(attribute != null) {
			return attribute.getValues();
		}
		return new ArrayList<String>();
	}

	/** 
	 * sets a value on an attribute, if attribute doesn't exist,
	 * appropriate attribute is created
	 */
	public void setAttributeValue(Object key, String value) {
		AbstractRepositoryReportAttribute attrib = getAttribute(key);
		if(attrib == null) {
			attrib = getAttributeFactory().createAttribute(key);
			this.addAttribute(key, attrib);
		}
		attrib.setValue(value);		
	}
	
	public void addAttributeValue(Object key, String value) {
		AbstractRepositoryReportAttribute attrib = getAttribute(key);
		if (attrib != null) {
			attrib.addValue(value);
		} else {
			attrib = getAttributeFactory().createAttribute(key);
			attrib.addValue(value);
			this.addAttribute(key, attrib);
		}
	}
	
	public void removeAttributeValue(Object key, String value) {
		AbstractRepositoryReportAttribute attrib = getAttribute(key);
		if (attrib != null) {
			attrib.removeValue(value);
		} 
	}

	public abstract AbstractAttributeFactory getAttributeFactory();
	
	protected String decodeStringFromCharset(String string) {
		String decoded = string;
		if (charset != null && string != null && Charset.availableCharsets().containsKey(charset)) {
			try {
				decoded = new String(string.getBytes(), charset);
			} catch (UnsupportedEncodingException e) {
				// ignore
			}
		}
		return decoded;
	}

}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.core;

import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;

public class BugzillaReportAttribute extends AbstractRepositoryReportAttribute {

	private static final long serialVersionUID = 6959987055086133307L;

	public BugzillaReportAttribute(BugzillaReportElement element) {
		super(element.toString(), element.isHidden());
		super.setID(element.getKeyString());
		super.setReadOnly(element.isReadOnly());
	}
	
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.bugzilla.core.internal;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.net.URL;
import java.net.URLConnection;

import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;

/**
 * Reads bugzilla product configuration from config.cgi on server in RDF format.
 * 
 * @author Rob Elves
 */
public class RepositoryConfigurationFactory {

	private static final String CONFIG_RDF_URL = "/config.cgi?ctype=rdf";

	private static RepositoryConfigurationFactory instance;

	private RepositoryConfigurationFactory() {
		// no initial setup needed
	}

	public static RepositoryConfigurationFactory getInstance() {
		if (instance == null) {
			instance = new RepositoryConfigurationFactory();
		}
		return instance;
	}

	public RepositoryConfiguration getConfiguration(TaskRepository repository) throws IOException {
		String configUrlStr = repository.getUrl() + CONFIG_RDF_URL;
		configUrlStr = BugzillaRepositoryUtil.addCredentials(repository, configUrlStr);
		URLConnection c = new URL(configUrlStr).openConnection();
		BufferedReader in = new BufferedReader(new InputStreamReader(c.getInputStream()));

		SaxConfigurationContentHandler contentHandler = new SaxConfigurationContentHandler();

		try {
			StringBuffer result = XmlCleaner.clean(in);
			StringReader strReader = new StringReader(result.toString());
			XMLReader reader = XMLReaderFactory.createXMLReader();
			reader.setErrorHandler(new SaxErrorHandler());
			reader.setContentHandler(contentHandler);
			reader.parse(new InputSource(strReader));
		} catch (SAXException e) {
			throw new IOException("Unable to read server configuration.");
		}
		return contentHandler.getConfiguration();

	}

	// public RepositoryConfiguration getConfiguration(String server) throws
	// IOException {
	// URL serverURL = new URL(server + CONFIG_RDF_URL);
	// BugzillaRepositoryUtil.addCredentials(repository, serverURL)
	// URLConnection c = serverURL.openConnection();
	// BufferedReader in = new BufferedReader(new
	// InputStreamReader(c.getInputStream()));
	//
	// SaxConfigurationContentHandler contentHandler = new
	// SaxConfigurationContentHandler();
	//
	// try {
	// StringBuffer result = XmlCleaner.clean(in);
	// StringReader strReader = new StringReader(result.toString());
	// XMLReader reader = XMLReaderFactory.createXMLReader();
	// reader.setErrorHandler(new SaxErrorHandler());
	// reader.setContentHandler(contentHandler);
	// reader.parse(new InputSource(strReader));
	// } catch (SAXException e) {
	// throw new IOException("Unable to read server configuration.");
	// }
	// return contentHandler.getConfiguration();
	//
	// }

	class SaxErrorHandler implements ErrorHandler {

		public void error(SAXParseException exception) throws SAXException {
			MylarStatusHandler.fail(exception, "ServerConfigurationFactory: " + exception.getLocalizedMessage(), false);
		}

		public void fatalError(SAXParseException exception) throws SAXException {
			MylarStatusHandler.fail(exception, "ServerConfigurationFactory: " + exception.getLocalizedMessage(), false);

		}

		public void warning(SAXParseException exception) throws SAXException {
			// ignore
		}

	}

}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.core;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * Class representing a report attribute may contain child attributes
 * 
 * @author Rob Elves
 */
public abstract class AbstractRepositoryReportAttribute implements Serializable {

	private boolean hidden = false;
	private boolean isReadOnly = false;;
	
	/** Attribute pretty printing name */
	private String name;

	/** Name of the option used when updating the attribute on the server */
	private String id;

	/** Legal values of the attribute */
	private LinkedHashMap<String, String> optionValues;

	/**
	 * Attribute's values (selected or added) 
	 */
	private List<String> values = new ArrayList<String>();

	public AbstractRepositoryReportAttribute(String name, boolean hidden) {
		// initialize the name and its legal values
		this.name = name;
		this.hidden = hidden;
		optionValues = new LinkedHashMap<String, String>();
	}

	public String getName() {
		return name;
	}

	public String getID() {
		return id;
	}

	public boolean isReadOnly() {
		return isReadOnly ;//optionValues.size() > 0;
	}
	
	public void setReadOnly(boolean readonly) {
		this.isReadOnly = readonly;
	}

	public Map<String, String> getOptionValues() {
		return optionValues;
	}

	public String getValue() {
		if (values.size() > 0) {
			return values.get(0);
		} else {
			return "";
		}
	}

	public List<String> getValues() {
		return values;
	}

	public void setValue(String value) {
		if(values.size() > 0) {
			values.set(0, value);
		} else {
			values.add(value);
		}
		// newValues.add(value);
	}

	public void setValues(List<String> values) {
		values.clear();
		values.addAll(values);
	}

	public void addValue(String value) {
		values.add(value);
	}

	public void removeValue(String value) {
		if (values.contains(value)) {
			values.remove(values.indexOf(value));
		}
	}
	
	public void clearValues() {
		values.clear();
	}
	


	// /**
	// * Set the new value of the attribute
	// *
	// * @param newVal
	// * The new value of the attribute
	// */
	// public void setNewValue(String newVal) {
	// newValues.add(newVal);
	// }
	//
	// public void setNewValues(List<String> newVals) {
	// newValues.clear();
	// newValues.addAll(newVals);
	// }

	// /**
	// * Get the new value for the attribute
	// *
	// * @return The new value
	// */
	// public String getNewValue() {
	// if(newValues.size() > 0) {
	// return values.get(0);
	// } else {
	// return "";
	// }
	// }

	// public List<String> getNewValues() {
	// return newValues;
	// }

	// public boolean isMultiValued() {
	// return newValues.size() > 1;
	// }

	/**
	 * Sets the name of the option used when updating the attribute on the
	 * server
	 * 
	 * @param parameterName
	 *            The name of the option when updating from the server
	 */
	public void setID(String parameterName) {
		this.id = parameterName;
	}

	/**
	 * Adds an attribute option value
	 * 
	 * @param readableValue
	 *            The value displayed on the screen
	 * @param parameterValue
	 *            The option value used when sending the form to the server
	 */
	public void addOptionValue(String readableValue, String parameterValue) {
		optionValues.put(readableValue, parameterValue);
	}

	/**
	 * Determine if the field was hidden or not
	 * 
	 * @return True if the field was hidden
	 */
	public boolean isHidden() {
		return hidden;
	}

	/**
	 * Set whether the field was hidden in the bug
	 * 
	 * @param b
	 *            Whether the field was hidden or not
	 */
	public void setHidden(boolean b) {
		hidden = b;
	}

	public String toString() {
		return getValue();
	}
	
	public boolean hasOptions() {
		return optionValues.size() > 0;
	}

	public void clearOptions() {
		optionValues.clear();
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.bugzilla.core.internal;

import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.BugzillaReportAttribute;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.bugzilla.core.ReportAttachment;
import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

/**
 * Parser for xml bugzilla reports.
 * 
 * @author Rob Elves
 */
public class SaxBugReportContentHandler extends DefaultHandler {

	private StringBuffer characters;

	private Comment comment;

	private int commentNum = 0;

	private ReportAttachment attachment;

	private BugzillaReport report;

	private String errorMessage = null;

	public SaxBugReportContentHandler(BugzillaReport rpt) {
		this.report = rpt;
	}

	public boolean errorOccurred() {
		return errorMessage != null;
	}

	public String getErrorMessage() {
		return errorMessage;
	}

	public BugzillaReport getReport() {
		return report;
	}

	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		characters.append(ch, start, length);
	}

	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		characters = new StringBuffer();
		BugzillaReportElement tag = BugzillaReportElement.UNKNOWN;
		try {
			tag = BugzillaReportElement.valueOf(localName.trim().toUpperCase());
		} catch (RuntimeException e) {
			if (e instanceof IllegalArgumentException) {
				MylarStatusHandler.fail(new Exception(e), "Mylar: Bugzilla report element not known: "
						+ e.getMessage().trim(), false);
				errorMessage = "Mylar: Bugzilla report element not known: " + e.getMessage().trim();
			}
		}
		switch (tag) {
		case BUGZILLA:
			// Note: here we can get the bugzilla version if necessary
			break;
		case BUG:
			if (attributes != null && (attributes.getValue("error") != null)) {
				errorMessage = attributes.getValue("error");
			}
			break;
		case LONG_DESC:
			comment = new Comment(report, commentNum++);
			break;
		case ATTACHMENT:
			attachment = new ReportAttachment();
			if (attributes != null && (attributes.getValue(BugzillaReportElement.IS_OBSOLETE.getKeyString()) != null)) {
				attachment.addAttribute(BugzillaReportElement.IS_OBSOLETE, new BugzillaReportAttribute(
						BugzillaReportElement.IS_OBSOLETE));
			}
			break;
		}

	}

	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		BugzillaReportElement tag = BugzillaReportElement.valueOf(localName.trim().toUpperCase());

		switch (tag) {
		case BUG_ID: {
			try {
				if (report.getId() != Integer.parseInt(characters.toString())) {
					errorMessage = "Requested report number does not match returned report number.";
				}
			} catch (NumberFormatException e) {
				errorMessage = "Bug id from server did not match requested id.";
			}

			AbstractRepositoryReportAttribute attr = report.getAttribute(tag);
			if (attr == null) {
				attr = new BugzillaReportAttribute(tag);
				report.addAttribute(tag, attr);
			}
			attr.setValue(characters.toString());
			break;
		}

			// Comment attributes
		case WHO:
		case BUG_WHEN:
		case THETEXT:
			if (comment != null) {
				BugzillaReportAttribute attr = new BugzillaReportAttribute(tag);
				attr.setValue(characters.toString());
				// System.err.println(">>> "+comment.getNumber()+"
				// "+characters.toString());
				comment.addAttribute(tag, attr);
			}
			break;
		case LONG_DESC:
			if (comment != null) {
				report.addComment(comment);
			}
			break;

		// Attachment attributes
		case ATTACHID:
		case DATE:
		case DESC:
		case FILENAME:
		case CTYPE:
		case TYPE:
			if (attachment != null) {
				BugzillaReportAttribute attr = new BugzillaReportAttribute(tag);
				attr.setValue(characters.toString());
				attachment.addAttribute(tag, attr);
			}
			break;
		case DATA:
			// TODO: Need to figure out under what circumstanceswhen attachments
			// are inline and
			// what to do with them.
			break;
		case ATTACHMENT:
			if (attachment != null) {
				report.addAttachment(attachment);
			}
			break;

		// IGNORED ELEMENTS
		case REPORTER_ACCESSIBLE:
		case CLASSIFICATION_ID:
		case CLASSIFICATION:
		case CCLIST_ACCESSIBLE:
		case EVERCONFIRMED:
		case BUGZILLA:
			break;
		case BUG:
			// Reached end of bug. Need to set LONGDESCLENGTH to number of
			// comments
			AbstractRepositoryReportAttribute numCommentsAttribute = report
					.getAttribute(BugzillaReportElement.LONGDESCLENGTH);
			if (numCommentsAttribute == null) {
				numCommentsAttribute = new BugzillaReportAttribute(BugzillaReportElement.LONGDESCLENGTH);
				numCommentsAttribute.setValue("" + report.getComments().size());
				report.addAttribute(BugzillaReportElement.LONGDESCLENGTH, numCommentsAttribute);
			} else {
				numCommentsAttribute.setValue("" + report.getComments().size());
			}
			break;

		// All others added as report attribute
		default:
			AbstractRepositoryReportAttribute attribute = report.getAttribute(tag);
			if (attribute == null) {
				// System.err.println(">>> Undeclared attribute added: " +
				// tag.toString()+" value: "+characters.toString());
				attribute = new BugzillaReportAttribute(tag);
				attribute.setValue(characters.toString());
				report.addAttribute(tag, attribute);
			} else {
				// System.err.println("Attr: " + attribute.getName() + " = " +
				// characters.toString());
				attribute.addValue(characters.toString());
			}
			break;
		}

	}

}




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.bugzilla.core;

import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.mylar.internal.core.util.MylarStatusHandler;

/**
 * A bug report entered in Bugzilla.
 * 
 * @author Mik Kersten
 * @author Rob Elves
 */
public class BugzillaReport extends AbstractRepositoryReport implements IBugzillaBug, Serializable {

	private static final long serialVersionUID = 310066248657960823L;

	public static final String VAL_STATUS_VERIFIED = "VERIFIED";

	public static final String VAL_STATUS_CLOSED = "CLOSED";

	public static final String VAL_STATUS_RESOLVED = "RESOLVED";

	public static final String VAL_STATUS_NEW = "NEW";

	/** Parser for dates in the report */
	private static SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");

	/** Description of the bug */
	protected String description;

	/** Creation timestamp */
	protected Date created;

	/** Modification timestamp */
	protected Date lastModified = null;

	/** The bugs valid keywords */
	protected List<String> validKeywords;

	/** The operations that can be done on the report */
	protected List<Operation> operations = new ArrayList<Operation>();

	private static final AbstractAttributeFactory attributeFactory = new BugzillaAttributeFactory();

	// /** Bug attributes (status, resolution, etc.) */
	// protected HashMap<String, AbstractRepositoryReportAttribute> attributes =
	// new HashMap<String, AbstractRepositoryReportAttribute>();
	//
	//
	// /** The keys for the bug attributes */
	// protected ArrayList<String> attributeKeys = new ArrayList<String>();

	// /** A list of comments */
	// protected ArrayList<Comment> comments = new ArrayList<Comment>();

	/** The value for the new comment to add (text that is saved) */
	protected String newComment = "";

	// /** The new value for the new comment to add (text from submit editor) */
	// protected String newNewComment = "";

	/** The operation that was selected to do to the bug */
	protected Operation selectedOperation = null;

	/** Whether or not this bug report is saved offline. */
	protected boolean savedOffline = false;

	protected boolean hasChanges = false;

	protected String charset = null;

	// /**
	// * Get the bugs id
	// *
	// * @return The bugs id
	// */
	// public int getId() {
	// return id;
	// }
	//
	// public String getRepositoryUrl() {
	// return repositoryUrl;
	// }

	public BugzillaReport(int id, String repositoryURL) {
		super(id, repositoryURL);

	}

	/**
	 * TODO: move?
	 */
	public static boolean isResolvedStatus(String status) {
		if (status != null) {
			return status.equals(VAL_STATUS_RESOLVED) || status.equals(VAL_STATUS_CLOSED)
					|| status.equals(VAL_STATUS_VERIFIED);
		} else {
			return false;
		}
	}

	public void addCC(String email) {
		addAttributeValue(BugzillaReportElement.CC, email);
	}

	/**
	 * Add an operation to the bug
	 * 
	 * @param o
	 *            The operation to add
	 */
	public void addOperation(Operation o) {
		operations.add(o);
	}

	/**
	 * Get the person to whom this bug is assigned
	 * 
	 * @return The person who is assigned to this bug
	 */
	public String getAssignedTo() {
		return getAttributeValue(BugzillaReportElement.ASSIGNED_TO);
	}

	// public AbstractRepositoryReportAttribute
	// getAttributeForKnobName(BugzillaReportElement element) {
	// return super.getAttribute(element.getKeyString());
	// }

	// private String decodeStringFromCharset(String string) {
	// String decoded = string;
	// if (charset != null && string != null &&
	// Charset.availableCharsets().containsKey(charset)) {
	// try {
	// decoded = new String(string.getBytes(), charset);
	// } catch (UnsupportedEncodingException e) {
	// // ignore
	// }
	// }
	// return decoded;
	// }

	/**
	 * Get the set of addresses in the CC list
	 * 
	 * @return A <code>Set</code> of addresses in the CC list
	 */
	public List<String> getCC() {
		return getAttributeValues(BugzillaReportElement.CC);
	}

	/**
	 * Get the date that the bug was created
	 * 
	 * @return The bugs creation date
	 */
	public Date getCreated() {
		if (created == null) {
			String dateString = getAttributeValue(BugzillaReportElement.CREATION_TS);
			try {
				created = df.parse(dateString);
			} catch (Exception e) {
				MylarStatusHandler.fail(e, "Mylar: Unable to parse report #" + getId() + "'s creation date.", false);
			}
		}
		return created;
	}

	/**
	 * Get the bugs description
	 * 
	 * @return The description of the bug
	 */
	public String getDescription() {
		List<Comment> coms = this.getComments();
		if (coms != null && coms.size() > 0) {
			return coms.get(0).getText();
		} else {
			return "";
		}

	}

	// public AbstractRepositoryReportAttribute getAttribute(String key) {
	// return attributes.get(key);
	// }
	//
	// /**
	// * Get the list of attributes for this bug
	// *
	// * @return An <code>ArrayList</code> of the bugs attributes
	// */
	// public List<AbstractRepositoryReportAttribute> getAttributes() {
	// // create an array list to store the attributes in
	// ArrayList<AbstractRepositoryReportAttribute> attributeEntries = new
	// ArrayList<AbstractRepositoryReportAttribute>(attributeKeys.size());
	//
	// // go through each of the attribute keys
	// for (Iterator<String> it = attributeKeys.iterator(); it.hasNext();) {
	// // get the key for the attribute
	// String key = it.next();
	//
	// // get the attribute and add it to the list
	// AbstractRepositoryReportAttribute attribute = attributes.get(key);
	// attributeEntries.add(attribute);
	// }
	//
	// // return the list of attributes for the bug
	// return attributeEntries;
	// }

	// public AbstractRepositoryReportAttribute getAttributeForKnobName(String
	// knobName) {
	// for (Iterator<String> it = attributeKeys.iterator(); it.hasNext();) {
	// String key = it.next();
	//
	// AbstractRepositoryReportAttribute attribute = attributes.get(key);
	// if (attribute != null && attribute.getID() != null
	// && attribute.getID().compareTo(knobName) == 0) {
	// return attribute;
	// }
	// }
	//
	// return null;
	// }

	// /**
	// * @param attribute
	// * The attribute to add to the bug
	// */
	// public void addAttribute(AbstractRepositoryReportAttribute attribute) {
	// if (!attributes.containsKey(attribute.getName())) {
	// attributeKeys.add(attribute.getName());
	// }
	//
	// attribute.setValue(decodeStringFromCharset(attribute.getValue()));
	//
	// // put the value of the attribute into the map, using its name as the
	// // key
	// attributes.put(attribute.getName(), attribute);
	// }

	// /**
	// * Get the comments posted on the bug
	// *
	// * @return A list of comments for the bug
	// */
	// public ArrayList<Comment> getComments() {
	// return comments;
	// }

	// /**
	// * Add a comment to the bug
	// *
	// * @param comment
	// * The comment to add to the bug
	// */
	// public void addComment(Comment comment) {
	// Comment preceding = null;
	// if (comments.size() > 0) {
	// // if there are some comments, get the last comment and set the next
	// // value to be the new comment
	// preceding = comments.get(comments.size() - 1);
	// preceding.setNext(comment);
	// }
	// // set the comments previous value to the preceeding one
	// comment.setPrevious(preceding);
	//
	// comment.setText(decodeStringFromCharset(comment.getText()));
	// // add the comment to the comment list
	// comments.add(comment);
	// }

	/**
	 * Get the keywords for the bug
	 * 
	 * @return The keywords for the bug
	 */
	public List<String> getKeywords() {

		// get the selected keywords for the bug
		StringTokenizer st = new StringTokenizer(getAttributeValue(BugzillaReportElement.KEYWORDS), ",", false);
		List<String> keywords = new ArrayList<String>();
		while (st.hasMoreTokens()) {
			String s = st.nextToken().trim();
			keywords.add(s);
		}

		return keywords;
		//		
		// String[] keywords =
		// getAttributeValue(BugzillaReportElement.KEYWORDS).split(",");
		// return getAttributeValue(BugzillaReportElement.KEYWORDS)
		// BugzillaPlugin.getDefault().getProductConfiguration(repository).getProducts()
		//		
		// return
		// BugzillaRepositoryUtil.getValidKeywords(this.getRepositoryUrl());
	}

	public String getLabel() {
		return getId() + ": " + getAttributeValue(BugzillaReportElement.SHORT_DESC);
	}

	public Date getLastModified() {
		if (lastModified == null) {
			String dateString = getAttributeValue(BugzillaReportElement.DELTA_TS);
			try {
				lastModified = df.parse(dateString);
			} catch (Exception e) {
				MylarStatusHandler
						.fail(e, "Mylar: Unable to parse report #" + getId() + "'s modification date.", false);
			}
		}
		return lastModified;
	}

	/**
	 * Get the new comment that is to be added to the bug
	 * 
	 * @return The new comment
	 */
	public String getNewComment() {
		return newComment;
	}

	// /**
	// * @return the new value of the new NewComment.
	// */
	// public String getNewNewComment() {
	// return newNewComment;
	// }

	/**
	 * Get an operation from the bug based on its display name
	 * 
	 * @param displayText
	 *            The display text for the operation
	 * @return The operation that has the display text
	 */
	public Operation getOperation(String displayText) {
		Iterator<Operation> itr = operations.iterator();
		while (itr.hasNext()) {
			Operation o = itr.next();
			String opName = o.getOperationName();
			opName = opName.replaceAll("</.*>", "");
			opName = opName.replaceAll("<.*>", "");
			if (opName.equals(displayText))
				return o;
		}
		return null;
	}

	/**
	 * Get all of the operations that can be done to the bug
	 * 
	 * @return The operations that can be done to the bug
	 */
	public List<Operation> getOperations() {
		return operations;
	}

	/**
	 * Get the person who reported the bug
	 * 
	 * @return The person who reported the bug
	 */
	public String getReporter() {
		return getAttributeValue(BugzillaReportElement.REPORTER);
	}

	/**
	 * Get the resolution of the bug
	 * 
	 * @return The resolution of the bug
	 */
	public String getResolution() {
		return getAttributeValue(BugzillaReportElement.RESOLUTION);
	}

	/**
	 * Get the status of the bug
	 * 
	 * @return The bugs status
	 */
	public String getStatus() {
		return getAttributeValue(BugzillaReportElement.BUG_STATUS);
	}

	/**
	 * Get the summary for the bug
	 * 
	 * @return The bugs summary
	 */
	public String getSummary() {
		return getAttributeValue(BugzillaReportElement.SHORT_DESC);
	}

	public void setSummary(String summary) {
		setAttributeValue(BugzillaReportElement.SHORT_DESC, summary);
	}

	public String getProduct() {
		return getAttributeValue(BugzillaReportElement.PRODUCT);
	}

	// public void setSummary(String newSummary) {
	// setAttributeValue(BugzillaReportElement.SHORT_DESC, newSummary);
	// }

	public boolean isLocallyCreated() {
		return false;
	}

	public boolean isResolved() {
		AbstractRepositoryReportAttribute status = getAttribute(BugzillaReportElement.BUG_STATUS);
		return status != null && isResolvedStatus(status.getValue());
	}

	public boolean isSavedOffline() {
		return savedOffline;
	}

	/**
	 * Remove an address from the bugs CC list
	 * 
	 * @param email
	 *            the address to be removed from the CC list
	 * @return <code>true</code> if the email is in the set and it was removed
	 */
	public void removeCC(String email) {
		removeAttributeValue(BugzillaReportElement.CC, email);
	}

	// /**
	// * Set the bugs creation date
	// *
	// * @param created
	// * The date the the bug was created
	// */
	// public void setCreated(Date created) {
	// this.created = created;
	// }

	public void setDescription(String description) {
		// ignore, used by NewBugReport
		// this.description = decodeStringFromCharset(description);
	}

	public void setKeywords(List<String> keywords) {
		this.validKeywords = keywords;
	}

	// public void setLastModified(Date date) {
	// this.lastModified = date;
	// }

	/**
	 * Set the new comment that will be added to the bug
	 * 
	 * @param newComment
	 *            The new comment to add to the bug
	 */
	public void setNewComment(String newComment) {
		this.newComment = newComment;
		// newNewComment = newComment;
	}

	// /**
	// * Set the new value of the new NewComment
	// *
	// * @param newNewComment
	// * The new value of the new NewComment.
	// */
	// public void setNewNewComment(String newNewComment) {
	// this.newNewComment = newNewComment;
	// }

	public void setOfflineState(boolean newOfflineState) {
		savedOffline = newOfflineState;
	}

	public void setSelectedOperation(Operation o) {
		selectedOperation = o;
	}

	public Operation getSelectedOperation() {
		return selectedOperation;
	}

	@Override
	public AbstractAttributeFactory getAttributeFactory() {
		return attributeFactory;
	}

	public AbstractRepositoryReportAttribute getAttribute(String test) {

		MylarStatusHandler.fail(new Exception(), "BugReport: getAttribute called with string", false);
		return new BugzillaReportAttribute(BugzillaReportElement.UNKNOWN);
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.bugzilla.core.internal;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;

import javax.security.auth.login.LoginException;

import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;

/**
 * Reads bug reports from repository.
 * 
 * @author Rob Elves
 */
public class RepositoryReportFactory {

	private static RepositoryReportFactory instance;

	private static final String SHOW_BUG_CGI_XML = "/show_bug.cgi?ctype=xml&id=";

	private static final String ATTR_CHARSET = "charset";

	private RepositoryReportFactory() {
		// no initial setup needed
	}

	public static RepositoryReportFactory getInstance() {
		if (instance == null) {
			instance = new RepositoryReportFactory();
		}
		return instance;
	}

	// /**
	// * Bugzilla specific, to be generalized
	// * TODO: Based on repository kind use appropriate loader
	// */
	// public AbstractRepositoryReport readReport(int id, TaskRepository
	// repository)
	// throws IOException, LoginException {
	// BugReport bugReport = new BugReport(id, repository.getUrl());
	// SaxBugReportContentHandler contentHandler = new
	// SaxBugReportContentHandler(bugReport);
	//
	// String xmlBugReportUrl = repository.getUrl() + SHOW_BUG_CGI_XML + id;
	//
	// URL serverURL = new URL(BugzillaRepositoryUtil.addCredentials(repository,
	// xmlBugReportUrl));
	// URLConnection connection = serverURL.openConnection();
	// String contentType = connection.getContentType();
	// if (contentType != null) {
	// String charsetFromContentType = getCharsetFromString(contentType);
	// if (charsetFromContentType != null) {
	// bugReport.setCharset(charsetFromContentType);
	// }
	// }
	//		
	// BufferedReader in = new BufferedReader(new
	// InputStreamReader(connection.getInputStream()));
	//
	// try {
	// XMLReader reader = XMLReaderFactory.createXMLReader();
	// reader.setContentHandler(contentHandler);
	// reader.setErrorHandler(new SaxErrorHandler());
	// reader.parse(new InputSource(in));
	//			
	// if(contentHandler.errorOccurred()) {
	// throw new BugzillaReportParseException(contentHandler.getErrorMessage());
	// }
	//			
	// } catch (SAXException e) {
	// throw new IOException(e.getMessage());
	// }
	// return bugReport;
	// }

	/**
	 * Bugzilla specific, to be generalized TODO: Based on repository kind use
	 * appropriate loader
	 */
	public void populateReport(BugzillaReport bugReport, TaskRepository repository) throws IOException, LoginException {

		SaxBugReportContentHandler contentHandler = new SaxBugReportContentHandler(bugReport);

		String xmlBugReportUrl = repository.getUrl() + SHOW_BUG_CGI_XML + bugReport.getId();

		URL serverURL = new URL(BugzillaRepositoryUtil.addCredentials(repository, xmlBugReportUrl));
		URLConnection connection = serverURL.openConnection();
		String contentType = connection.getContentType();
		if (contentType != null) {
			String charsetFromContentType = getCharsetFromString(contentType);
			if (charsetFromContentType != null) {
				bugReport.setCharset(charsetFromContentType);
			}
		}

		BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));

		try {
			XMLReader reader = XMLReaderFactory.createXMLReader();
			reader.setContentHandler(contentHandler);
			reader.setErrorHandler(new SaxErrorHandler());
			reader.parse(new InputSource(in));

			if (contentHandler.errorOccurred()) {
				throw new BugzillaReportParseException(contentHandler.getErrorMessage());
			}

		} catch (SAXException e) {
			throw new IOException(e.getMessage());
		}
	}

	// TODO: pull up
	public static String getCharsetFromString(String string) {
		int charsetStartIndex = string.indexOf(ATTR_CHARSET);
		if (charsetStartIndex != -1) {
			int charsetEndIndex = string.indexOf("\"", charsetStartIndex); // TODO:
			// could
			// be
			// space
			// after?
			if (charsetEndIndex == -1) {
				charsetEndIndex = string.length();
			}
			String charsetString = string.substring(charsetStartIndex + 8, charsetEndIndex);
			if (Charset.availableCharsets().containsKey(charsetString)) {
				return charsetString;
			}
		}
		return null;
	}

	class SaxErrorHandler implements ErrorHandler {

		public void error(SAXParseException exception) throws SAXException {
			System.err.println("Error: " + exception.getLineNumber() + "\n" + exception.getLocalizedMessage());

		}

		public void fatalError(SAXParseException exception) throws SAXException {
			// System.err.println("Fatal Error: " + exception.getLineNumber() +
			// "\n" + exception.getLocalizedMessage());
			// TODO: Need to determine actual error from html
			throw new SAXException(IBugzillaConstants.ERROR_INVALID_USERNAME_OR_PASSWORD);
		}

		public void warning(SAXParseException exception) throws SAXException {
			System.err.println("Warning: " + exception.getLineNumber() + "\n" + exception.getLocalizedMessage());

		}

	}

	public class BugzillaReportParseException extends IOException {

		private static final long serialVersionUID = 7269179766737288564L;

		public BugzillaReportParseException(String message) {
			super(message);
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.core;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

public class AttributeContainer implements Serializable {
	
	private static final long serialVersionUID = -3990742719133977940L;

	/** The keys for the report attributes */
	private ArrayList<Object> attributeKeys;

	/** report attributes (status, resolution, etc.) */
	private HashMap<Object, AbstractRepositoryReportAttribute> attributes;
	
	public AttributeContainer() {
		attributeKeys = new ArrayList<Object>();
		attributes = new HashMap<Object, AbstractRepositoryReportAttribute>();
	}
	
	public void addAttribute(Object key, AbstractRepositoryReportAttribute attribute) {
		if (!attributes.containsKey(attribute.getName())) {
			attributeKeys.add(key);
		}

		// TODO: deal with character sets
		//attribute.setValue(decodeStringFromCharset(attribute.getValue()));

		attributes.put(key, attribute);
	}
	
	public AbstractRepositoryReportAttribute getAttribute(Object key) {
		return attributes.get(key);
	}

	public void removeAttribute(Object key) {
		attributeKeys.remove(key);
		attributes.remove(key);
	}
	
	public List<AbstractRepositoryReportAttribute> getAttributes() {
		ArrayList<AbstractRepositoryReportAttribute> attributeEntries = new ArrayList<AbstractRepositoryReportAttribute>(
				attributeKeys.size());
		for (Iterator<Object> it = attributeKeys.iterator(); it.hasNext();) {
			Object key = it.next();
			AbstractRepositoryReportAttribute attribute = attributes.get(key);
			attributeEntries.add(attribute);
		}
		return attributeEntries;
	}

	public String getAttributeValue(Object key) {
		AbstractRepositoryReportAttribute attribute = getAttribute(key);
		if(attribute != null) {
			return attribute.getValue();
		}
		return "";
	}
}

Lines 26-32 Link Here

(-)src/org/eclipse/mylar/tests/misc/AllMiscTests.java (-1 / +1 lines)
26	// suite.addTestSuite(BugzillaSearchPluginTest.class);	26	// suite.addTestSuite(BugzillaSearchPluginTest.class);
27	suite.addTestSuite(AssertionsEnabledTest.class);	27	suite.addTestSuite(AssertionsEnabledTest.class);
28	suite.addTestSuite(HypertextStructureBridgeTest.class);	28	suite.addTestSuite(HypertextStructureBridgeTest.class);
29	suite.addTestSuite(BugzillaStackTraceTest.class);	29	//suite.addTestSuite(BugzillaStackTraceTest.class);
30	// $JUnit-END$	30	// $JUnit-END$
31	return suite;	31	return suite;
32	}	32	}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
////Created on Oct 12, 2004
package org.eclipse.mylar.tests.misc;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.tests.BugzillaTestPlugin;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugs.search.BugzillaMylarSearchOperation;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;
import org.eclipse.mylar.internal.bugzilla.core.search.BugzillaSearchHit;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaReportNode;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.StackTrace;

/**
 * Class to test the Bridge methods that do not require server queries
 * 
 * @author Shawn Minto
 */
public class BugzillaStackTraceTest extends TestCase {

	private static final String TEST_FILE_LOC = "testdata/reports-stacktrace/";

	private static final String BUGZILLA_SERVER_NAME = "https://bugs.eclipse.org/bugs";

	/**
	 * Test that the regular expression escaping mechanism works properly
	 */
	public void testREGEX() {
		String r = ".*+(){}[]^$|?/\\";
		String r2 = StackTrace.escapeForRegex(r);
		String ans = "\\.\\*\\+\\(\\)\\{\\}\\[\\]\\^\\$\\|\\?\\/\\\\";
		String msg = "Regular Expression matching wrong:\nwas: " + r2 + "\nshould be:" + ans;
		assertTrue(msg, r2.equals(ans));
	}

	// /**
	// * Test parsing the bug for multiple stacks in in
	// */
	// public void testMultipleStacksDiffComments(){
	// // REPORT_REPOSITORY 4862 - 2 stack traces - 1 in description, 1 in
	// comment - text
	// before and after
	// performParse(4862, "4862.html", 2, false);
	// }

	// /**
	// * Test parsing the bug for a single stack in the description with some
	// * text before it
	// */
	// public void testSingleStackCodeBeforeInDescription(){
	// // REPORT_REPOSITORY 76388 - 1 stack trace - description - text before
	// and formatted
	// ugly
	// performParse(76388, "76388.html", 1, false);
	// }

	/**
	 * Test parsing the bug for a single stack trace in the description with
	 * text before and after it
	 */
	public void testSingleStackCodeBeforeAndAfterInDescription() {

		// REPORT_REPOSITORY 76146 - 1 stack trace - description - text before
		// and code after
		performParse(76146, "76146.html", 1, false);
	}

	/**
	 * Test parsing a bug that has 1 stack trace in the description with no
	 * extra text, but has lines in it that span 3 lines
	 */
	public void testSingleStackPoorFormatInDescription() {
		// REPORT_REPOSITORY 67395 - 1 stack trace - description - no extra
		// text, 1 at line
		// spans 3 lines
		performParse(67395, "67395.html", 1, false);
	}

	/**
	 * Test parsing a bug with no stack traces and no qualified exception names
	 */
	public void testNoStackNoQualified() {
		// REPORT_REPOSITORY 4548 - no stack traces, no qualified reference to
		// an exception
		performParse(4548, "4548.html", 0, false);
	}

	/**
	 * Test parsing a bug with no stack traces, but a qualified reference to an
	 * exception
	 */
	public void testNoStackQual() {
		// REPORT_REPOSITORY 1 - no stack traces, qualified reference to
		// exception - made up
		// bug
		performParse(1, "1.html", 0, false);
	}

	/**
	 * Test parsing of a bug with 1 stack trace and multiple qualified
	 * references
	 */
	public void testSingleStackQual() {
		// REPORT_REPOSITORY 2 - 1 stack trace- 2 qual ref, stack trace, 1 qual
		// ref - made up
		// bug
		performParse(2, "2.html", 1, false);
	}

	/**
	 * Test parsing of a bug with many stacks traces in a single comment
	 */
	public void testMultipleStackSingleComment() {
		// REPORT_REPOSITORY 40152 - 1 stack trace- 2 qual ref, stack trace, 1
		// qual ref - made
		// up bug
		performParse(40152, "40152.html", 33, false);
	}

	/**
	 * Print out the stack traces
	 * 
	 * @param l
	 *            List of stack traces
	 */
	private void printStackTraces(List<StackTrace> l) {
		System.out.println("\n\n");
		for (int i = 0; i < l.size(); i++) {
			StackTrace trace = l.get(i);
			System.out.println("*****************?????????????????*****************\n");
			System.out.println("OFFSET: " + trace.getOffset() + " LENGTH: " + trace.getLength());
			System.out.println(trace.getStackTrace());
			System.out.println("*****************?????????????????*****************\n\n");
		}
	}

	private void performParse(int bugNumber, String bugFileName, int numTracesExpected, boolean printStackTraces) {

		BugzillaSearchHit hit = new BugzillaSearchHit("<TEST-SERVER>", bugNumber, "", "", "", "", "", "", "", ""); // stack
		// trace
		// in
		// desc
		// and
		// com

		// create a new doi info
		BugzillaReportNode doi = new BugzillaReportNode(0, hit, false);
		try {

			// read the bug in from a file
			File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(TEST_FILE_LOC + bugFileName)); // used
			// if
			// run
			// as a
			// plugin
			// test
			// File f = new File(TEST_FILE_LOC+bugFileName); // used if run as a
			// standalone test
			Reader reader = new FileReader(f);
			doi.setBug(BugParser.parseBug(reader, hit.getId(), BUGZILLA_SERVER_NAME, true, null, null, null));
			reader.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

		// do a second pass parse on the bug
		List<BugzillaReportNode> l = new ArrayList<BugzillaReportNode>();
		l.add(doi);
		BugzillaMylarSearchOperation.secondPassBugzillaParser(l);

		// make sure that we received the right number of stack traces back
		// System.out.println("*** REPORT_REPOSITORY " + hit.getId() + " ***");
		// System.out.println("NumStackTraces = " +
		// doi.getStackTraces().size());
		assertEquals("Wrong Number stack traces", numTracesExpected, doi.getStackTraces().size());
		if (printStackTraces)
			printStackTraces(doi.getStackTraces());
	}
}




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;

/**
 * Tests for parsing Bugzilla reports
 */
public class BugzillaParserTestNoBug extends TestCase {

	public BugzillaParserTestNoBug() {
		super();
	}

	public BugzillaParserTestNoBug(String arg0) {
		super(arg0);
	}

	public void testBugNotFound() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
				"testdata/pages/bug-not-found-eclipse.html"));

		Reader in = new FileReader(f);

		BugReport bug = BugParser.parseBug(in, 666, "<server>", false, null, null, null);
		assertNull(bug);
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes
 */
public class BugzillaNewBugParserTestVE extends TestCase {

	public BugzillaNewBugParserTestVE() {
		super();
	}

	public BugzillaNewBugParserTestVE(String arg0) {
		super(arg0);
	}

	public void testProductVE() throws Exception {
		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/ve-page.html"));

		Reader in = new FileReader(f);

		NewBugzillaReport nbm = new NewBugzillaReport();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this but model
		List<AbstractRepositoryReportAttribute> attributes = nbm.getAttributes();
		// printList(attributes);

		Iterator<AbstractRepositoryReportAttribute> itr = attributes.iterator();
		AbstractRepositoryReportAttribute att = itr.next();

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: product", "product", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No product options", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No AssignedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# of options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		// attOptions = (HashMap) att.getOptionValues();
		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Version options", 3, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "0.5.0", options[i++]);
			assertEquals("Version options", "1.0.0", options[i++]);
			assertEquals("Version options", "unspecified", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Component options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "CDE", options[i++]);
			assertEquals("Component options", "Doc", options[i++]);
			assertEquals("Component options", "Java Core", options[i++]);
			assertEquals("Component options", "Java Model (JEM)", options[i++]);
			assertEquals("Component options", "JFC/Swing", options[i++]);
			assertEquals("Component options", "SWT", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_status options", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);

	}

	// private void printList(List<Attribute> attributes) {
	//
	// Iterator<Attribute> itr = attributes.iterator();
	// System.out.println("Attributes for this Product:");
	// System.out.println("============================");
	//
	// while (itr.hasNext()) {
	// Attribute attr = itr.next();
	// System.out.println();
	// System.out.println(attr.getName() + ": ");
	// System.out.println("-----------");
	//
	// Map<String, String> options = attr.getOptionValues();
	// Object[] it = options.keySet().toArray();
	// for (int i = 0; i < it.length; i++)
	// System.out.println((String) it[i]);
	// }
	// }
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes
 */
public class BugzillaNewBugParserTestPlatform extends TestCase {

	public BugzillaNewBugParserTestPlatform() {
		super();
	}

	public BugzillaNewBugParserTestPlatform(String arg0) {
		super(arg0);
	}

	public void testProductPlatform() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(),
				new Path("testdata/pages/platform-page.html"));

		Reader in = new FileReader(f);

		NewBugzillaReport nbm = new NewBugzillaReport();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this bug model
		List<AbstractRepositoryReportAttribute> attributes = nbm.getAttributes();
		// printList(attributes);

		// to iterator over the ArrayList of attributes
		Iterator<AbstractRepositoryReportAttribute> itr = attributes.iterator();

		// Attribute: Severity
		AbstractRepositoryReportAttribute att = itr.next(); // current attribute

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: product", "product", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No product optins", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: Assigned To", "Assigned To", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No AssingedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# OS options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# Version options", 8, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "1.0", options[i++]);
			assertEquals("Version options", "2.0", options[i++]);
			assertEquals("Version options", "2.0.1", options[i++]);
			assertEquals("Version options", "2.0.2", options[i++]);
			assertEquals("Version options", "2.1", options[i++]);
			assertEquals("Version options", "2.1.1", options[i++]);
			assertEquals("Version options", "2.1.2", options[i++]);
			assertEquals("Version options", "3.0", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		// Attribute: Component
		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# Component options", 16, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "Ant", options[i++]);
			assertEquals("Component options", "Compare", options[i++]);
			assertEquals("Component options", "Core", options[i++]);
			assertEquals("Component options", "CVS", options[i++]);
			assertEquals("Component options", "Debug", options[i++]);
			assertEquals("Component options", "Doc", options[i++]);
			assertEquals("Component options", "Help", options[i++]);
			assertEquals("Component options", "Releng", options[i++]);
			assertEquals("Component options", "Scripting", options[i++]);
			assertEquals("Component options", "Search", options[i++]);
			assertEquals("Component options", "SWT", options[i++]);
			assertEquals("Component options", "Team", options[i++]);
			assertEquals("Component options", "Text", options[i++]);
			assertEquals("Component options", "UI", options[i++]);
			assertEquals("Component options", "Update", options[i++]);
			assertEquals("Component options", "WebDAV", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No bug_status options", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);
	}

	// private void printList(List<Attribute> attributes) {
	//
	// Iterator<Attribute> itr = attributes.iterator();
	// System.out.println("Attributes for this Product:");
	// System.out.println("============================");
	//
	// while (itr.hasNext()) {
	// Attribute attr = itr.next();
	// System.out.println();
	// System.out.println(attr.getName() + ": ");
	// System.out.println("-----------");
	//
	// Map<String, String> options = attr.getOptionValues();
	// Object[] it = options.keySet().toArray();
	// for (int i = 0; i < it.length; i++)
	// System.out.println((String) it[i]);
	// }
	// }
}




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;

/**
 * Tests for parsing Bugzilla reports
 */
public class BugzillaParserTest extends TestCase {

	public BugzillaParserTest() {
		super();
	}

	public BugzillaParserTest(String arg0) {
		super(arg0);
	}

	public void testFullReportBug1() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/bug-1-full.html"));

		Reader in = new FileReader(f);

		BugReport bug = BugParser.parseBug(in, 1, "<server>", false, null, null, null);

		// displayBug(bug);
		assertEquals("Bug id", 1, bug.getId());
		assertEquals("Bug summary", "Usability issue with external editors (1GE6IRL)", bug.getSummary());
		assertEquals("Reporter", "andre_weinand@ch.ibm.com (Andre Weinand)", bug.getReporter());
		assertEquals("Reporter", "andre_weinand@ch.ibm.com (Andre Weinand)", bug.getAttribute("Reporter").getValue());
		assertEquals("Summary", "Usability issue with external editors (1GE6IRL)", bug.getSummary());
		assertEquals("Status", "VERIFIED", bug.getStatus());
		assertEquals("Resolution", "FIXED", bug.getResolution());
		assertEquals("Keywords", null, bug.getKeywords());
		assertEquals("Assigned To", "James_Moody@ca.ibm.com (James Moody)", bug.getAssignedTo());
		assertEquals("Priority", "P3", bug.getAttribute("Priority").getValue());
		assertEquals("OS", "All", bug.getAttribute("OS").getValue());
		assertEquals("Version", "2.0", bug.getAttribute("Version").getValue());
		assertEquals("Target Milestone", "---", bug.getAttribute("Target Milestone").getValue());
		assertEquals("Keywords", "", bug.getAttribute("Keywords").getValue());
		assertEquals("Severity", "normal", bug.getAttribute("Severity").getValue());
		assertEquals("Component", "VCM", bug.getAttribute("Component").getValue());
		assertEquals("CC", "Kevin_McGuire@oti.com", bug.getCC().iterator().next());
		assertEquals("Platform", "All", bug.getAttribute("Platform").getValue());
		assertEquals("Product", "Platform", bug.getAttribute("Product").getValue());
		assertEquals("URL", "", bug.getAttribute("URL").getValue());
		assertEquals("Bug#", "1", bug.getAttribute("Bug#").getValue());

		// Description
		String description = "- Setup a project that contains a *.gif resource\n"
				+ "\t- release project to CVS\n"
				+ "\t- edit the *.gif resource with an external editor, e.g. PaintShop\n"
				+ "\t- save and close external editor\n"
				+ "\t- in Navigator open the icon resource and verify that your changes are there\n"
				+ "\t- release project\n"
				+ "\t\t-> nothing to release!\n"
				+ "\t- in Navigator open the icon resource and verify that your changes are still there\n\n"
				+

				"\tProblem: because I never \"Refreshed from local\", the workspace hasn't changed so \"Release\" didn't find anything.\n"
				+ "\tHowever opening the resource with an external editor found the modified file on disk and showed the changes.\n\n"
				+

				"\tThe real problem occurs if \"Release\" actually finds something to release but you don't spot that some resources are missing.\n"
				+ "\tThis is extremely error prone: one of my changes didn't made it into build 110 because of this!\n\n"
				+

				"NOTES:\n"
				+ "EG (5/23/01 3:00:33 PM)\n"
				+ "\tRelease should do a refresh from local before doing the release.\n"
				+ "\tMoving to VCM\n\n\n"
				+

				"KM (05/27/01 5:10:19 PM)\n"
				+ "\tComments from JM in related email:\n\n"
				+

				"\tShould not do this for free.  Could have a setting which made it optoinal but should nt be mandatory.  Default setting could be to have it on.\n"
				+ "\tConsider the SWT team who keep their workspaces on network drives.  This will be slow.  \n\n"
				+

				"\tSide effects will be that a build runs when the refresh is completed unless you somehow do it in a workspace runnable and don't end the\n"
				+ "\trunnable until after the release.  This would be less than optimal as some builders may be responsible for maintaining some invariants and deriving resources which are releasable.  If you don't run the builders before releasing, the invariants will not be maintained and you will release inconsistent state.\n\n"
				+

				"\tSummary:  Offer to \"ensure local consistency\" before releasing.\n\n" +

				"KM (5/31/01 1:30:35 PM)\n"
				+ "\tSee also 1GEAG1A: ITPVCM:WINNT - Internal error comparing with a document\n"
				+ "\twhich failed with an error.  Never got log from Tod though.";

		assert (description.length() == bug.getDescription().length());
		assertEquals("Description", description, bug.getDescription());

		// Comments:
		Iterator<Comment> it = bug.getComments().iterator();
		while (it.hasNext()) {
			// COMMENT #1
			Comment comment = it.next();
			assertEquals("Author1", "James_Moody@ca.ibm.com", comment.getAuthor());
			assertEquals("Name1", "James Moody", comment.getAuthorName());
			assertEquals("Text1", "*** Bug 183 has been marked as a duplicate of this bug. ***", comment.getText());

			// COMMENT #2
			comment = it.next();
			assertEquals("Author2", "James_Moody@ca.ibm.com", comment.getAuthor());
			assertEquals("Name2", "James Moody", comment.getAuthorName());
			assertEquals("Text2", "Implemented 'auto refresh' option. Default value is off.", comment.getText());

			// COMMENT 3
			comment = it.next();
			assertEquals("Author3", "dj_houghton@ca.ibm.com", comment.getAuthor());
			assertEquals("Name3", "DJ Houghton", comment.getAuthorName());
			assertEquals("Text3", "PRODUCT VERSION:\n\t109\n\n", comment.getText());

			// COMMENT 4
			comment = it.next();
			assertEquals("Author4", "James_Moody@ca.ibm.com", comment.getAuthor());
			assertEquals("Name4", "James Moody", comment.getAuthorName());
			assertEquals("Text4", "Fixed in v206", comment.getText());
		}
	}

	// private static void displayBug(BugReport bug) {
	// System.out.println("Bug " + bug.getId() + ": " + bug.getSummary());
	// System.out.println("Opened: " + bug.getCreated());
	// for (Iterator<Attribute> it = bug.getAttributes().iterator();
	// it.hasNext();) {
	// Attribute attribute = it.next();
	// String key = attribute.getName();
	// System.out.println(key + ": " + attribute.getValue()
	// + (attribute.isEditable() ? " [OK]" : " %%"));
	// }
	//
	// System.out.print("CC: ");
	// for (Iterator<String> it = bug.getCC().iterator(); it.hasNext();) {
	// String email = it.next();
	// System.out.print(email + " ");
	// }
	// System.out.println();
	//
	// System.out.println(bug.getDescription());
	// for (Iterator<Comment> it = bug.getComments().iterator(); it.hasNext();)
	// {
	// Comment comment = it.next();
	// System.out.println(comment.getAuthorName() + " <"
	// + comment.getAuthor() + "> (" + comment.getCreated() + ")");
	// System.out.print(comment.getText());
	// System.out.println();
	// }
	// }
	//
	// private static void printComments(BugReport bug) {
	// for (Iterator<Comment> it = bug.getComments().iterator(); it.hasNext();)
	// {
	// Comment comment = it.next();
	// System.out.println("Author: " + comment.getAuthor());
	// System.out.println("Name: " + comment.getAuthorName());
	// System.out.println("Date: " + comment.getCreated());
	// System.out.println("Bug ID: " + comment.getBug().getId());
	// System.out.println("Comment: " + comment.getText());
	// System.out.println();
	// }
	// }
	//
	// /** prints names of attributes */
	// private static void printAttributes(BugReport bug) {
	// System.out.println("ATTRIBUTE KEYS:");
	// for (Iterator<Attribute> it = bug.getAttributes().iterator();
	// it.hasNext();) {
	// Attribute att = it.next();
	// System.out.println(att.getName());
	// }
	// }
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * @author Mik Kersten
 * @author Rob Elves
 */
public class Bugzilla220ParserTest extends TestCase {

	public static final String TEST_SERVER = IBugzillaConstants.ECLIPSE_BUGZILLA_URL;
	
	private static final String PRODUCT_MYLAR = "Mylar";

	private static final String PRODUCT_TEST = "TestProduct";

	public void testId220() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
				"testdata/pages/test-report-220.html"));
		Reader in = new FileReader(f);

		BugReport bug = BugParser.parseBug(in, 7, TEST_SERVER, false, null, null, null);

		assertEquals(7, bug.getId());
		assertEquals("summary", bug.getSummary());
		assertEquals("7", bug.getAttribute("Bug#").getValue());
		assertEquals("7", bug.getAttribute("id").getValue());
	}

	public void testId2201() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
				"testdata/pages/test-report-2201.html"));
		Reader in = new FileReader(f);

		BugReport bug = BugParser.parseBug(in, 125527, TEST_SERVER, false, null, null, null);

		assertEquals(125527, bug.getId());
		assertEquals("bugzilla refresh incorrect for new reports and newly opened hits", bug.getSummary());
		assertEquals("125527", bug.getAttribute("Bug#").getValue());
		assertEquals("125527", bug.getAttribute("id").getValue());
	}

	public void testNewBugProduct220() throws Exception {

		NewBugzillaReport nbm = new NewBugzillaReport();

		File f = FileTool
				.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/enter-bug220.html"));
		Reader in = new FileReader(f);

		new NewBugParser(in).parseBugAttributes(nbm, true);
		assertEquals(PRODUCT_TEST, nbm.getAttribute("product").getValue());
	}

	public void testNewBugProduct2201() throws Exception {

		NewBugzillaReport nbm = new NewBugzillaReport();

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(),
				new Path("testdata/pages/enter-bug2201.html"));
		Reader in = new FileReader(f);

		new NewBugParser(in).parseBugAttributes(nbm, true);
		assertEquals(PRODUCT_MYLAR, nbm.getAttribute("product").getValue());
	}

}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
////Created on Oct 12, 2004
package org.eclipse.mylar.tests.misc;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.tests.BugzillaTestPlugin;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugs.search.BugzillaMylarSearchOperation;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;
import org.eclipse.mylar.internal.bugzilla.core.search.BugzillaSearchHit;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaReportNode;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.StackTrace;

/**
 * Class to test the Bridge methods that do not require server queries
 * 
 * @author Shawn Minto
 */
public class BugzillaStackTraceTest extends TestCase {

	private static final String TEST_FILE_LOC = "testdata/reports-stacktrace/";

	private static final String BUGZILLA_SERVER_NAME = "https://bugs.eclipse.org/bugs";

	/**
	 * Test that the regular expression escaping mechanism works properly
	 */
	public void testREGEX() {
		String r = ".*+(){}[]^$|?/\\";
		String r2 = StackTrace.escapeForRegex(r);
		String ans = "\\.\\*\\+\\(\\)\\{\\}\\[\\]\\^\\$\\|\\?\\/\\\\";
		String msg = "Regular Expression matching wrong:\nwas: " + r2 + "\nshould be:" + ans;
		assertTrue(msg, r2.equals(ans));
	}

	// /**
	// * Test parsing the bug for multiple stacks in in
	// */
	// public void testMultipleStacksDiffComments(){
	// // REPORT_REPOSITORY 4862 - 2 stack traces - 1 in description, 1 in
	// comment - text
	// before and after
	// performParse(4862, "4862.html", 2, false);
	// }

	// /**
	// * Test parsing the bug for a single stack in the description with some
	// * text before it
	// */
	// public void testSingleStackCodeBeforeInDescription(){
	// // REPORT_REPOSITORY 76388 - 1 stack trace - description - text before
	// and formatted
	// ugly
	// performParse(76388, "76388.html", 1, false);
	// }

	/**
	 * Test parsing the bug for a single stack trace in the description with
	 * text before and after it
	 */
	public void testSingleStackCodeBeforeAndAfterInDescription() {

		// REPORT_REPOSITORY 76146 - 1 stack trace - description - text before
		// and code after
		performParse(76146, "76146.html", 1, false);
	}

	/**
	 * Test parsing a bug that has 1 stack trace in the description with no
	 * extra text, but has lines in it that span 3 lines
	 */
	public void testSingleStackPoorFormatInDescription() {
		// REPORT_REPOSITORY 67395 - 1 stack trace - description - no extra
		// text, 1 at line
		// spans 3 lines
		performParse(67395, "67395.html", 1, false);
	}

	/**
	 * Test parsing a bug with no stack traces and no qualified exception names
	 */
	public void testNoStackNoQualified() {
		// REPORT_REPOSITORY 4548 - no stack traces, no qualified reference to
		// an exception
		performParse(4548, "4548.html", 0, false);
	}

	/**
	 * Test parsing a bug with no stack traces, but a qualified reference to an
	 * exception
	 */
	public void testNoStackQual() {
		// REPORT_REPOSITORY 1 - no stack traces, qualified reference to
		// exception - made up
		// bug
		performParse(1, "1.html", 0, false);
	}

	/**
	 * Test parsing of a bug with 1 stack trace and multiple qualified
	 * references
	 */
	public void testSingleStackQual() {
		// REPORT_REPOSITORY 2 - 1 stack trace- 2 qual ref, stack trace, 1 qual
		// ref - made up
		// bug
		performParse(2, "2.html", 1, false);
	}

	/**
	 * Test parsing of a bug with many stacks traces in a single comment
	 */
	public void testMultipleStackSingleComment() {
		// REPORT_REPOSITORY 40152 - 1 stack trace- 2 qual ref, stack trace, 1
		// qual ref - made
		// up bug
		performParse(40152, "40152.html", 33, false);
	}

	/**
	 * Print out the stack traces
	 * 
	 * @param l
	 *            List of stack traces
	 */
	private void printStackTraces(List<StackTrace> l) {
		System.out.println("\n\n");
		for (int i = 0; i < l.size(); i++) {
			StackTrace trace = l.get(i);
			System.out.println("*****************?????????????????*****************\n");
			System.out.println("OFFSET: " + trace.getOffset() + " LENGTH: " + trace.getLength());
			System.out.println(trace.getStackTrace());
			System.out.println("*****************?????????????????*****************\n\n");
		}
	}

	private void performParse(int bugNumber, String bugFileName, int numTracesExpected, boolean printStackTraces) {

		BugzillaSearchHit hit = new BugzillaSearchHit("<TEST-SERVER>", bugNumber, "", "", "", "", "", "", "", ""); // stack
		// trace
		// in
		// desc
		// and
		// com

		// create a new doi info
		BugzillaReportNode doi = new BugzillaReportNode(0, hit, false);
		try {

			// read the bug in from a file
			File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(TEST_FILE_LOC + bugFileName)); // used
			// if
			// run
			// as a
			// plugin
			// test
			// File f = new File(TEST_FILE_LOC+bugFileName); // used if run as a
			// standalone test
			Reader reader = new FileReader(f);
			doi.setBug(BugParser.parseBug(reader, hit.getId(), BUGZILLA_SERVER_NAME, true, null, null, null));
			reader.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

		// do a second pass parse on the bug
		List<BugzillaReportNode> l = new ArrayList<BugzillaReportNode>();
		l.add(doi);
		BugzillaMylarSearchOperation.secondPassBugzillaParser(l);

		// make sure that we received the right number of stack traces back
		// System.out.println("*** REPORT_REPOSITORY " + hit.getId() + " ***");
		// System.out.println("NumStackTraces = " +
		// doi.getStackTraces().size());
		assertEquals("Wrong Number stack traces", numTracesExpected, doi.getStackTraces().size());
		if (printStackTraces)
			printStackTraces(doi.getStackTraces());
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes for new bug reports
 */
public class BugzillaNewBugParserTestCDT extends TestCase {

	public BugzillaNewBugParserTestCDT() {
		super();
	}

	public BugzillaNewBugParserTestCDT(String arg0) {
		super(arg0);
	}

	public void testProductCDT() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/cdt-page.html"));

		Reader in = new FileReader(f);

		NewBugzillaReport nbm = new NewBugzillaReport();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this bug model
		List<AbstractRepositoryReportAttribute> attributes = nbm.getAttributes();
		// printList(attributes);

		Iterator<AbstractRepositoryReportAttribute> itr = attributes.iterator();
		AbstractRepositoryReportAttribute att = itr.next();

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: product", "product", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No product options", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No AssignedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# of options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		// attOptions = (HashMap) att.getOptionValues();
		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Version options", 5, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "1.0", options[i++]);
			assertEquals("Version options", "1.0.1", options[i++]);
			assertEquals("Version options", "1.1", options[i++]);
			assertEquals("Version options", "1.2", options[i++]);
			assertEquals("Version options", "2.0", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		// Attribute: Component
		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Component options", 9, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "CDT-parser", options[i++]);
			assertEquals("Component options", "Core", options[i++]);
			assertEquals("Component options", "Cpp-Extensions", options[i++]);
			assertEquals("Component options", "Debug", options[i++]);
			assertEquals("Component options", "Debug-MI", options[i++]);
			assertEquals("Component options", "Doc", options[i++]);
			assertEquals("Component options", "Generic-Extensions", options[i++]);
			assertEquals("Component options", "Launcher", options[i++]);
			assertEquals("Component options", "UI", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# bug_status options [none]", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);

	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.bugzilla.core.internal;

import java.io.IOException;
import java.io.Reader;
import java.text.ParseException;

import javax.security.auth.login.LoginException;

import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer.Token;

/**
 * @author Shawn Minto
 * 
 * This class parses the valid attribute values for a new bug
 */
class NewBugParser {
	/** Tokenizer used on the stream */
	private HtmlStreamTokenizer tokenizer;

	/** Flag for whether we need to try to get the product or not */
	private static boolean getProd = false;

	public NewBugParser(Reader in) {
		tokenizer = new HtmlStreamTokenizer(in, null);
	}

	/**
	 * Parse the new bugs valid attributes
	 * 
	 * @param nbm
	 *            A reference to a NewBugModel where all of the information is
	 *            stored
	 * @throws IOException
	 * @throws ParseException
	 * @throws LoginException
	 */
	public void parseBugAttributes(NewBugzillaReport nbm, boolean retrieveProducts) throws IOException, ParseException,
			LoginException {
		nbm.attributes.clear(); // clear any attriubtes in bug model from a
		// previous product

		NewBugParser.getProd = retrieveProducts;

		// create a new bug report and set the parser state to the start state
		ParserState state = ParserState.START;
		String attribute = null;

		boolean isTitle = false;
		boolean possibleBadLogin = false;
		boolean isErrorState = false;
		String title = "";
		// Default error message
		String errorMsg = "Bugzilla could not get the needed bug attribute since your login name or password is incorrect.  Please check your settings in the bugzilla preferences.";

		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			// make sure that bugzilla doesn't want us to login
			if (token.getType() == Token.TAG && ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.TITLE
					&& !((HtmlTag) (token.getValue())).isEndTag()) {
				isTitle = true;
				continue;
			}

			if (isTitle) {
				// get all of the data in the title tag to compare with
				if (token.getType() != Token.TAG) {
					title += ((StringBuffer) token.getValue()).toString().toLowerCase() + " ";
					continue;
				} else if (token.getType() == Token.TAG
						&& ((HtmlTag) token.getValue()).getTagType() == HtmlTag.Type.TITLE
						&& ((HtmlTag) token.getValue()).isEndTag()) {
					// check if the title looks like we may have a problem with
					// login
					if (title.indexOf("login") != -1) {
						possibleBadLogin = true; // generic / default msg
						// passed to constructor re:
						// bad login
					}
					if ((title.indexOf("invalid") != -1 && title.indexOf("password") != -1)
							|| title.indexOf("check e-mail") != -1 || title.indexOf("error") != -1) {
						possibleBadLogin = true;
						isErrorState = true; // set flag so appropriate msg
						// is provide for the exception
						errorMsg = ""; // error message will be parsed from
						// error page
					}

					isTitle = false;
					title = "";
				}
				continue;
			}

			// we have found the start of an attribute name
			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();				
				if (tag.getTagType() == HtmlTag.Type.TD && "right".equalsIgnoreCase(tag.getAttribute("align"))) {
					// parse the attribute's name
					attribute = parseAttributeName();
					if(attribute != null && attribute.contains(IBugzillaConstants.INVALID_2201_ATTRIBUTE_IGNORED)) {
						continue;
					}					
					if (attribute == null)
						continue;
					state = ParserState.ATT_VALUE;
					continue;
				}

				if (tag.getTagType() == HtmlTag.Type.TD && "#ff0000".equalsIgnoreCase(tag.getAttribute("bgcolor"))) {
					state = ParserState.ERROR;
					continue;
				}
			}

			// we have found the start of attribute values
			if (state == ParserState.ATT_VALUE && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD) {
					// parse the attribute values
					parseAttributeValue(nbm, attribute);

					state = ParserState.ATT_NAME;
					attribute = null;
					continue;
				}
			}
			// page being parsed contains an Error message
			// parse error message so it can be given to the constructor of the
			// exception
			// so an appropriate error message is displayed
			if (state == ParserState.ERROR && isErrorState) {
				// tag should be text token, not a tag
				// get the error message
				if (token.getType() == Token.TEXT) {
					// get string value of next token to add to error messgage
					// unescape the string so any escape sequences parsed appear
					// unescaped in the details pane
					errorMsg += HtmlStreamTokenizer.unescape(((StringBuffer) token.getValue()).toString()) + " ";
				}
				// expect </font> tag to indicate end of error end msg
				// set next state to continue parsing remainder of page
				else if (token.getType() == Token.TAG
						&& ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.FONT
						&& ((HtmlTag) (token.getValue())).isEndTag()) {
					state = ParserState.ATT_NAME;
				}
				continue;
			}

			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.INPUT && tag.getAttribute("type") != null
						&& "hidden".equalsIgnoreCase(tag.getAttribute("type").trim())) {
					AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(tag.getAttribute("name"));
					a.setID(tag.getAttribute("name"));
					a.setValue(tag.getAttribute("value"));
					a.setHidden(true);
					nbm.attributes.put(a.getName(), a);
					continue;
				}
			}
		}

		if (possibleBadLogin && (nbm.getAttributes() == null || nbm.getAttributes().size() == 0)) {
			throw new LoginException(errorMsg);
		}
	}

	/**
	 * Parse the case where we have found an attribute name
	 * 
	 * @param tokenizer
	 *            The tokenizer to use to find the name
	 * @return The name of the attribute
	 * @throws IOException
	 * @throws ParseException
	 */
	private String parseAttributeName() throws IOException, ParseException {
		StringBuffer sb = new StringBuffer();

		parseTableCell(sb);
		HtmlStreamTokenizer.unescape(sb);
		// remove the colon if there is one
		if (sb.length() == 0)
			return null;
		if (sb.charAt(sb.length() - 1) == ':') {
			sb.deleteCharAt(sb.length() - 1);
		}
		return sb.toString();
	}

	/**
	 * Reads text into a StringBuffer until it encounters a close table cell tag
	 * (&lt;/TD&gt;) or start of another cell. The text is appended to the
	 * existing value of the buffer. <b>NOTE:</b> Does not handle nested cells!
	 * 
	 * @param tokenizer
	 * @param sb
	 * @throws IOException
	 * @throws ParseException
	 */
	private void parseTableCell(StringBuffer sb) throws IOException, ParseException {
		boolean noWhitespace = false;
		for (HtmlStreamTokenizer.Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer
				.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD) {
					if (!tag.isEndTag()) {
						tokenizer.pushback(token);
					}
					break;
				}
				noWhitespace = token.getWhitespace().length() == 0;
			} else if (token.getType() == Token.TEXT) {
				// if there was no whitespace between the tag and the
				// preceding text, don't insert whitespace before this text
				// unless it is there in the source
				if (!noWhitespace && token.getWhitespace().length() > 0 && sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
	}

	/**
	 * Parse the case where we have found attribute values
	 * 
	 * @param nbm
	 *            The NewBugModel that is to contain information about a new bug
	 * @param attributeName
	 *            The name of the attribute that we are parsing
	 * @param tokenizer
	 *            The tokenizer to use for parsing
	 * @throws IOException
	 * @throws ParseException
	 */
	private void parseAttributeValue(NewBugzillaReport nbm, String attributeName) throws IOException, ParseException {

		HtmlStreamTokenizer.Token token = tokenizer.nextToken();
		if (token.getType() == Token.TAG) {
			HtmlTag tag = (HtmlTag) token.getValue();
			if (tag.getTagType() == HtmlTag.Type.SELECT && !tag.isEndTag()) {
				String parameterName = tag.getAttribute("name");
				parseSelect(nbm, attributeName, parameterName);
			} else if (tag.getTagType() == HtmlTag.Type.INPUT && !tag.isEndTag()) {
				parseInput(nbm, attributeName, tag);
			} else if (!tag.isEndTag()) {
				parseAttributeValueCell(nbm, attributeName);
			}
		} else {
			StringBuffer sb = new StringBuffer();
			if (token.getType() == Token.TEXT) {
				sb.append((StringBuffer) token.getValue());
				parseAttributeValueCell(nbm, attributeName, sb);
			}
		}
	}

	/**
	 * Parse the case where the attribute value is just text in a table cell
	 * 
	 * @param attributeName
	 *            The name of the attribute we are parsing
	 * @param tokenizer
	 *            The tokenizer to use for parsing
	 * @throws IOException
	 * @throws ParseException
	 */
	private void parseAttributeValueCell(NewBugzillaReport nbm, String attributeName) throws IOException, ParseException {
		StringBuffer sb = new StringBuffer();

		parseAttributeValueCell(nbm, attributeName, sb);
	}

	private void parseAttributeValueCell(NewBugzillaReport nbm, String attributeName, StringBuffer sb) throws IOException,
			ParseException {

		parseTableCell(sb);
		HtmlStreamTokenizer.unescape(sb);

		// if we need the product we will get it
		if (getProd && attributeName.equalsIgnoreCase("product")) {
			nbm.setProduct(sb.toString());
		}
	}

	/**
	 * Parse the case where the attribute value is an input
	 * 
	 * @param nbm
	 *            The new bug model to add information that we get to
	 * @param attributeName
	 *            The name of the attribute that we are parsing
	 * @param tag
	 *            The HTML tag that we are currently on
	 * @throws IOException
	 */
	private static void parseInput(NewBugzillaReport nbm, String attributeName, HtmlTag tag) throws IOException {

		AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(attributeName);
		a.setID(tag.getAttribute("name"));
		String value = tag.getAttribute("value");
		if (value == null)
			value = "";

		// if we found the summary, add it to the bug report
		if (attributeName.equalsIgnoreCase("summary")) {
			nbm.setSummary(value);
		} else if (attributeName.equalsIgnoreCase("Attachments")) {
			// do nothing - not a problem after 2.14
		} else if (attributeName.equalsIgnoreCase("add cc")) {
			// do nothing
		} else if (attributeName.toLowerCase().startsWith("cc")) {
			// do nothing cc's are options not inputs
		} else {
			// otherwise just add the attribute
			a.setValue(value);
			nbm.attributes.put(attributeName, a);
		}
	}

	/**
	 * Parse the case where the attribute value is an option
	 * 
	 * @param nbm
	 *            The NewBugModel that we are storing information in
	 * @param attributeName
	 *            The name of the attribute that we are parsing
	 * @param parameterName
	 *            The SELECT tag's name
	 * @param tokenizer
	 *            The tokenizer that we are using for parsing
	 * @throws IOException
	 * @throws ParseException
	 */
	private void parseSelect(NewBugzillaReport nbm, String attributeName, String parameterName) throws IOException,
			ParseException {

		boolean first = false;
		AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(attributeName);
		a.setID(parameterName);

		HtmlStreamTokenizer.Token token = tokenizer.nextToken();
		while (token.getType() != Token.EOF) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.SELECT && tag.isEndTag())
					break;
				if (tag.getTagType() == HtmlTag.Type.OPTION && !tag.isEndTag()) {
					String optionName = tag.getAttribute("value");
					boolean selected = tag.hasAttribute("selected");
					StringBuffer optionText = new StringBuffer();
					for (token = tokenizer.nextToken(); token.getType() == Token.TEXT; token = tokenizer.nextToken()) {
						if (optionText.length() > 0) {
							optionText.append(' ');
						}
						optionText.append((StringBuffer) token.getValue());
					}
					a.addOptionValue(optionText.toString(), optionName);

					if (selected || first) {
						a.setValue(optionText.toString());
						first = false;
					}
				} else {
					token = tokenizer.nextToken();
				}
			} else {
				token = tokenizer.nextToken();
			}
		}

		if (!(nbm.attributes).containsKey(attributeName)) {
			(nbm.attributes).put(attributeName, a);
		}
	}

	/**
	 * Enum class for describing current state of Bugzilla report parser.
	 */
	private static class ParserState {
		/** An instance of the start state */
		protected static final ParserState START = new ParserState("start");

		/** An instance of the state when the parser found an attribute name */
		protected static final ParserState ATT_NAME = new ParserState("att_name");

		/** An instance of the state when the parser found an attribute value */
		protected static final ParserState ATT_VALUE = new ParserState("att_value");

		/** An instance of the state when an error page is found */
		protected static final ParserState ERROR = new ParserState("error");

		/** State's human-readable name */
		private String name;

		/**
		 * Constructor
		 * 
		 * @param description -
		 *            The states human readable name
		 */
		private ParserState(String description) {
			this.name = description;
		}

		@Override
		public String toString() {
			return name;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes
 */
public class BugzillaNewBugParserTestGMT extends TestCase {

	public BugzillaNewBugParserTestGMT() {
		super();
	}

	public BugzillaNewBugParserTestGMT(String arg0) {
		super(arg0);
	}

	public void testProductGMT() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/gmt-page.html"));

		Reader in = new FileReader(f);

		NewBugzillaReport nbm = new NewBugzillaReport();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this bug model
		List<AbstractRepositoryReportAttribute> attributes = nbm.getAttributes();
		// printList(attributes);

		Iterator<AbstractRepositoryReportAttribute> itr = attributes.iterator();
		AbstractRepositoryReportAttribute att = itr.next();

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: product", "product", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No product options", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No AssignedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# of options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		// attOptions = (HashMap) att.getOptionValues();
		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Version options", 1, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "unspecified", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Component options", 1, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "Core", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_status options", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);

	}

	// private void printList(List<Attribute> attributes) {
	//
	// Iterator<Attribute> itr = attributes.iterator();
	// System.out.println("Attributes for this Product:");
	// System.out.println("============================");
	//
	// while (itr.hasNext()) {
	// Attribute attr = itr.next();
	// System.out.println();
	// System.out.println(attr.getName() + ": ");
	// System.out.println("-----------");
	//
	// Map<String, String> options = attr.getOptionValues();
	// Object[] it = options.keySet().toArray();
	// for (int i = 0; i < it.length; i++)
	// System.out.println((String) it[i]);
	// }
	// }
}




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.internal.bugzilla.core.internal;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import javax.security.auth.login.LoginException;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.bugzilla.core.Operation;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer.Token;

/**
 * @author Shawn Minto
 * @author Mik Kersten (hardening of prototype)
 * @author Rob Elves (attachments) This class parses bugs so that they can be
 *         displayed using the bug editor
 */
public class BugParser {

	private static final String VALUE_ATTACHMENT_OBSOLETE = "bz_obsolete";

	private static final String ATTRIBUTE_CLASS = "class";

	private static final String TAG_SPAN = "span";

	private static final String ATTRIBUTE_ID_TITLE = "title";

	private static final String ATTRIBUTE_ID_HREF = "href";

	private static final String ATTACHMENT_CGI_ID = "attachment.cgi?id=";

	private static final String KEY_BUG_NUM = "Bug#";

	private static final String KEY_RESOLUTION = "resolution";

	private static final String KEY_VALUE = "value";

	private static final String KEY_NAME = "name";

	private static final String ATTR_CHARSET = "charset";

	/** Parser for dates in the report */
	private static SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");

	private static final String keywordsUrl = "describekeywords.cgi";

	/**
	 * Parse the case where we have found an attribute name
	 * 
	 * @param in
	 *            The input stream for the bug
	 * @return The name of the attribute that we are parsing
	 * @throws IOException
	 */
	private static String parseAttributeName(HtmlStreamTokenizer tokenizer) throws IOException, ParseException {
		StringBuffer sb = new StringBuffer();

		parseTableCell(tokenizer, sb);
		HtmlStreamTokenizer.unescape(sb);
		// remove the colon if there is one
		if (sb.length() > 0 && sb.charAt(sb.length() - 1) == ':') {
			sb.deleteCharAt(sb.length() - 1);
		}
		return sb.toString();
	}

	/**
	 * Parse the case where we have found attribute values
	 * 
	 * @param in
	 *            The input stream of the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @param attribute
	 *            The name of the attribute
	 * @throws IOException
	 */
	private static void parseAttributeValue(BugReport bug, String originalAttributeName, HtmlStreamTokenizer tokenizer,
			String serverUrl, String userName, String password) throws IOException, ParseException {

		// NOTE: special rule to deal with change in 2.20.1
		String attributeName = originalAttributeName;
		if (attributeName.endsWith(KEY_BUG_NUM) && attributeName.length() > KEY_BUG_NUM.length()) {
			attributeName = originalAttributeName.substring(attributeName.length() - KEY_BUG_NUM.length(),
					attributeName.length());
		}

		Token token = tokenizer.nextToken();
		if (token.getType() == Token.TAG) {
			HtmlTag tag = (HtmlTag) token.getValue();

			// make sure that we are on a tag that we care about, not a label
			// fix added so that we can parse the mozilla bug pages
			if (tag.getTagType() == HtmlTag.Type.LABEL) {
				token = tokenizer.nextToken();
				if (token.getType() == Token.TAG)
					tag = (HtmlTag) token.getValue();
				else {
					StringBuffer sb = new StringBuffer();
					if (token.getType() == Token.TEXT) {
						sb.append((StringBuffer) token.getValue());
						parseAttributeValueCell(bug, attributeName, tokenizer, sb);
					}
				}
			}

			if (tag.getTagType() == HtmlTag.Type.SELECT && !tag.isEndTag()) {
				String parameterName = tag.getAttribute(KEY_NAME);
				parseSelect(bug, attributeName, parameterName, tokenizer);
			} else if (tag.getTagType() == HtmlTag.Type.INPUT && !tag.isEndTag()) {
				parseInput(bug, attributeName, tag, serverUrl, userName, password);
			} else if (!tag.isEndTag() || attributeName.equalsIgnoreCase(KEY_RESOLUTION)) {
				if (tag.isEndTag() && attributeName.equalsIgnoreCase(KEY_RESOLUTION)) {
					AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(attributeName);
					a.setValue("");
					bug.addAttribute(a);
				}
				parseAttributeValueCell(bug, attributeName, tokenizer);
			}
		} else {
			StringBuffer sb = new StringBuffer();
			if (token.getType() == Token.TEXT) {
				sb.append((StringBuffer) token.getValue());
				parseAttributeValueCell(bug, attributeName, tokenizer, sb);
			}
		}
	}

	/**
	 * Parse the case where the attribute value is just text in a table cell
	 * 
	 * @param in
	 *            The input stream of the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @param attributeName
	 *            The name of the attribute that we are parsing
	 * @throws IOException
	 */
	private static void parseAttributeValueCell(BugReport bug, String attributeName, HtmlStreamTokenizer tokenizer)
			throws IOException, ParseException {
		StringBuffer sb = new StringBuffer();
		parseAttributeValueCell(bug, attributeName, tokenizer, sb);
	}

	private static void parseAttributeValueCell(BugReport bug, String attributeName, HtmlStreamTokenizer tokenizer,
			StringBuffer sb) throws IOException, ParseException {

		parseTableCell(tokenizer, sb);
		HtmlStreamTokenizer.unescape(sb);

		// create a new attribute and set its value to the value that we
		// retrieved
		AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(attributeName);
		a.setValue(sb.toString());

		// if we found an attachment attribute, forget about it, else add the
		// attribute to the bug report
		if (attributeName.toLowerCase().startsWith("attachments")) {
			// do nothing
		} else {
			if (attributeName.equals(KEY_BUG_NUM))
				a.setValue(a.getValue().replaceFirst("alias:", ""));
			bug.addAttribute(a);
		}
	}

	/**
	 * Reads text into a StringBuffer until it encounters a close table cell tag
	 * (&lt;/TD&gt;) or start of another cell. The text is appended to the
	 * existing value of the buffer. <b>NOTE:</b> Does not handle nested cells!
	 * 
	 * @param tokenizer
	 * @param sb
	 * @throws IOException
	 * @throws ParseException
	 */
	private static void parseTableCell(HtmlStreamTokenizer tokenizer, StringBuffer sb) throws IOException,
			ParseException {
		boolean noWhitespace = false;
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD) {
					if (!tag.isEndTag()) {
						tokenizer.pushback(token);
					}
					break;
				}
				noWhitespace = token.getWhitespace().length() == 0;
			} else if (token.getType() == Token.TEXT) {
				// if there was no whitespace between the tag and the
				// preceding text, don't insert whitespace before this text
				// unless it is there in the source
				if (!noWhitespace && token.getWhitespace().length() > 0 && sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
	}

	/**
	 * Parse the case where the attribute value is an option
	 * 
	 * @param in
	 *            The input stream for the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @param attribute
	 *            The name of the attribute that we are parsing
	 * @param parameterName
	 *            the SELECT tag's name
	 * @throws IOException
	 */
	private static void parseSelect(BugReport bug, String attributeName, String parameterName,
			HtmlStreamTokenizer tokenizer) throws IOException, ParseException {

		boolean first = false;
		AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(attributeName);
		a.setID(parameterName);

		Token token = tokenizer.nextToken();
		while (token.getType() != Token.EOF) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.SELECT && tag.isEndTag())
					break;
				if (tag.getTagType() == HtmlTag.Type.OPTION && !tag.isEndTag()) {
					String optionName = tag.getAttribute(KEY_VALUE);
					boolean selected = tag.hasAttribute("selected");
					StringBuffer optionText = new StringBuffer();
					for (token = tokenizer.nextToken(); token.getType() == Token.TEXT; token = tokenizer.nextToken()) {
						if (optionText.length() > 0) {
							optionText.append(' ');
						}
						optionText.append((StringBuffer) token.getValue());
					}
					a.addOptionValue(optionText.toString(), optionName);
					if (selected || first) {
						a.setValue(optionText.toString());
						first = false;
					}
				} else {
					token = tokenizer.nextToken();
				}
			} else {
				token = tokenizer.nextToken();
			}
		}

		// if we parsed the cc field add the e-mails to the bug report else add
		// the attribute to the bug report
		if (attributeName.toLowerCase().startsWith("cc")) {
			for (Iterator<String> it = a.getOptionValues().keySet().iterator(); it.hasNext();) {
				String email = it.next();
				bug.addCC(HtmlStreamTokenizer.unescape(email));
			}
		} else {
			bug.addAttribute(a);
		}
	}

	/**
	 * Parse the case where the attribute value is an input
	 * 
	 * @param bug
	 *            The bug report for the current bug
	 * @param attributeName
	 *            The name of the attribute
	 * @param tag
	 *            The INPUT tag
	 * @throws IOException
	 */
	private static void parseInput(BugReport bug, String attributeName, HtmlTag tag, String serverUrl, String userName,
			String password) throws IOException {

		AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(attributeName);
		a.setID(tag.getAttribute(KEY_NAME));
		String name = tag.getAttribute(KEY_NAME);
		String value = tag.getAttribute(KEY_VALUE);
		if (value == null)
			value = "";

		// if we found the summary, add it to the bug report
		if (name.equalsIgnoreCase("short_desc")) {
			bug.setSummary(value);
		} else if (name.equalsIgnoreCase("bug_file_loc")) {
			a.setValue(value);
			bug.addAttribute(a);
		} else if (name.equalsIgnoreCase("newcc")) {
			a.setValue(value);
			bug.addAttribute(a);
		} else {
			// otherwise just add the attribute
			a.setValue(value);
			bug.addAttribute(a);

			if (attributeName.equalsIgnoreCase("keywords") && serverUrl != null) {

				BufferedReader input = null;
				try {

					String urlText = "";

					// if we have a user name, may as well log in just in case
					// it is required
					if (userName != null && !userName.equals("") && password != null && !password.equals("")) {
						/*
						 * The UnsupportedEncodingException exception for
						 * URLEncoder.encode() should not be thrown, since every
						 * implementation of the Java platform is required to
						 * support the standard charset "UTF-8"
						 */
						urlText += "?GoAheadAndLogIn=1&Bugzilla_login=" + URLEncoder.encode(userName, "UTF-8")
								+ "&Bugzilla_password=" + URLEncoder.encode(password, "UTF-8");
					}

					// connect to the bugzilla server to get the keyword list
					URL url = new URL(serverUrl + "/" + keywordsUrl + urlText);
					URLConnection urlConnection = BugzillaPlugin.getDefault().getUrlConnection(url);
					input = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));

					// parse the valid keywords and add them to the bug
					List<String> keywords = new KeywordParser(input).getKeywords();
					bug.setKeywords(keywords);

				} catch (Exception e) {
					// throw an exception if there is a problem reading the bug
					// from the server
					throw new IOException("Exception while fetching the list of keywords from the server: "
							+ e.getMessage());
				} finally {
					try {
						if (input != null)
							input.close();
					} catch (IOException e) {
						BugzillaPlugin.log(new Status(IStatus.ERROR, IBugzillaConstants.PLUGIN_ID, IStatus.ERROR,
								"Problem closing the stream", e));
					}
				}
			}
		}
	}

	/**
	 * Parse the case where we are dealing with the description
	 * 
	 * @param bug
	 *            The bug report for the bug
	 * @throws IOException
	 */
	private static void parseDescription(BugReport bug, HtmlStreamTokenizer tokenizer) throws IOException,
			ParseException {

		StringBuffer sb = new StringBuffer();
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (sb.length() > 0) {
					sb.append(token.getWhitespace());
				}
				if (tag.getTagType() == HtmlTag.Type.PRE && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (sb.length() > 0) {
					sb.append(token.getWhitespace());
				}
				sb.append((StringBuffer) token.getValue());
			}
		}

		// set the bug to have the description we retrieved
		String text = HtmlStreamTokenizer.unescape(sb).toString();
		bug.setDescription(text);
	}

	// /**
	// * parses the description of an attachment on the report
	// */
	// private static String parseAttachementDescription(HtmlStreamTokenizer
	// tokenizer) throws IOException,
	// ParseException {
	//
	// StringBuffer sb = new StringBuffer();
	// for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF;
	// token = tokenizer.nextToken()) {
	// if (token.getType() == Token.TAG) {
	// HtmlTag tag = (HtmlTag) token.getValue();
	// if (tag.getTagType() == HtmlTag.Type.A && tag.isEndTag())
	// break;
	// } else if (token.getType() == Token.TEXT) {
	// if (sb.length() > 0) {
	// sb.append(token.getWhitespace());
	// }
	// sb.append((StringBuffer) token.getValue());
	// }
	// }
	//
	// // set the bug to have the description we retrieved
	// String text = HtmlStreamTokenizer.unescape(sb).toString();
	// return text;
	// }

	/**
	 * Parse the case where we have found the start of a comment
	 * 
	 * @param in
	 *            The input stream of the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @return The comment that we have created with the information
	 * @throws IOException
	 * @throws ParseException
	 */
	private static Comment parseCommentHead(BugReport bug, HtmlStreamTokenizer tokenizer) throws IOException,
			ParseException {
		int number = 0;
		Date date = null;
		String author = null;
		String authorName = null;

		// get the comment's number
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.A) {
					String href = tag.getAttribute(ATTRIBUTE_ID_HREF);
					if (href != null) {
						int index = href.toLowerCase().indexOf("#c");
						if (index == -1)
							continue;
						token = tokenizer.nextToken();
						number = Integer.parseInt(((StringBuffer) token.getValue()).toString().substring(1));
						break;
					}
				}
			}
		}

		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.A) {
					String href = tag.getAttribute(ATTRIBUTE_ID_HREF);
					if (href != null) {
						int index = href.toLowerCase().indexOf("mailto");
						if (index == -1)
							continue;
						author = href.substring(index + 7);
						break;
					}
				}
			}
		}

		// get the author's real name
		StringBuffer sb = new StringBuffer();
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.A && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
		authorName = sb.toString();

		// get the comment's date
		sb.setLength(0);
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.I && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
		try {
			if (sb.length() >= 16) {
				date = df.parse(sb.substring(0, 16));
			}
		} catch (Exception e) {
			date = Calendar.getInstance().getTime(); // XXX: could not
			// determine date
		}
		return new Comment(bug, number, date, author, authorName);
	}

	/**
	 * Parse the case where we have comment text
	 * 
	 * @param in
	 *            The input stream for the bug
	 * @param bug
	 *            The bug report for the current bug
	 * @param comment
	 *            The comment to add the text to
	 * @throws IOException
	 */
	private static void parseCommentText(BugReport bug, Comment comment, HtmlStreamTokenizer tokenizer)
			throws IOException, ParseException {

		StringBuffer commentStringBuffer = new StringBuffer();
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagName().equals(TAG_SPAN)) {
					if(tag.hasAttribute(ATTRIBUTE_CLASS) && tag.getAttribute(ATTRIBUTE_CLASS).equals("")) {
						parseAttachment(commentStringBuffer, comment, tokenizer, false);
						continue;
					} else if(tag.hasAttribute(ATTRIBUTE_CLASS) && tag.getAttribute(ATTRIBUTE_CLASS).equals(VALUE_ATTACHMENT_OBSOLETE)) {
						parseAttachment(commentStringBuffer, comment, tokenizer, true);
						continue;
					}
				}
				// added to ensure whitespace is not
				// lost if adding a tag within a tag
				if (commentStringBuffer.length() > 0) {
					commentStringBuffer.append(token.getWhitespace());
				}
				if (tag.getTagType() == HtmlTag.Type.PRE && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (commentStringBuffer.length() > 0) {
					commentStringBuffer.append(token.getWhitespace());
				}
				commentStringBuffer.append((StringBuffer) token.getValue());
			}
			// remove attachment description from comment body
			if (comment.hasAttachment() && commentStringBuffer.indexOf(comment.getAttachmentDescription()) == 0) {
				commentStringBuffer = new StringBuffer();
			}
		}

		HtmlStreamTokenizer.unescape(commentStringBuffer);
		comment.setText(commentStringBuffer.toString());
		bug.addComment(comment);
	}

	private static void parseAttachment(StringBuffer stringBuffer, Comment comment, HtmlStreamTokenizer tokenizer, boolean obsolete)
			throws IOException, ParseException {

		int attachmentID = -1;
		String attachmentDescription = "";
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();

				if (tag.getTagType() == HtmlTag.Type.A && !comment.hasAttachment()) {
					if (tag.getAttribute(ATTRIBUTE_ID_HREF) != null) {
						String link = tag.getAttribute(ATTRIBUTE_ID_HREF);
						if (link.startsWith(ATTACHMENT_CGI_ID)) {
							try {
								int endIndex = link.indexOf("&");
								if (endIndex > 0 && endIndex < link.length()) {
									attachmentID = Integer.parseInt(link
											.substring(ATTACHMENT_CGI_ID.length(), endIndex));
								}
							} catch (NumberFormatException e) {
								return;
							}
						}
						if (tag.getAttribute(ATTRIBUTE_ID_TITLE) != null) {
							attachmentDescription = tag.getAttribute(ATTRIBUTE_ID_TITLE);
						}
						if (attachmentID > 0) {
							comment.setHasAttachment(true);
							comment.setAttachmentId(attachmentID);
							comment.setAttachmentDescription(attachmentDescription);
							comment.setObsolete(obsolete);
						}

					}
				}
				if (tag.getTagName().equals(TAG_SPAN) && tag.isEndTag())
					break;
			}
		}
	}

	/**
	 * Parse the full html version of the bug
	 * 
	 * @param in -
	 *            the input stream for the bug
	 * @param id -
	 *            the id of the bug that is to be parsed
	 * @return A bug report for the bug that was parsed
	 * @throws IOException
	 * @throws ParseException
	 */
	public static BugReport parseBug(Reader in, int id, String serverUrl, boolean is218, String userName,
			String password, String contentType) throws IOException, ParseException, LoginException {
		// create a new bug report and set the parser state to the start state
		BugReport bug = new BugReport(id, serverUrl);
		boolean contentTypeResolved = false;
		if (contentType != null) {
			String charsetFromContentType = getCharsetFromString(contentType);
			if (charsetFromContentType != null) {
				bug.setCharset(charsetFromContentType);
				contentTypeResolved = true;
			}
		}
		ParserState state = ParserState.START;
		Comment comment = null;
		String attribute = null;

		HtmlStreamTokenizer tokenizer = new HtmlStreamTokenizer(in, null);

		boolean isTitle = false;
		boolean possibleBadLogin = false;
		boolean checkBody = false;
		String title = "";
		StringBuffer body = new StringBuffer();

		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {

			// get the charset from the HTML if not specified
			if (!contentTypeResolved) {
				if (token.getType() == Token.TAG && ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.META
						&& !((HtmlTag) (token.getValue())).isEndTag()) {
					String charsetFromHtml = getCharsetFromString(token.toString());
					if (charsetFromHtml != null)
						bug.setCharset(charsetFromHtml);
				}
			}

			// make sure that bugzilla doesn't want us to login
			if (token.getType() == Token.TAG && ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.TITLE
					&& !((HtmlTag) (token.getValue())).isEndTag()) {
				isTitle = true;
				continue;
			}

			if (isTitle) {
				// get all of the data in the title tag
				if (token.getType() != Token.TAG) {
					title += ((StringBuffer) token.getValue()).toString().toLowerCase() + " ";
					continue;
				} else if (token.getType() == Token.TAG
						&& ((HtmlTag) token.getValue()).getTagType() == HtmlTag.Type.TITLE
						&& ((HtmlTag) token.getValue()).isEndTag()) {
					// check and see if the title seems as though we have wrong
					// login info
					if (title.indexOf("login") != -1
							|| (title.indexOf("invalid") != -1 && title.indexOf("password") != -1)
							|| title.indexOf("check e-mail") != -1)
						possibleBadLogin = true; // we possibly have a bad
					// login

					// if the title starts with error, we may have a login
					// problem, or
					// there is a problem with the bug (doesn't exist), so we
					// must do
					// some more checks
					if (title.startsWith("error"))
						checkBody = true;

					isTitle = false;
					title = "";
				}
				continue;
			}

			// if we have to add all of the text so that we can check it later
			// for problems with the username and password
			if (checkBody && token.getType() == Token.TEXT) {
				body.append((StringBuffer) token.getValue());
				body.append(" ");
			}

			// we have found the start of an attribute name
			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD && "right".equalsIgnoreCase(tag.getAttribute("align"))) {
					// parse the attribute's name
					attribute = parseAttributeName(tokenizer);
					if (attribute != null && attribute.contains(IBugzillaConstants.INVALID_2201_ATTRIBUTE_IGNORED)) {
						continue;
					}
					if (attribute.toLowerCase().startsWith("opened")) {
						// find the colon so we can get the date
						int index = attribute.toLowerCase().indexOf(":");
						String date;
						if (index != -1)
							date = attribute.substring(index + 1).trim();
						else
							date = attribute.substring(6).trim();

						// set the bugs opened date to be the date we parsed
						bug.setCreated(df.parse(date));
						state = ParserState.ATT_NAME;
						continue;
					}

					// in 2.18, the last modified looks like the opened so we
					// need to parse it differently
					if (attribute.toLowerCase().startsWith("last modified") && is218) {
						// find the colon so we can get the date
						int index = attribute.toLowerCase().indexOf(":");
						String date;
						if (index != -1)
							date = attribute.substring(index + 1).trim();
						else
							date = attribute.substring(6).trim();

						// create a new attribute and set the date
						AbstractRepositoryReportAttribute t = new AbstractRepositoryReportAttribute("Last Modified");
						t.setValue(date);

						// add the attribute to the bug report
						bug.addAttribute(t);
						bug.setLastModified(df.parse(date));
						state = ParserState.ATT_NAME;
						continue;
					}

					state = ParserState.ATT_VALUE;
					continue;
				} else if (tag.getTagType() == HtmlTag.Type.INPUT && "radio".equalsIgnoreCase(tag.getAttribute("type"))
						&& "knob".equalsIgnoreCase(tag.getAttribute(KEY_NAME))) {
					// we found a radio button
					parseOperations(bug, tokenizer, tag, is218);
				}
			}

			// we have found the start of attribute values
			if (state == ParserState.ATT_VALUE && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD) {
					// parse the attribute values
					parseAttributeValue(bug, attribute, tokenizer, serverUrl, userName, password);

					state = ParserState.ATT_NAME;
					attribute = null;
					continue;
				}
			}

			// we have found the start of a comment
			if (state == ParserState.DESC_START && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.I) {
					// parse the comment's start
					comment = parseCommentHead(bug, tokenizer);

					state = ParserState.DESC_VALUE;
					continue;
				}
			}

			// we have found the start of the comment text
			if (state == ParserState.DESC_VALUE && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.PRE) {
					// parse the text of the comment
					parseCommentText(bug, comment, tokenizer);

					comment = null;
					state = ParserState.DESC_START;
					continue;
				}
			}
			
			// last modification date
			if (bug.getCreated() == null && (state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.DIV && tag.getAttribute("id") != null && "header".equalsIgnoreCase(tag.getAttribute("id"))) {
					StringBuffer sb = new StringBuffer();
					parseLastModified(sb, tokenizer);					
					if(sb.length() > 0) {
						int index = sb.indexOf(":");
						String date;
						if (index != -1)
							date = sb.substring(index + 1).trim();
						else
							date = sb.substring(6).trim();

						// create a new attribute and set the date
						AbstractRepositoryReportAttribute t = new AbstractRepositoryReportAttribute("Last Modified");
						t.setValue(date);

						// add the attribute to the bug report
						bug.setLastModified(df.parse(date));
						bug.addAttribute(t);
					}
					continue;
				}
			}
			

			// look for date opened field
			if (bug.getCreated() == null && (state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD && tag.getAttribute("align") != null && "left".equalsIgnoreCase(tag.getAttribute("align")) && tag.getAttribute("width") != null && "30%".equals(tag.getAttribute("width"))) {
					StringBuffer sb = new StringBuffer();
					parseDateOpened(sb, tokenizer);					
					if(sb.length() > 0) {
						int index = sb.indexOf(":");
						String date;
						if (index != -1)
							date = sb.substring(index + 1).trim();
						else
							date = sb.substring(6).trim();

						// set the bugs opened date to be the date we parsed
						bug.setCreated(df.parse(date));
					}
					continue;
				}
			}

			// we have found the description of the bug
			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.PRE) {
					// parse the description for the bug
					parseDescription(bug, tokenizer);

					state = ParserState.DESC_START;
					continue;
				}
			}

			// parse hidden fields

			if ((state == ParserState.ATT_NAME || state == ParserState.START) && token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.INPUT && tag.getAttribute("type") != null
						&& "hidden".equalsIgnoreCase(tag.getAttribute("type").trim())) {

					AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(tag.getAttribute(KEY_NAME));
					a.setID(tag.getAttribute(KEY_NAME));
					a.setValue(tag.getAttribute(KEY_VALUE));
					a.setHidden(true);
					bug.addAttribute(a);
					continue;
				}
			}

			// // parse out attachments
			// if(token.getType() == Token.TAG) {
			// HtmlTag tag = (HtmlTag) token.getValue();
			// if(tag.getTagType() == HtmlTag.Type.A && tag.getAttribute("href")
			// != null) {
			// String link = tag.getAttribute("href");
			// if(link.startsWith("attachment.cgi?id=") &&
			// !link.contains("action")) {
			// int attachmentID = Integer.parseInt(link.substring(18));
			// String description = parseAttachementDescription(tokenizer);
			// bug.addAttachment(attachmentID, description);
			// }
			// }
			// }

		}

		// if we are to check the body, make sure that there wasn't a bad login
		if (checkBody) {
			String b = body.toString();
			if (b.indexOf("login") != -1
					|| ((b.indexOf("invalid") != -1 || b.indexOf("not valid") != -1) && b.indexOf("password") != -1)
					|| b.indexOf("check e-mail") != -1)
				possibleBadLogin = true; // we possibly have a bad login
		}

		// if there is no summary or created date, we expect that
		// the bug doesn't exist, so set it to null

		// if the bug seems like it doesn't exist, and we suspect a login
		// problem, assume that there was a login problem
		if (bug.getCreated() == null && bug.getAttributes().isEmpty()) {
			if (possibleBadLogin) {
				throw new LoginException(IBugzillaConstants.MESSAGE_LOGIN_FAILURE);
			} else {
				return null;
			}
		}
		// we are done...return the bug
		return bug;
	}

	private static void parseDateOpened(StringBuffer sb, HtmlStreamTokenizer tokenizer) throws IOException, ParseException {
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();
				if (tag.getTagType() == HtmlTag.Type.TD && tag.isEndTag())
					break;
			} else if (token.getType() == Token.TEXT) {
				if (sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
		
	}
	
	private static void parseLastModified(StringBuffer sb, HtmlStreamTokenizer tokenizer) throws IOException, ParseException {
		boolean inH3 = false;
		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				HtmlTag tag = (HtmlTag) token.getValue();				
				if (tag.getTagType() == HtmlTag.Type.H3 && !tag.isEndTag()) {
					inH3 = true;
					continue;
				} else if (tag.getTagType() == HtmlTag.Type.DIV && tag.isEndTag()) {
					break;
				}
			} else if (token.getType() == Token.TEXT && inH3) {
				if (sb.length() > 0) {
					sb.append(' ');
				}
				sb.append((StringBuffer) token.getValue());
			}
		}
		
	}

	public static String getCharsetFromString(String string) {
		int charsetStartIndex = string.indexOf(ATTR_CHARSET);
		if (charsetStartIndex != -1) {
			int charsetEndIndex = string.indexOf("\"", charsetStartIndex); // TODO:
			// could
			// be
			// space
			// after?
			if (charsetEndIndex == -1) {
				charsetEndIndex = string.length();
			}
			String charsetString = string.substring(charsetStartIndex + 8, charsetEndIndex);
			if (Charset.availableCharsets().containsKey(charsetString)) {
				return charsetString;
			}
		}
		return null;
	}

	/**
	 * Parse the operations that are allowed on the bug (Assign, Re-open, fix)
	 * 
	 * @param bug
	 *            The bug to add the operations to
	 * @param tokenizer
	 *            The stream tokenizer for the bug
	 * @param tag
	 *            The last tag that we were on
	 */
	private static void parseOperations(BugReport bug, HtmlStreamTokenizer tokenizer, HtmlTag tag, boolean is218)
			throws ParseException, IOException {

		String knobName = tag.getAttribute(KEY_VALUE);
		boolean isChecked = false;
		if (tag.getAttribute("checked") != null && tag.getAttribute("checked").equals("checked"))
			isChecked = true;
		StringBuffer sb = new StringBuffer();

		Token lastTag = null;

		for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
			if (token.getType() == Token.TAG) {
				tag = (HtmlTag) token.getValue();

				if (!(tag.getTagType() == HtmlTag.Type.A || tag.getTagType() == HtmlTag.Type.B
						|| tag.getTagType() == HtmlTag.Type.STRONG || tag.getTagType() == HtmlTag.Type.LABEL)) {
					lastTag = token;
					break;
				} else {

					if (is218 && tag.getTagType() == HtmlTag.Type.LABEL) {
						continue;
					} else if (tag.getTagType() == HtmlTag.Type.A || tag.getTagType() == HtmlTag.Type.B
							|| tag.getTagType() == HtmlTag.Type.STRONG) {
						sb.append(tag.toString().trim() + " ");
					} else {
						break;
					}
				}
			} else if (token.getType() == Token.TEXT && !token.toString().trim().equals("\n"))
				sb.append(token.toString().trim() + " ");
		}

		String displayName = HtmlStreamTokenizer.unescape(sb).toString();
		Operation o = new Operation(knobName, displayName);
		o.setChecked(isChecked);

		if (lastTag != null) {
			tag = (HtmlTag) lastTag.getValue();
			if (tag.getTagType() != HtmlTag.Type.SELECT) {
				tokenizer.pushback(lastTag);
				if (tag.getTagType() == HtmlTag.Type.INPUT
						&& !("radio".equalsIgnoreCase(tag.getAttribute("type")) && "knob".equalsIgnoreCase(tag
								.getAttribute(KEY_NAME)))) {
					o.setInputName(((HtmlTag) lastTag.getValue()).getAttribute(KEY_NAME));
					o.setInputValue(((HtmlTag) lastTag.getValue()).getAttribute(KEY_VALUE));
				}
			} else {
				Token token = tokenizer.nextToken();
				// parse the options

				tag = (HtmlTag) token.getValue();
				o.setUpOptions(((HtmlTag) lastTag.getValue()).getAttribute(KEY_NAME));

				while (token.getType() != Token.EOF) {
					if (token.getType() == Token.TAG) {
						tag = (HtmlTag) token.getValue();
						if (tag.getTagType() == HtmlTag.Type.SELECT && tag.isEndTag())
							break;
						if (tag.getTagType() == HtmlTag.Type.OPTION && !tag.isEndTag()) {
							String optionName = tag.getAttribute(KEY_VALUE);
							StringBuffer optionText = new StringBuffer();
							for (token = tokenizer.nextToken(); token.getType() == Token.TEXT; token = tokenizer
									.nextToken()) {
								if (optionText.length() > 0) {
									optionText.append(' ');
								}
								optionText.append((StringBuffer) token.getValue());
							}
							o.addOption(optionText.toString(), optionName);
						} else {
							token = tokenizer.nextToken();
						}
					} else {
						token = tokenizer.nextToken();
					}
				}
			}
		}

		bug.addOperation(o);
	}

	/**
	 * Enum class for describing current state of Bugzilla report parser.
	 */
	private static class ParserState {
		/** An instance of the start state */
		protected static final ParserState START = new ParserState("start");

		/** An instance of the state when the parser found an attribute name */
		protected static final ParserState ATT_NAME = new ParserState("att_name");

		/** An instance of the state when the parser found an attribute value */
		protected static final ParserState ATT_VALUE = new ParserState("att_value");

		/** An instance of the state when the parser found a description */
		protected static final ParserState DESC_START = new ParserState("desc_start");

		/** An instance of the state when the parser found a description value */
		protected static final ParserState DESC_VALUE = new ParserState("desc_value");

		/** State's human-readable name */
		private String name;

		/**
		 * Constructor
		 * 
		 * @param description -
		 *            The states human readable name
		 */
		private ParserState(String description) {
			this.name = description;
		}

		@Override
		public String toString() {
			return name;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes
 */
public class BugzillaNewBugParserTestEquinox extends TestCase {

	public BugzillaNewBugParserTestEquinox() {
		super();
	}

	public BugzillaNewBugParserTestEquinox(String arg0) {
		super(arg0);
	}

	public void testProductEquinox() throws Exception {

		File f = FileTool
				.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/equinox-page.html"));

		Reader in = new FileReader(f);

		NewBugzillaReport nbm = new NewBugzillaReport();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this bug model
		List<AbstractRepositoryReportAttribute> attributes = nbm.getAttributes();
		// printList(attributes);

		Iterator<AbstractRepositoryReportAttribute> itr = attributes.iterator();
		AbstractRepositoryReportAttribute att = itr.next();

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: prodcut", "product", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No product options", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No AssignedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# OS options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Version options", 1, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "unspecified", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		// Attribute: Component
		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Component options", 3, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "Dynamic Plugins", options[i++]);
			assertEquals("Component options", "General", options[i++]);
			assertEquals("Component options", "OSGi", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_status options", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);

	}

	// private void printList(List<Attribute> attributes) {
	//
	// Iterator<Attribute> itr = attributes.iterator();
	// System.out.println("Attributes for this Product:");
	// System.out.println("============================");
	//
	// while (itr.hasNext()) {
	// Attribute attr = itr.next();
	// System.out.println();
	// System.out.println(attr.getName() + ": ");
	// System.out.println("-----------");
	//
	// Map<String, String> options = attr.getOptionValues();
	// Object[] it = options.keySet().toArray();
	// for (int i = 0; i < it.length; i++)
	// System.out.println((String) it[i]);
	// }
	// }
}





package org.eclipse.mylar.tasklist.tests;

import java.util.Calendar;
import java.util.Date;

import junit.framework.TestCase;

import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.BugzillaReportAttribute;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaTask;

/**


	public void testCompletionDate() {
		BugzillaTask task = new BugzillaTask("handle", "description", true);
		BugzillaReport report = new BugzillaReport(1, IBugzillaConstants.ECLIPSE_BUGZILLA_URL);
		task.setBugReport(report);
		assertNull(task.getCompletionDate());

		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.MILLISECOND, 0);
		calendar.getTimeInMillis();
		Date now = new Date(calendar.getTimeInMillis());
		
		Comment comment = new Comment(report, 1);
		AbstractRepositoryReportAttribute attribute = new BugzillaReportAttribute(BugzillaReportElement.CREATION_TS);
		attribute.setValue(Comment.creation_ts_date_format.format(now));	
		comment.addAttribute(BugzillaReportElement.CREATION_TS, attribute);
		report.addComment(comment);
		assertNull(task.getCompletionDate());

		AbstractRepositoryReportAttribute resolvedAttribute = new BugzillaReportAttribute(BugzillaReportElement.BUG_STATUS);
		resolvedAttribute.setValue(BugzillaReport.VAL_STATUS_RESOLVED);
		report.addAttribute(BugzillaReportElement.BUG_STATUS, resolvedAttribute);
		assertNotNull(task.getCompletionDate());
		assertEquals(Comment.creation_ts_date_format.format(now), Comment.creation_ts_date_format.format(task.getCompletionDate()));

	}





import java.util.Date;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.BugzillaReportAttribute;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaTask;

/**

			return null;
		}
	}

	/**
	 * Adaptred from Java Developers' almanac
	 */
	public static void copy(File source, File dest) throws IOException {
		InputStream in = new FileInputStream(source);
		OutputStream out = new FileOutputStream(dest);
		byte[] buf = new byte[1024];
		int len;
		while ((len = in.read(buf)) > 0) {
			out.write(buf, 0, len);
		}
		in.close();
		out.close();
	}

	public static void setBugTaskCompleted(BugzillaTask bugzillaTask, boolean completed) {
		BugzillaReport report = new BugzillaReport(1, IBugzillaConstants.ECLIPSE_BUGZILLA_URL);
		bugzillaTask.setBugReport(report);
		AbstractRepositoryReportAttribute resolvedAttribute = new BugzillaReportAttribute(
				BugzillaReportElement.BUG_STATUS);
		if (completed) {			
			resolvedAttribute.setValue(BugzillaReport.VAL_STATUS_RESOLVED);
			Comment comment = new Comment(report, 1);
			AbstractRepositoryReportAttribute attribute = new BugzillaReportAttribute(BugzillaReportElement.CREATION_TS);
			attribute.setValue(Comment.creation_ts_date_format.format(new Date()));	
			comment.addAttribute(BugzillaReportElement.CREATION_TS, attribute);
			report.addComment(comment);
		} else {
			resolvedAttribute.setValue(BugzillaReport.VAL_STATUS_NEW);
		}

		report.addAttribute(BugzillaReportElement.BUG_STATUS, resolvedAttribute);
		report.addComment(new Comment(report, 1));
		// report.addComment(new Comment(report, 1, now, "author",
		// "author-name"));
	}
}

Lines 84-90 Link Here

(-)src/org/eclipse/mylar/provisional/tasklist/AbstractRepositoryConnector.java (-1 / +3 lines)
84	* set an exception on queryStatus.getChildren[0] to indicate	84	* set an exception on queryStatus.getChildren[0] to indicate
85	* failure	85	* failure
86	*/	86	*/
87	protected abstract List<AbstractQueryHit> performQuery(AbstractRepositoryQuery query, IProgressMonitor monitor,	87	public abstract List<AbstractQueryHit> performQuery(AbstractRepositoryQuery query, IProgressMonitor monitor,
88	MultiStatus queryStatus);	88	MultiStatus queryStatus);
89		89
90	protected abstract void updateOfflineState(AbstractRepositoryTask repositoryTask, boolean forceSync);	90	protected abstract void updateOfflineState(AbstractRepositoryTask repositoryTask, boolean forceSync);
Lines 310-313 Link Here
310	"Opening JIRA issues not added to task list is not implemented."	310	"Opening JIRA issues not added to task list is not implemented."
311	);	311	);
312	}	312	}
		313
		314
313	}	315	}

Lines 11-17 Link Here

(-)src/org/eclipse/mylar/internal/bugs/BugzillaContextLabelProvider.java (-2 / +2 lines)
11		11
12	package org.eclipse.mylar.internal.bugs;	12	package org.eclipse.mylar.internal.bugs;
13		13
14	import org.eclipse.mylar.bugzilla.core.BugReport;	14	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
15	import org.eclipse.mylar.internal.bugs.search.BugzillaReferencesProvider;	15	import org.eclipse.mylar.internal.bugs.search.BugzillaReferencesProvider;
16	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaReportNode;	16	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaReportNode;
17	import org.eclipse.mylar.internal.tasklist.ui.TaskListImages;	17	import org.eclipse.mylar.internal.tasklist.ui.TaskListImages;
Lines 56-62 Link Here
56	// try to get from the cache before downloading	56	// try to get from the cache before downloading
57	Object report;	57	Object report;
58	BugzillaReportNode reportNode = MylarBugsPlugin.getReferenceProvider().getCached(node.getHandleIdentifier());	58	BugzillaReportNode reportNode = MylarBugsPlugin.getReferenceProvider().getCached(node.getHandleIdentifier());
59	BugReport cachedReport = MylarBugsPlugin.getDefault().getCache().getCached(node.getHandleIdentifier());	59	BugzillaReport cachedReport = MylarBugsPlugin.getDefault().getCache().getCached(node.getHandleIdentifier());
60	IMylarStructureBridge bridge = MylarPlugin.getDefault()	60	IMylarStructureBridge bridge = MylarPlugin.getDefault()
61	.getStructureBridge(BugzillaStructureBridge.CONTENT_TYPE);	61	.getStructureBridge(BugzillaStructureBridge.CONTENT_TYPE);
62		62

Lines 19-25 Link Here

(-)src/org/eclipse/mylar/internal/bugs/BugzillaStructureBridge.java (-2 / +2 lines)
19	import org.eclipse.core.resources.IProject;	19	import org.eclipse.core.resources.IProject;
20	import org.eclipse.core.runtime.IProgressMonitor;	20	import org.eclipse.core.runtime.IProgressMonitor;
21	import org.eclipse.jface.operation.IRunnableWithProgress;	21	import org.eclipse.jface.operation.IRunnableWithProgress;
22	import org.eclipse.mylar.bugzilla.core.BugReport;	22	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
23	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;	23	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
24	import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;	24	import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
25	import org.eclipse.mylar.internal.bugzilla.core.BugzillaTools;	25	import org.eclipse.mylar.internal.bugzilla.core.BugzillaTools;
Lines 75-81 Link Here
75	return null;	75	return null;
76	}	76	}
77		77
78	private BugReport result;	78	private BugzillaReport result;
79		79
80	/**	80	/**
81	* TODO: this will not return a non-cached handle	81	* TODO: this will not return a non-cached handle





import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Platform;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaTools;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaCacheFile;
import org.eclipse.mylar.internal.core.util.MylarStatusHandler;

 */
public class BugzillaReportCache {

	private Map<String, BugzillaReport> cache = new HashMap<String, BugzillaReport>();

	public void cache(String handle, BugzillaReport report) {
		cache.put(handle, report);
		cacheFile.add(report);
	}

		cacheFile.removeAll();
	}

	public BugzillaReport getFromCache(String bugHandle) {
		return cache.get(bugHandle);
	}



		try {
			cacheFile = new BugzillaCacheFile(cachPath.toFile());
			ArrayList<BugzillaReport> cached = cacheFile.elements();
			for (BugzillaReport bug : cached) {
				if (bug instanceof BugzillaReport)
					cache.put(BugzillaTools.getHandle(bug), (BugzillaReport) bug);
			}
		} catch (Exception e) {
			MylarStatusHandler.log(e, "occurred while restoring saved offline Bugzilla reports.");
		}
	}

	public BugzillaReport getCached(String handle) {
		return cache.get(handle);
	}
}




import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IType;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.internal.bugs.MylarBugsPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;


				// we have a bugzilla task, so get the bug report
				BugzillaTask bugTask = (BugzillaTask) task;
				BugzillaReport bug = bugTask.getBugReport();

				// parse the bug report for the element that we are searching
				// for

	 * @param bug
	 *            The bug to search in
	 */
	private boolean search(String elementName, BugzillaReport bug) {

		if (bug == null)
			return false; // MIK: added null check here


			// get the bug report so that we have all of the data
			// - descriptions, comments, etc
			BugzillaReport b = null;
			try {
				b = info.getBug();
			} catch (Exception e) {





import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
import org.eclipse.mylar.internal.tasklist.ui.views.TaskListView;
import org.eclipse.mylar.internal.tasklist.ui.wizards.ContextAttachWizard;
import org.eclipse.mylar.provisional.core.MylarPlugin;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask;
import org.eclipse.mylar.provisional.tasklist.ITask;
import org.eclipse.swt.widgets.Shell;

	public void run(IAction action) {
		ITask task = TaskListView.getDefault().getSelectedTask();
		if (task instanceof AbstractRepositoryTask) {
			try {	
				if (!MylarPlugin.getContextManager().hasContext(task.getHandleIdentifier())) {
					MessageDialog.openInformation(null, "Attach Context", "No context exists for selected task.");
					return;
				}
				
				ContextAttachWizard wizard = new ContextAttachWizard((AbstractRepositoryTask)task);
				Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
				if (wizard != null && shell != null && !shell.isDisposed()) {




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.Attribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugModel;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes for new bug reports
 */
public class BugzillaNewBugParserTestCDT extends TestCase {

	public BugzillaNewBugParserTestCDT() {
		super();
	}

	public BugzillaNewBugParserTestCDT(String arg0) {
		super(arg0);
	}

	public void testProductCDT() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/cdt-page.html"));

		Reader in = new FileReader(f);

		NewBugModel nbm = new NewBugModel();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this bug model
		List<Attribute> attributes = nbm.getAttributes();
		// printList(attributes);

		Iterator<Attribute> itr = attributes.iterator();
		Attribute att = itr.next();

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: product", "product", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No product options", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No AssignedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# of options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		// attOptions = (HashMap) att.getOptionValues();
		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Version options", 5, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "1.0", options[i++]);
			assertEquals("Version options", "1.0.1", options[i++]);
			assertEquals("Version options", "1.1", options[i++]);
			assertEquals("Version options", "1.2", options[i++]);
			assertEquals("Version options", "2.0", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		// Attribute: Component
		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Component options", 9, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "CDT-parser", options[i++]);
			assertEquals("Component options", "Core", options[i++]);
			assertEquals("Component options", "Cpp-Extensions", options[i++]);
			assertEquals("Component options", "Debug", options[i++]);
			assertEquals("Component options", "Debug-MI", options[i++]);
			assertEquals("Component options", "Doc", options[i++]);
			assertEquals("Component options", "Generic-Extensions", options[i++]);
			assertEquals("Component options", "Launcher", options[i++]);
			assertEquals("Component options", "UI", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# bug_status options [none]", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);

	}
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.NewBugModel;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * @author Mik Kersten
 * @author Rob Elves
 */
public class Bugzilla220ParserTest extends TestCase {

	public static final String TEST_SERVER = IBugzillaConstants.ECLIPSE_BUGZILLA_URL;
	
	private static final String PRODUCT_MYLAR = "Mylar";

	private static final String PRODUCT_TEST = "TestProduct";

	public void testId220() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
				"testdata/pages/test-report-220.html"));
		Reader in = new FileReader(f);

		BugReport bug = BugParser.parseBug(in, 7, TEST_SERVER, false, null, null, null);

		assertEquals(7, bug.getId());
		assertEquals("summary", bug.getSummary());
		assertEquals("7", bug.getAttribute("Bug#").getValue());
		assertEquals("7", bug.getAttribute("id").getValue());
	}

	public void testId2201() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
				"testdata/pages/test-report-2201.html"));
		Reader in = new FileReader(f);

		BugReport bug = BugParser.parseBug(in, 125527, TEST_SERVER, false, null, null, null);

		assertEquals(125527, bug.getId());
		assertEquals("bugzilla refresh incorrect for new reports and newly opened hits", bug.getSummary());
		assertEquals("125527", bug.getAttribute("Bug#").getValue());
		assertEquals("125527", bug.getAttribute("id").getValue());
	}

	public void testNewBugProduct220() throws Exception {

		NewBugModel nbm = new NewBugModel();

		File f = FileTool
				.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/enter-bug220.html"));
		Reader in = new FileReader(f);

		new NewBugParser(in).parseBugAttributes(nbm, true);
		assertEquals(PRODUCT_TEST, nbm.getAttribute("product").getValue());
	}

	public void testNewBugProduct2201() throws Exception {

		NewBugModel nbm = new NewBugModel();

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(),
				new Path("testdata/pages/enter-bug2201.html"));
		Reader in = new FileReader(f);

		new NewBugParser(in).parseBugAttributes(nbm, true);
		assertEquals(PRODUCT_MYLAR, nbm.getAttribute("product").getValue());
	}

}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.net.URL;

import junit.framework.TestCase;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;

/**
 * @author Rob Elves
 */
public class ReportAttachmentTest extends TestCase {

	public void testExistingBugWithAttachment() throws Exception {
		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
				"testdata/pages/test-report-222attachment.html"));
		Reader in = new FileReader(f);

		BugReport bug = BugParser.parseBug(in, 4, IBugzillaConstants.ECLIPSE_BUGZILLA_URL, false, null, null, null);
		
		assertEquals(4, bug.getId());
		assertEquals("4", bug.getAttribute("Bug#").getValue());
		assertEquals("4", bug.getAttribute("id").getValue());
		
		assertNotNull(bug.getComments());
		assertEquals(1, bug.getComments().size());
		assertTrue(bug.getComments().get(0).hasAttachment());
		assertEquals("Testing upload", bug.getComments().get(0).getAttachmentDescription());
//		System.err.println(bug.getComments().get(0).getText());
//		assertEquals(1, bug.getAttachements().size());
//		assertEquals("Testing upload", bug.getAttachements().get(1));
	}
	
	public void testAttachementDownload() throws Exception {
		URL localURL = null;
		URL installURL = BugzillaTestPlugin.getDefault().getBundle().getEntry("testdata/contexts/");
//		File destinationFile = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/contexts/"));
		localURL = FileLocator.toFileURL(installURL); 
		File destinationFile = new File(localURL.getPath()+"downloadedContext.xml");
		
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, IBugzillaConstants.TEST_BUGZILLA_222_URL);
		boolean result = BugzillaRepositoryUtil.downloadAttachment(repository, 2, destinationFile, true);
		assertTrue(result);
	}
	
//	public void testAttachementUpload() throws Exception {
//		File sourceFile = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
//		"testdata/contexts/downloadedContext.xml"));
//		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, IBugzillaConstants.TEST_BUGZILLA_222_URL);
//		repository.setAuthenticationCredentials("relves@cs.ubc.ca", "***");
//		boolean result = BugzillaRepositoryUtil.uploadAttachment(repository, 4, "Upload Comment 2", "Upload Description 2", sourceFile, "application/xml", false);		
//		assertTrue(result);
//	}
	
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.Attribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugModel;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes
 */
public class BugzillaNewBugParserTestGMT extends TestCase {

	public BugzillaNewBugParserTestGMT() {
		super();
	}

	public BugzillaNewBugParserTestGMT(String arg0) {
		super(arg0);
	}

	public void testProductGMT() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/gmt-page.html"));

		Reader in = new FileReader(f);

		NewBugModel nbm = new NewBugModel();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this bug model
		List<Attribute> attributes = nbm.getAttributes();
		// printList(attributes);

		Iterator<Attribute> itr = attributes.iterator();
		Attribute att = itr.next();

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: product", "product", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No product options", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No AssignedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# of options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		// attOptions = (HashMap) att.getOptionValues();
		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Version options", 1, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "unspecified", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Component options", 1, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "Core", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_status options", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);

	}

	// private void printList(List<Attribute> attributes) {
	//
	// Iterator<Attribute> itr = attributes.iterator();
	// System.out.println("Attributes for this Product:");
	// System.out.println("============================");
	//
	// while (itr.hasNext()) {
	// Attribute attr = itr.next();
	// System.out.println();
	// System.out.println(attr.getName() + ": ");
	// System.out.println("-----------");
	//
	// Map<String, String> options = attr.getOptionValues();
	// Object[] it = options.keySet().toArray();
	// for (int i = 0; i < it.length; i++)
	// System.out.println((String) it[i]);
	// }
	// }
}





import junit.framework.TestCase;

import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryConfiguration;
import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryConfigurationFactory;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;

public class BugzillaConfigurationTest extends TestCase {



	
	public void test222RDFProductConfig() throws IOException {
		RepositoryConfigurationFactory factory = RepositoryConfigurationFactory.getInstance();
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, IBugzillaConstants.TEST_BUGZILLA_222_URL);
		RepositoryConfiguration config = factory.getConfiguration(repository);
		assertNotNull(config);
		assertEquals("2.22rc1", config.getInstallVersion());
		assertEquals(7, config.getStatusValues().size());

		assertEquals(1, config.getVersions("TestProduct").size());
		assertEquals(1, config.getTargetMilestones("TestProduct").size());
	}
		
	public void test2201RDFProductConfig() throws IOException {
		RepositoryConfigurationFactory factory = RepositoryConfigurationFactory.getInstance();
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, IBugzillaConstants.TEST_BUGZILLA_2201_URL);
		RepositoryConfiguration config = factory.getConfiguration(repository);
		assertNotNull(config);
		assertEquals("2.20.1", config.getInstallVersion());
		assertEquals(7, config.getStatusValues().size());

		assertEquals(4, config.getOpenStatusValues().size());
		assertEquals(2, config.getComponents("TestProduct").size());
		assertEquals(1, config.getVersions("TestProduct").size());	
		// assertEquals(1, config.getTargetMilestones("TestProduct").size());
	}
	
	public void test220RDFProductConfig() throws IOException {
		RepositoryConfigurationFactory factory = RepositoryConfigurationFactory.getInstance();
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, IBugzillaConstants.TEST_BUGZILLA_220_URL);
		RepositoryConfiguration config = factory.getConfiguration(repository);
		assertNotNull(config);
		assertEquals("2.20", config.getInstallVersion());
		assertEquals(7, config.getStatusValues().size());

		assertEquals(4, config.getOpenStatusValues().size());
		assertEquals(2, config.getComponents("TestProduct").size());
		assertEquals(1, config.getVersions("TestProduct").size());
		// assertEquals(1, config.getTargetMilestones("TestProduct").size());
	}
	
	public void test218RDFProductConfig() throws IOException {
		RepositoryConfigurationFactory factory = RepositoryConfigurationFactory.getInstance();
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, IBugzillaConstants.TEST_BUGZILLA_218_URL);
		RepositoryConfiguration config = factory.getConfiguration(repository);
		assertNotNull(config);
		assertEquals("2.18.5", config.getInstallVersion());
		assertEquals(7, config.getStatusValues().size());
		assertEquals(8, config.getResolutions().size());
		assertEquals(8, config.getPlatforms().size());
		assertEquals(36, config.getOSs().size());
		assertEquals(5, config.getPriorities().size());
		assertEquals(7, config.getSeverities().size());
		assertEquals(1, config.getProducts().size());
		assertEquals(4, config.getOpenStatusValues().size());
		assertEquals(1, config.getComponents("TestProduct").size());
		assertEquals(1, config.getVersions("TestProduct").size());
		// assertEquals(1, config.getTargetMilestones("TestProduct").size());
	}
	
	public void testEclipseRDFProductConfig() throws IOException {
		RepositoryConfigurationFactory factory = RepositoryConfigurationFactory.getInstance();
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, IBugzillaConstants.ECLIPSE_BUGZILLA_URL);
		RepositoryConfiguration config = factory.getConfiguration(repository);
		assertNotNull(config);
		assertEquals("2.20.1", config.getInstallVersion());
		assertEquals(7, config.getStatusValues().size());

		assertEquals(27, config.getOSs().size());
		assertEquals(5, config.getPriorities().size());
		assertEquals(7, config.getSeverities().size());
		assertEquals(52, config.getProducts().size());
		assertEquals(4, config.getOpenStatusValues().size());
		assertEquals(10, config.getComponents("Mylar").size());
		assertEquals(21, config.getKeywords().size());
		// assertEquals(10, config.getComponents("Hyades").size());
		// assertEquals(1, config.getTargetMilestones("TestProduct").size());
	}
}




	public static Test suite() {
		TestSuite suite = new TestSuite("Test for org.eclipse.mylar.bugzilla.tests");
		// $JUnit-BEGIN$
		suite.addTestSuite(RepositoryReportFactoryTest.class);
		suite.addTestSuite(BugzillaConfigurationTest.class);
		suite.addTestSuite(BugzillaTaskHyperlinkDetectorTest.class);		
		suite.addTestSuite(ReportAttachmentTest.class);
		suite.addTestSuite(BugzillaSearchEngineTest.class);
		//suite.addTestSuite(Bugzilla220ParserTest.class);
		suite.addTestSuite(BugzillaRepositoryConnectorTest.class);
		suite.addTestSuite(EncodingTest.class);
		//suite.addTestSuite(NewBugWizardTest.class);
		suite.addTestSuite(RegularExpressionMatchTest.class);
		// suite.addTestSuite(BugzillaNewBugParserTestCDT.class);
		// suite.addTestSuite(BugzillaNewBugParserTestEquinox.class);
		// suite.addTestSuite(BugzillaNewBugParserTestGMT.class);
		// suite.addTestSuite(BugzillaNewBugParserTestPlatform.class);
		// suite.addTestSuite(BugzillaNewBugParserTestVE.class);
		//suite.addTestSuite(BugzillaParserTestNoBug.class);
		suite.addTestSuite(BugzillaProductParserTest.class);
		// TODO: enable
		// suite.addTest(new TestSuite(BugzillaParserTest.class));




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.Attribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugModel;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes
 */
public class BugzillaNewBugParserTestPlatform extends TestCase {

	public BugzillaNewBugParserTestPlatform() {
		super();
	}

	public BugzillaNewBugParserTestPlatform(String arg0) {
		super(arg0);
	}

	public void testProductPlatform() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(),
				new Path("testdata/pages/platform-page.html"));

		Reader in = new FileReader(f);

		NewBugModel nbm = new NewBugModel();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this bug model
		List<Attribute> attributes = nbm.getAttributes();
		// printList(attributes);

		// to iterator over the ArrayList of attributes
		Iterator<Attribute> itr = attributes.iterator();

		// Attribute: Severity
		Attribute att = itr.next(); // current attribute

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: product", "product", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No product optins", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: Assigned To", "Assigned To", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No AssingedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# OS options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# Version options", 8, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "1.0", options[i++]);
			assertEquals("Version options", "2.0", options[i++]);
			assertEquals("Version options", "2.0.1", options[i++]);
			assertEquals("Version options", "2.0.2", options[i++]);
			assertEquals("Version options", "2.1", options[i++]);
			assertEquals("Version options", "2.1.1", options[i++]);
			assertEquals("Version options", "2.1.2", options[i++]);
			assertEquals("Version options", "3.0", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		// Attribute: Component
		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# Component options", 16, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "Ant", options[i++]);
			assertEquals("Component options", "Compare", options[i++]);
			assertEquals("Component options", "Core", options[i++]);
			assertEquals("Component options", "CVS", options[i++]);
			assertEquals("Component options", "Debug", options[i++]);
			assertEquals("Component options", "Doc", options[i++]);
			assertEquals("Component options", "Help", options[i++]);
			assertEquals("Component options", "Releng", options[i++]);
			assertEquals("Component options", "Scripting", options[i++]);
			assertEquals("Component options", "Search", options[i++]);
			assertEquals("Component options", "SWT", options[i++]);
			assertEquals("Component options", "Team", options[i++]);
			assertEquals("Component options", "Text", options[i++]);
			assertEquals("Component options", "UI", options[i++]);
			assertEquals("Component options", "Update", options[i++]);
			assertEquals("Component options", "WebDAV", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No bug_status options", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);
	}

	// private void printList(List<Attribute> attributes) {
	//
	// Iterator<Attribute> itr = attributes.iterator();
	// System.out.println("Attributes for this Product:");
	// System.out.println("============================");
	//
	// while (itr.hasNext()) {
	// Attribute attr = itr.next();
	// System.out.println();
	// System.out.println(attr.getName() + ": ");
	// System.out.println("-----------");
	//
	// Map<String, String> options = attr.getOptionValues();
	// Object[] it = options.keySet().toArray();
	// for (int i = 0; i < it.length; i++)
	// System.out.println((String) it[i]);
	// }
	// }
}




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.Attribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugModel;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes
 */
public class BugzillaNewBugParserTestVE extends TestCase {

	public BugzillaNewBugParserTestVE() {
		super();
	}

	public BugzillaNewBugParserTestVE(String arg0) {
		super(arg0);
	}

	public void testProductVE() throws Exception {
		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/ve-page.html"));

		Reader in = new FileReader(f);

		NewBugModel nbm = new NewBugModel();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this but model
		List<Attribute> attributes = nbm.getAttributes();
		// printList(attributes);

		Iterator<Attribute> itr = attributes.iterator();
		Attribute att = itr.next();

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: product", "product", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No product options", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("No AssignedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		attOptions = att.getOptionValues();
		options = attOptions.keySet().toArray();
		assertEquals("# of options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		// attOptions = (HashMap) att.getOptionValues();
		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Version options", 3, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "0.5.0", options[i++]);
			assertEquals("Version options", "1.0.0", options[i++]);
			assertEquals("Version options", "unspecified", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Component options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "CDE", options[i++]);
			assertEquals("Component options", "Doc", options[i++]);
			assertEquals("Component options", "Java Core", options[i++]);
			assertEquals("Component options", "Java Model (JEM)", options[i++]);
			assertEquals("Component options", "JFC/Swing", options[i++]);
			assertEquals("Component options", "SWT", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_status options", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);

	}

	// private void printList(List<Attribute> attributes) {
	//
	// Iterator<Attribute> itr = attributes.iterator();
	// System.out.println("Attributes for this Product:");
	// System.out.println("============================");
	//
	// while (itr.hasNext()) {
	// Attribute attr = itr.next();
	// System.out.println();
	// System.out.println(attr.getName() + ": ");
	// System.out.println("-----------");
	//
	// Map<String, String> options = attr.getOptionValues();
	// Object[] it = options.keySet().toArray();
	// for (int i = 0; i < it.length; i++)
	// System.out.println((String) it[i]);
	// }
	// }
}




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;

/**
 * Tests for parsing Bugzilla reports
 */
public class BugzillaParserTestNoBug extends TestCase {

	public BugzillaParserTestNoBug() {
		super();
	}

	public BugzillaParserTestNoBug(String arg0) {
		super(arg0);
	}

	public void testBugNotFound() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
				"testdata/pages/bug-not-found-eclipse.html"));

		Reader in = new FileReader(f);

		BugReport bug = BugParser.parseBug(in, 666, "<server>", false, null, null, null);
		assertNull(bug);
	}
}





package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.mylar.internal.bugzilla.ui.wizard.AbstractBugzillaWizardPage;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;
import org.eclipse.ui.PlatformUI;

/**


	public void testPlatformOptions() throws Exception {

		NewBugzillaReport newReport = new NewBugzillaReport(IBugzillaConstants.TEST_BUGZILLA_220_URL);
		Reader in = new FileReader(f);

		NewBugModel model = new NewBugModel();
		AbstractBugzillaWizardPage page = new TestWizardDataPage();
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.TEST_BUGZILLA_220_URL);
		BugzillaRepositoryUtil.setupNewBugAttributes(repository, newReport); // FALSE
																				// **
		page.setPlatformOptions(newReport);

		String os = Platform.getOS();
		if (os.equals("win32"))
			assertEquals("Windows", newReport.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		else if (os.equals("solaris"))
			assertEquals("Solaris", newReport.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		else if (os.equals("qnx"))
			assertEquals("QNX-Photon", newReport.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		else if (os.equals("macosx"))
			assertEquals("Mac OS", newReport.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		else if (os.equals("linux"))
			assertEquals("Linux", newReport.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		else if (os.equals("hpux"))
			assertEquals("HP-UX", newReport.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		else if (os.equals("aix"))
			assertEquals("AIX", newReport.getAttribute(BugzillaReportElement.OP_SYS).getValue());

		String platform = Platform.getOSArch();
		if (platform.equals("x86"))
			assertEquals("PC", newReport.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		else if (platform.equals("x86_64"))
			assertEquals("PC", newReport.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		else if (platform.equals("ia64"))
			assertEquals("PC", newReport.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		else if (platform.equals("ia64_32"))
			assertEquals("PC", newReport.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		else if (platform.equals("sparc"))
			assertEquals("Sun", newReport.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		else if (platform.equals("ppc"))
			assertEquals("Power", newReport.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());

	}





/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.Attribute;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.NewBugModel;
import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;

/**
 * Tests NewBugParser -- parses product attributes
 */
public class BugzillaNewBugParserTestEquinox extends TestCase {

	public BugzillaNewBugParserTestEquinox() {
		super();
	}

	public BugzillaNewBugParserTestEquinox(String arg0) {
		super(arg0);
	}

	public void testProductEquinox() throws Exception {

		File f = FileTool
				.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/equinox-page.html"));

		Reader in = new FileReader(f);

		NewBugModel nbm = new NewBugModel();
		new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
															// **

		// attributes for this bug model
		List<Attribute> attributes = nbm.getAttributes();
		// printList(attributes);

		Iterator<Attribute> itr = attributes.iterator();
		Attribute att = itr.next();

		// Attribute: Severity
		assertEquals("Attribute: Severity", "Severity", att.getName());

		Map<String, String> attOptions = att.getOptionValues(); // HashMap of
		// options for the
		// current
		// attribute
		Object[] options = attOptions.keySet().toArray(); // Array of keys for
		// the options of the
		// current attribute
		assertEquals("# Severity options", 7, options.length);

		int i = 0;
		while (i < options.length) {
			assertEquals("severity options", "blocker", options[i++]);
			assertEquals("severity options", "critical", options[i++]);
			assertEquals("severity options", "major", options[i++]);
			assertEquals("severity options", "normal", options[i++]);
			assertEquals("severity options", "minor", options[i++]);
			assertEquals("severity options", "trivial", options[i++]);
			assertEquals("severity options", "enhancement", options[i++]);
		}

		// Attribute: product
		att = itr.next();
		assertEquals("Attribute: prodcut", "product", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No product options", 0, options.length);

		// Attribute: AssignedTo
		att = itr.next();
		assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No AssignedTo options", 0, options.length);

		// Attribute: OS
		att = itr.next();
		assertEquals("Attribute: OS", "OS", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# OS options", 20, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("OS options", "All", options[i++]);
			assertEquals("OS options", "AIX Motif", options[i++]);
			assertEquals("OS options", "Windows 95", options[i++]);
			assertEquals("OS options", "Windows 98", options[i++]);
			assertEquals("OS options", "Windows CE", options[i++]);
			assertEquals("OS options", "Windows ME", options[i++]);
			assertEquals("OS options", "Windows 2000", options[i++]);
			assertEquals("OS options", "Windows NT", options[i++]);
			assertEquals("OS options", "Windows XP", options[i++]);
			assertEquals("OS options", "Windows All", options[i++]);
			assertEquals("OS options", "MacOS X", options[i++]);
			assertEquals("OS options", "Linux", options[i++]);
			assertEquals("OS options", "Linux-GTK", options[i++]);
			assertEquals("OS options", "Linux-Motif", options[i++]);
			assertEquals("OS options", "HP-UX", options[i++]);
			assertEquals("OS options", "Neutrino", options[i++]);
			assertEquals("OS options", "QNX-Photon", options[i++]);
			assertEquals("OS options", "Solaris", options[i++]);
			assertEquals("OS options", "Unix All", options[i++]);
			assertEquals("OS options", "other", options[i++]);
		}

		// Attribute: Version
		att = itr.next();
		assertEquals("Attribute: Version", "Version", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Version options", 1, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Version options", "unspecified", options[i++]);
		}

		// Attribute: Platform
		att = itr.next();
		assertEquals("Attribute: Platform", "Platform", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Platform options", 6, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Platform options", "All", options[i++]);
			assertEquals("Platform options", "Macintosh", options[i++]);
			assertEquals("Platform options", "PC", options[i++]);
			assertEquals("Platform options", "Power PC", options[i++]);
			assertEquals("Platform options", "Sun", options[i++]);
			assertEquals("Platform options", "Other", options[i++]);
		}

		// Attribute: Component
		att = itr.next();
		assertEquals("Attribute: Component", "Component", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("# Component options", 3, options.length);

		i = 0;
		while (i < options.length) {
			assertEquals("Component options", "Dynamic Plugins", options[i++]);
			assertEquals("Component options", "General", options[i++]);
			assertEquals("Component options", "OSGi", options[i++]);
		}

		// Attribute: bug_status
		att = itr.next();
		assertEquals("Attribute: bug_status", "bug_status", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_status options", 0, options.length);

		// Attribute: form_name
		att = itr.next();
		assertEquals("Attribute: form_name", "form_name", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No form_name options", 0, options.length);

		// Attribute: bug_file_loc
		att = itr.next();
		assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No bug_file_loc options", 0, options.length);

		// Attribute: priority
		att = itr.next();
		assertEquals("Attribute: priority", "priority", att.getName());

		options = att.getOptionValues().keySet().toArray();
		assertEquals("No priority options", 0, options.length);

	}

	// private void printList(List<Attribute> attributes) {
	//
	// Iterator<Attribute> itr = attributes.iterator();
	// System.out.println("Attributes for this Product:");
	// System.out.println("============================");
	//
	// while (itr.hasNext()) {
	// Attribute attr = itr.next();
	// System.out.println();
	// System.out.println(attr.getName() + ": ");
	// System.out.println("-----------");
	//
	// Map<String, String> options = attr.getOptionValues();
	// Object[] it = options.keySet().toArray();
	// for (int i = 0; i < it.length; i++)
	// System.out.println((String) it[i]);
	// }
	// }
}





import junit.framework.TestCase;

import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;

/**
 * @author Mik Kersten


	public void testEncodingSetting() throws LoginException, IOException, ParseException {

		String charset = BugzillaRepositoryUtil.getCharsetFromString("text/html; charset=UTF-8");
		assertEquals("UTF-8", charset);

		charset = BugzillaRepositoryUtil.getCharsetFromString("text/html");
		assertEquals(null, charset);

		charset = BugzillaRepositoryUtil
				.getCharsetFromString("<<meta http-equiv=\"Content-Type\" content=\"text/html; charset=iso-8859-2\">>");
		assertEquals("iso-8859-2", charset);

		charset = BugzillaRepositoryUtil.getCharsetFromString("<<meta http-equiv=\"Content-Type\" content=\"text/html\">>");
		assertEquals(null, charset);
	}





import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryConnector;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryQuery;
import org.eclipse.mylar.provisional.tasklist.AbstractQueryHit;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;


				QUERY_NAME, 
				MAX_HITS, MylarTaskListPlugin.getTaskListManager().getTaskList());
		
		AbstractRepositoryConnector connector = (AbstractRepositoryConnector) MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(BugzillaPlugin.REPOSITORY_KIND);
		results.addAll(connector.performQuery(repositoryQuery, new NullProgressMonitor(), new MultiStatus(MylarTaskListPlugin.PLUGIN_ID, IStatus.OK, "Query result", null)));
		return results;	
	}




/*******************************************************************************
 * Copyright (c) 2003 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.bugzilla.tests;

import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.util.Iterator;

import junit.framework.TestCase;

import org.eclipse.core.runtime.Path;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.core.tests.support.FileTool;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;

/**
 * Tests for parsing Bugzilla reports
 */
public class BugzillaParserTest extends TestCase {

	public BugzillaParserTest() {
		super();
	}

	public BugzillaParserTest(String arg0) {
		super(arg0);
	}

	public void testFullReportBug1() throws Exception {

		File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/bug-1-full.html"));

		Reader in = new FileReader(f);

		BugReport bug = BugParser.parseBug(in, 1, "<server>", false, null, null, null);

		// displayBug(bug);
		assertEquals("Bug id", 1, bug.getId());
		assertEquals("Bug summary", "Usability issue with external editors (1GE6IRL)", bug.getSummary());
		assertEquals("Reporter", "andre_weinand@ch.ibm.com (Andre Weinand)", bug.getReporter());
		assertEquals("Reporter", "andre_weinand@ch.ibm.com (Andre Weinand)", bug.getAttribute("Reporter").getValue());
		assertEquals("Summary", "Usability issue with external editors (1GE6IRL)", bug.getSummary());
		assertEquals("Status", "VERIFIED", bug.getStatus());
		assertEquals("Resolution", "FIXED", bug.getResolution());
		assertEquals("Keywords", null, bug.getKeywords());
		assertEquals("Assigned To", "James_Moody@ca.ibm.com (James Moody)", bug.getAssignedTo());
		assertEquals("Priority", "P3", bug.getAttribute("Priority").getValue());
		assertEquals("OS", "All", bug.getAttribute("OS").getValue());
		assertEquals("Version", "2.0", bug.getAttribute("Version").getValue());
		assertEquals("Target Milestone", "---", bug.getAttribute("Target Milestone").getValue());
		assertEquals("Keywords", "", bug.getAttribute("Keywords").getValue());
		assertEquals("Severity", "normal", bug.getAttribute("Severity").getValue());
		assertEquals("Component", "VCM", bug.getAttribute("Component").getValue());
		assertEquals("CC", "Kevin_McGuire@oti.com", bug.getCC().iterator().next());
		assertEquals("Platform", "All", bug.getAttribute("Platform").getValue());
		assertEquals("Product", "Platform", bug.getAttribute("Product").getValue());
		assertEquals("URL", "", bug.getAttribute("URL").getValue());
		assertEquals("Bug#", "1", bug.getAttribute("Bug#").getValue());

		// Description
		String description = "- Setup a project that contains a *.gif resource\n"
				+ "\t- release project to CVS\n"
				+ "\t- edit the *.gif resource with an external editor, e.g. PaintShop\n"
				+ "\t- save and close external editor\n"
				+ "\t- in Navigator open the icon resource and verify that your changes are there\n"
				+ "\t- release project\n"
				+ "\t\t-> nothing to release!\n"
				+ "\t- in Navigator open the icon resource and verify that your changes are still there\n\n"
				+

				"\tProblem: because I never \"Refreshed from local\", the workspace hasn't changed so \"Release\" didn't find anything.\n"
				+ "\tHowever opening the resource with an external editor found the modified file on disk and showed the changes.\n\n"
				+

				"\tThe real problem occurs if \"Release\" actually finds something to release but you don't spot that some resources are missing.\n"
				+ "\tThis is extremely error prone: one of my changes didn't made it into build 110 because of this!\n\n"
				+

				"NOTES:\n"
				+ "EG (5/23/01 3:00:33 PM)\n"
				+ "\tRelease should do a refresh from local before doing the release.\n"
				+ "\tMoving to VCM\n\n\n"
				+

				"KM (05/27/01 5:10:19 PM)\n"
				+ "\tComments from JM in related email:\n\n"
				+

				"\tShould not do this for free.  Could have a setting which made it optoinal but should nt be mandatory.  Default setting could be to have it on.\n"
				+ "\tConsider the SWT team who keep their workspaces on network drives.  This will be slow.  \n\n"
				+

				"\tSide effects will be that a build runs when the refresh is completed unless you somehow do it in a workspace runnable and don't end the\n"
				+ "\trunnable until after the release.  This would be less than optimal as some builders may be responsible for maintaining some invariants and deriving resources which are releasable.  If you don't run the builders before releasing, the invariants will not be maintained and you will release inconsistent state.\n\n"
				+

				"\tSummary:  Offer to \"ensure local consistency\" before releasing.\n\n" +

				"KM (5/31/01 1:30:35 PM)\n"
				+ "\tSee also 1GEAG1A: ITPVCM:WINNT - Internal error comparing with a document\n"
				+ "\twhich failed with an error.  Never got log from Tod though.";

		assert (description.length() == bug.getDescription().length());
		assertEquals("Description", description, bug.getDescription());

		// Comments:
		Iterator<Comment> it = bug.getComments().iterator();
		while (it.hasNext()) {
			// COMMENT #1
			Comment comment = it.next();
			assertEquals("Author1", "James_Moody@ca.ibm.com", comment.getAuthor());
			assertEquals("Name1", "James Moody", comment.getAuthorName());
			assertEquals("Text1", "*** Bug 183 has been marked as a duplicate of this bug. ***", comment.getText());

			// COMMENT #2
			comment = it.next();
			assertEquals("Author2", "James_Moody@ca.ibm.com", comment.getAuthor());
			assertEquals("Name2", "James Moody", comment.getAuthorName());
			assertEquals("Text2", "Implemented 'auto refresh' option. Default value is off.", comment.getText());

			// COMMENT 3
			comment = it.next();
			assertEquals("Author3", "dj_houghton@ca.ibm.com", comment.getAuthor());
			assertEquals("Name3", "DJ Houghton", comment.getAuthorName());
			assertEquals("Text3", "PRODUCT VERSION:\n\t109\n\n", comment.getText());

			// COMMENT 4
			comment = it.next();
			assertEquals("Author4", "James_Moody@ca.ibm.com", comment.getAuthor());
			assertEquals("Name4", "James Moody", comment.getAuthorName());
			assertEquals("Text4", "Fixed in v206", comment.getText());
		}
	}

	// private static void displayBug(BugReport bug) {
	// System.out.println("Bug " + bug.getId() + ": " + bug.getSummary());
	// System.out.println("Opened: " + bug.getCreated());
	// for (Iterator<Attribute> it = bug.getAttributes().iterator();
	// it.hasNext();) {
	// Attribute attribute = it.next();
	// String key = attribute.getName();
	// System.out.println(key + ": " + attribute.getValue()
	// + (attribute.isEditable() ? " [OK]" : " %%"));
	// }
	//
	// System.out.print("CC: ");
	// for (Iterator<String> it = bug.getCC().iterator(); it.hasNext();) {
	// String email = it.next();
	// System.out.print(email + " ");
	// }
	// System.out.println();
	//
	// System.out.println(bug.getDescription());
	// for (Iterator<Comment> it = bug.getComments().iterator(); it.hasNext();)
	// {
	// Comment comment = it.next();
	// System.out.println(comment.getAuthorName() + " <"
	// + comment.getAuthor() + "> (" + comment.getCreated() + ")");
	// System.out.print(comment.getText());
	// System.out.println();
	// }
	// }
	//
	// private static void printComments(BugReport bug) {
	// for (Iterator<Comment> it = bug.getComments().iterator(); it.hasNext();)
	// {
	// Comment comment = it.next();
	// System.out.println("Author: " + comment.getAuthor());
	// System.out.println("Name: " + comment.getAuthorName());
	// System.out.println("Date: " + comment.getCreated());
	// System.out.println("Bug ID: " + comment.getBug().getId());
	// System.out.println("Comment: " + comment.getText());
	// System.out.println();
	// }
	// }
	//
	// /** prints names of attributes */
	// private static void printAttributes(BugReport bug) {
	// System.out.println("ATTRIBUTE KEYS:");
	// for (Iterator<Attribute> it = bug.getAttributes().iterator();
	// it.hasNext();) {
	// Attribute att = it.next();
	// System.out.println(att.getName());
	// }
	// }
}





import java.net.MalformedURLException;
import java.util.Date;
import java.util.Iterator;

import javax.security.auth.login.LoginException;

import junit.framework.TestCase;

import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.BugReport;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaException;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaReportSubmitForm;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.PossibleBugzillaFailureException;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaQueryHit;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryConnector;


	private static final String DEFAULT_KIND = BugzillaPlugin.REPOSITORY_KIND;

	//private static final String TEST_REPOSITORY_URL = "https://bugs.eclipse.org/bugs";

	private BugzillaRepositoryConnector client;


		super.setUp();
		manager = MylarTaskListPlugin.getRepositoryManager();
		manager.clearRepositories();
		repository = new TaskRepository(DEFAULT_KIND, IBugzillaConstants.TEST_BUGZILLA_222_URL);
		// repository.setAuthenticationCredentials("userid", "password");
		manager.addRepository(repository);
		assertNotNull(manager);


		// Modify it
		String newCommentText = "BugzillaRepositoryClientTest.testSynchronize(): " + (new Date()).toString();
		task.getBugReport().setNewComment(newCommentText);
		// overwrites old fields/attributes with new content (ususually done by
		// BugEditor)
		task.getBugReport().setHasChanged(true);
//		updateBug(task.getBugReport());
		assertEquals(task.getSyncState(), RepositoryTaskSyncState.SYNCHRONIZED);
		client.saveBugReport(task.getBugReport());
		assertEquals(RepositoryTaskSyncState.OUTGOING, task.getSyncState());

		// because task doesn't have bug report (new query hit)
		// Result: retrieved with no incoming status
		task.setSyncState(RepositoryTaskSyncState.SYNCHRONIZED);
		BugzillaReport bugReport = task.getBugReport();
		task.setBugReport(null);
		client.synchronize(task, false, null);
		assertEquals(RepositoryTaskSyncState.SYNCHRONIZED, task.getSyncState());


	}

	protected void updateBug(BugzillaReport bug) {

		// go through all of the attributes and update the main values to the
		// new ones
//		for (Iterator<AbstractRepositoryReportAttribute> it = bug.getAttributes().iterator(); it.hasNext();) {
//			AbstractRepositoryReportAttribute attribute = it.next();
//			if (attribute.getValue() != null && attribute.getValue().compareTo(attribute.getValue()) != 0) {
//				bug.setHasChanged(true);
//			}
//			attribute.setValue(attribute.getNewValue());
//
//		}
//		if (bug.getNewComment().compareTo(bug.getNewNewComment()) != 0) {
//			bug.setHasChanged(true);
//		}

		// Update some other fields as well.
		//bug.setNewComment(bug.getNewNewComment());

	}





/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.bugzilla.tests;

import java.io.IOException;

import javax.security.auth.login.LoginException;

import junit.framework.TestCase;

import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryReportFactory;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;

public class RepositoryReportFactoryTest extends TestCase {

	RepositoryReportFactory factory = RepositoryReportFactory.getInstance();

	public void testBugNoFound222() {
		int bugid = -1;
		String errorMessage = "";
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.TEST_BUGZILLA_222_URL);
		try {
			BugzillaReport report = new BugzillaReport(bugid, repository.getUrl());
			factory.populateReport(report, repository);
		} catch (LoginException e) {
			//
		} catch (IOException e) {
			errorMessage = e.getMessage();
		}
		assertEquals(IBugzillaConstants.ERROR_INVALID_BUG_ID, errorMessage);
	}

	public void testInvalidCredentials222() {
		int bugid = 1;
		String errorMessage = "";
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.TEST_BUGZILLA_222_URL);
		repository.setAuthenticationCredentials("invalid", "invalid");
		try {
			BugzillaReport report = new BugzillaReport(bugid, repository.getUrl());
			factory.populateReport(report, repository);
		} catch (LoginException e) {
			errorMessage = e.getMessage();
		} catch (IOException e) {
			errorMessage = e.getMessage();
		}
		assertEquals(IBugzillaConstants.ERROR_INVALID_USERNAME_OR_PASSWORD, errorMessage);
		repository.flushAuthenticationCredentials();
	}

	public void testReadingReport() throws Exception {
		int bugid = 4;
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.TEST_BUGZILLA_222_URL);

		BugzillaReport report = new BugzillaReport(bugid, repository.getUrl());
		BugzillaRepositoryUtil.setupExistingBugAttributes(repository.getUrl(), report);
		factory.populateReport(report, repository);

		assertNotNull(report);
		assertEquals("Another Test", report.getAttribute(BugzillaReportElement.SHORT_DESC).getValue());
		assertEquals("TestProduct", report.getAttribute(BugzillaReportElement.PRODUCT).getValue());
		assertEquals("PC", report.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		assertEquals("Other", report.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		assertEquals(37, report.getComments().size());
		assertEquals("Testing new 2.22 version capability", report.getComments().get(0).getAttribute(
				BugzillaReportElement.THETEXT).getValue());
		assertEquals(15, report.getAttachments().size());
		assertEquals("1", report.getAttachments().get(0).getAttribute(BugzillaReportElement.ATTACHID).getValue());
		assertEquals("2006-03-10 14:11", report.getAttachments().get(0).getAttribute(BugzillaReportElement.DATE)
				.getValue());
		assertEquals("Testing upload", report.getAttachments().get(0).getAttribute(BugzillaReportElement.DESC)
				.getValue());
		assertEquals("patch130217.txt", report.getAttachments().get(0).getAttribute(BugzillaReportElement.FILENAME)
				.getValue());
		assertEquals("text/plain", report.getAttachments().get(0).getAttribute(BugzillaReportElement.TYPE).getValue());
	}

	public void testReadingReport222() throws Exception {
		int bugid = 1;
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.TEST_BUGZILLA_222_URL);

		BugzillaReport report = new BugzillaReport(bugid, repository.getUrl());
		BugzillaRepositoryUtil.setupExistingBugAttributes(repository.getUrl(), report);
		factory.populateReport(report, repository);

		assertNotNull(report);
		assertEquals("search-match-test 1", report.getAttribute(BugzillaReportElement.SHORT_DESC).getValue());
		assertEquals("TestProduct", report.getAttribute(BugzillaReportElement.PRODUCT).getValue());
		assertEquals("TestComponent", report.getAttribute(BugzillaReportElement.COMPONENT).getValue());
		assertEquals("PC", report.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		assertEquals("Windows", report.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		assertEquals("other", report.getAttribute(BugzillaReportElement.VERSION).getValue());
		assertEquals("P1", report.getAttribute(BugzillaReportElement.PRIORITY).getValue());
		assertEquals("blocker", report.getAttribute(BugzillaReportElement.BUG_SEVERITY).getValue());
		assertEquals("1", report.getAttribute(BugzillaReportElement.BUG_ID).getValue());
		assertEquals("NEW", report.getAttribute(BugzillaReportElement.BUG_STATUS).getValue());
		assertEquals("2006-03-08 19:59", report.getAttribute(BugzillaReportElement.CREATION_TS).getValue());
		assertEquals("2006-03-08 19:59:15", report.getAttribute(BugzillaReportElement.DELTA_TS).getValue());
		assertEquals("---", report.getAttribute(BugzillaReportElement.TARGET_MILESTONE).getValue());
		assertEquals("relves@cs.ubc.ca", report.getAttribute(BugzillaReportElement.REPORTER).getValue());
		assertEquals("relves@cs.ubc.ca", report.getAttribute(BugzillaReportElement.ASSIGNED_TO).getValue());
		assertEquals(1, report.getComments().size());
		assertEquals("relves@cs.ubc.ca", report.getComments().get(0).getAttribute(BugzillaReportElement.WHO).getValue());
		assertEquals("2006-03-08 19:59:15", report.getComments().get(0).getAttribute(BugzillaReportElement.BUG_WHEN)
				.getValue());
		assertEquals("search-match-test 1", report.getComments().get(0).getAttribute(BugzillaReportElement.THETEXT)
				.getValue());
		assertEquals(0, report.getAttachments().size());
	}

	public void testReadingReport2201() throws Exception {
		int bugid = 1;
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.TEST_BUGZILLA_2201_URL);

		BugzillaReport report = new BugzillaReport(bugid, repository.getUrl());
		BugzillaRepositoryUtil.setupExistingBugAttributes(repository.getUrl(), report);
		factory.populateReport(report, repository);

		assertNotNull(report);
		assertEquals("1", report.getAttribute(BugzillaReportElement.BUG_ID).getValue());
		assertEquals("search-match-test 1", report.getAttribute(BugzillaReportElement.SHORT_DESC).getValue());
		assertEquals("TestProduct", report.getAttribute(BugzillaReportElement.PRODUCT).getValue());
		assertEquals("TestComponent", report.getAttribute(BugzillaReportElement.COMPONENT).getValue());
		assertEquals("PC", report.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		assertEquals("Windows", report.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		assertEquals("other", report.getAttribute(BugzillaReportElement.VERSION).getValue());
		assertEquals("P2", report.getAttribute(BugzillaReportElement.PRIORITY).getValue());
		assertEquals("normal", report.getAttribute(BugzillaReportElement.BUG_SEVERITY).getValue());
		assertEquals("NEW", report.getAttribute(BugzillaReportElement.BUG_STATUS).getValue());
		assertEquals("2006-03-02 18:13", report.getAttribute(BugzillaReportElement.CREATION_TS).getValue());
		assertEquals("2006-05-03 13:06:11", report.getAttribute(BugzillaReportElement.DELTA_TS).getValue());
		assertEquals("---", report.getAttribute(BugzillaReportElement.TARGET_MILESTONE).getValue());
		AbstractRepositoryReportAttribute attribute = report.getAttribute(BugzillaReportElement.BLOCKED);
		assertEquals(2, attribute.getValues().size());
		assertEquals("2", attribute.getValues().get(0));
		assertEquals("9", attribute.getValues().get(1));
		attribute = report.getAttribute(BugzillaReportElement.CC);
		assertEquals(2, attribute.getValues().size());
		assertEquals("relves@cs.ubc.ca", attribute.getValues().get(0));
		assertEquals("relves@gmail.com", attribute.getValues().get(1));
		assertEquals("relves@cs.ubc.ca", report.getAttribute(BugzillaReportElement.REPORTER).getValue());
		assertEquals("relves@cs.ubc.ca", report.getAttribute(BugzillaReportElement.ASSIGNED_TO).getValue());
		assertEquals(1, report.getComments().size());
		assertEquals("relves@cs.ubc.ca", report.getComments().get(0).getAttribute(BugzillaReportElement.WHO).getValue());
		assertEquals("2006-03-02 18:13", report.getComments().get(0).getAttribute(BugzillaReportElement.BUG_WHEN)
				.getValue());
		assertEquals("search-match-test 1", report.getComments().get(0).getAttribute(BugzillaReportElement.THETEXT)
				.getValue());
		assertEquals(0, report.getAttachments().size());
	}

	public void testReadingReport2201Eclipse() throws Exception {
		int bugid = 24448;
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.ECLIPSE_BUGZILLA_URL);

		BugzillaReport report = new BugzillaReport(bugid, repository.getUrl());
		BugzillaRepositoryUtil.setupExistingBugAttributes(repository.getUrl(), report);
		factory.populateReport(report, repository);

		assertNotNull(report);
		assertEquals("24448", report.getAttribute(BugzillaReportElement.BUG_ID).getValue());
		assertEquals("Ant causing Out of Memory", report.getAttribute(BugzillaReportElement.SHORT_DESC).getValue());
		assertEquals("Platform", report.getAttribute(BugzillaReportElement.PRODUCT).getValue());
		assertEquals("Ant", report.getAttribute(BugzillaReportElement.COMPONENT).getValue());
		assertEquals("PC", report.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		assertEquals("other", report.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		assertEquals("2.0", report.getAttribute(BugzillaReportElement.VERSION).getValue());
		assertEquals("P2", report.getAttribute(BugzillaReportElement.PRIORITY).getValue());
		assertEquals("normal", report.getAttribute(BugzillaReportElement.BUG_SEVERITY).getValue());
		assertEquals("RESOLVED", report.getAttribute(BugzillaReportElement.BUG_STATUS).getValue());
		assertEquals("WONTFIX", report.getAttribute(BugzillaReportElement.RESOLUTION).getValue());
		assertEquals("2002-10-07 09:32", report.getAttribute(BugzillaReportElement.CREATION_TS).getValue());
		assertEquals("2006-02-03 12:03:57", report.getAttribute(BugzillaReportElement.DELTA_TS).getValue());
		assertEquals("core, performance, ui", report.getAttribute(BugzillaReportElement.KEYWORDS).getValue());
		// AbstractRepositoryReportAttribute attribute =
		// report.getAttribute(BugzillaReportElement.CC);
		// assertEquals(30, attribute.getValues().size());
		// assertEquals("relves@cs.ubc.ca", attribute.getValues().get(0));
		// assertEquals("relves@gmail.com", attribute.getValues().get(1));
		// assertEquals("relves@cs.ubc.ca",
		// report.getAttribute(BugzillaReportElement.REPORTER).getValue());
		// assertEquals("relves@cs.ubc.ca",
		// report.getAttribute(BugzillaReportElement.ASSIGNED_TO).getValue());
		// assertEquals(1, report.getComments().size());
		// assertEquals("relves@cs.ubc.ca",
		// report.getComments().get(0).getAttribute(BugzillaReportElement.WHO).getValue());
		// assertEquals("2006-03-02 18:13",
		// report.getComments().get(0).getAttribute(BugzillaReportElement.BUG_WHEN)
		// .getValue());
		// assertEquals("search-match-test 1",
		// report.getComments().get(0).getAttribute(BugzillaReportElement.THETEXT)
		// .getValue());
		// assertEquals(0, report.getAttachments().size());
	}

	public void testReadingReport220() throws Exception {
		int bugid = 1;
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.TEST_BUGZILLA_220_URL);

		BugzillaReport report = new BugzillaReport(bugid, repository.getUrl());
		BugzillaRepositoryUtil.setupExistingBugAttributes(repository.getUrl(), report);
		factory.populateReport(report, repository);

		assertNotNull(report);
		assertEquals("1", report.getAttribute(BugzillaReportElement.BUG_ID).getValue());
		assertEquals("search-match-test", report.getAttribute(BugzillaReportElement.SHORT_DESC).getValue());
		assertEquals("TestProduct", report.getAttribute(BugzillaReportElement.PRODUCT).getValue());
		assertEquals("TestComponent", report.getAttribute(BugzillaReportElement.COMPONENT).getValue());
		assertEquals("PC", report.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		assertEquals("Windows", report.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		assertEquals("other", report.getAttribute(BugzillaReportElement.VERSION).getValue());
		assertEquals("P2", report.getAttribute(BugzillaReportElement.PRIORITY).getValue());
		assertEquals("normal", report.getAttribute(BugzillaReportElement.BUG_SEVERITY).getValue());
		assertEquals("NEW", report.getAttribute(BugzillaReportElement.BUG_STATUS).getValue());
		assertEquals("2006-03-02 17:30", report.getAttribute(BugzillaReportElement.CREATION_TS).getValue());
		assertEquals("2006-04-20 15:13:43", report.getAttribute(BugzillaReportElement.DELTA_TS).getValue());
		assertEquals("---", report.getAttribute(BugzillaReportElement.TARGET_MILESTONE).getValue());
		assertEquals("relves@cs.ubc.ca", report.getAttribute(BugzillaReportElement.REPORTER).getValue());
		assertEquals("relves@cs.ubc.ca", report.getAttribute(BugzillaReportElement.ASSIGNED_TO).getValue());
		assertEquals("relves@cs.ubc.ca", report.getAttribute(BugzillaReportElement.CC).getValue());
		assertEquals(3, report.getComments().size());
		assertEquals("relves@cs.ubc.ca", report.getComments().get(0).getAttribute(BugzillaReportElement.WHO).getValue());
		assertEquals("2006-03-02 17:30", report.getComments().get(0).getAttribute(BugzillaReportElement.BUG_WHEN)
				.getValue());
		assertEquals("search-match-test", report.getComments().get(0).getAttribute(BugzillaReportElement.THETEXT)
				.getValue());
		assertEquals(0, report.getAttachments().size());
	}

	public void testReadingReport218() throws Exception {
		int bugid = 1;
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.TEST_BUGZILLA_218_URL);

		BugzillaReport report = new BugzillaReport(bugid, repository.getUrl());
		BugzillaRepositoryUtil.setupExistingBugAttributes(repository.getUrl(), report);
		factory.populateReport(report, repository);

		assertNotNull(report);
		assertEquals("1", report.getAttribute(BugzillaReportElement.BUG_ID).getValue());
		assertEquals("search-match-test 1", report.getAttribute(BugzillaReportElement.SHORT_DESC).getValue());
		assertEquals("TestProduct", report.getAttribute(BugzillaReportElement.PRODUCT).getValue());
		assertEquals("TestComponent", report.getAttribute(BugzillaReportElement.COMPONENT).getValue());
		assertEquals("PC", report.getAttribute(BugzillaReportElement.REP_PLATFORM).getValue());
		assertEquals("Windows XP", report.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		assertEquals("other", report.getAttribute(BugzillaReportElement.VERSION).getValue());
		assertEquals("P2", report.getAttribute(BugzillaReportElement.PRIORITY).getValue());
		assertEquals("normal", report.getAttribute(BugzillaReportElement.BUG_SEVERITY).getValue());
		assertEquals("NEW", report.getAttribute(BugzillaReportElement.BUG_STATUS).getValue());
		assertEquals("2006-03-02 18:09", report.getAttribute(BugzillaReportElement.CREATION_TS).getValue());
		assertEquals("2006-05-05 17:45:24", report.getAttribute(BugzillaReportElement.DELTA_TS).getValue());
		assertEquals("---", report.getAttribute(BugzillaReportElement.TARGET_MILESTONE).getValue());
		assertEquals("relves@cs.ubc.ca", report.getAttribute(BugzillaReportElement.REPORTER).getValue());
		assertEquals("relves@cs.ubc.ca", report.getAttribute(BugzillaReportElement.ASSIGNED_TO).getValue());
		assertEquals(1, report.getComments().size());
		assertEquals("relves@cs.ubc.ca", report.getComments().get(0).getAttribute(BugzillaReportElement.WHO).getValue());
		assertEquals("2006-03-02 18:09", report.getComments().get(0).getAttribute(BugzillaReportElement.BUG_WHEN)
				.getValue());
		assertEquals("search-match-test 1", report.getComments().get(0).getAttribute(BugzillaReportElement.THETEXT)
				.getValue());
		assertEquals(0, report.getAttachments().size());
	}

	public void testBugReportAPI() throws Exception {
		int bugid = 4;
		TaskRepository repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND,
				IBugzillaConstants.TEST_BUGZILLA_222_URL);

		BugzillaReport report = new BugzillaReport(bugid, repository.getUrl());
		BugzillaRepositoryUtil.setupExistingBugAttributes(repository.getUrl(), report);
		factory.populateReport(report, repository);

		assertNotNull(report);
		assertTrue(report instanceof BugzillaReport);
		BugzillaReport bugReport = (BugzillaReport) report;
		assertEquals("Another Test", bugReport.getSummary());
		assertEquals("Testing new 2.22 version capability", bugReport.getDescription());
		assertEquals("TestProduct", bugReport.getProduct());
		assertEquals("relves@cs.ubc.ca", bugReport.getAssignedTo());
		// assertEquals("Other",
		// report.getAttribute(BugzillaReportElement.OP_SYS).getValue());
		// assertEquals(37, report.getComments().size());
		// assertEquals("Testing new 2.22 version capability",
		// report.getComments().get(0).getAttribute(BugzillaReportElement.THETEXT).getValue());
		// assertEquals(15, report.getAttachments().size());
		// assertEquals("1",
		// report.getAttachments().get(0).getAttribute(BugzillaReportElement.ATTACHID).getValue());
	}
}





import javax.security.auth.login.LoginException;

import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.bugzilla.core.search.BugzillaSearchHit;


	private List<StackTrace> stackTraces;

	/** The bug report associated with this DoiInfo */
	private BugzillaReport bug;

	/**
	 * Constructor

	 * @throws LoginException
	 * @throws MalformedURLException
	 */
	public BugzillaReport getBug() throws MalformedURLException, LoginException, IOException {
		if (bug == null) {
			// get the bug report
			bug = BugzillaRepositoryUtil.getBug(hit.getRepository(), hit.getId());

	 * @param bug -
	 *            BugReport that this is associated with
	 */
	public void setBug(BugzillaReport bug) {
		this.bug = bug;
	}





import java.util.Date;
import java.util.List;

import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer;
import org.eclipse.mylar.internal.bugzilla.core.internal.OfflineReportsFile;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask;

	 * The bug report for this BugzillaTask. This is <code>null</code> if the
	 * bug report with the specified ID was unable to download.
	 */
	protected transient BugzillaReport bugReport = null;

	public BugzillaTask(String handle, String label, boolean newTask) {
		super(handle, label, newTask);

			bugReport = null;
			return true;
		}
		bugReport = (BugzillaReport) tempBug;

		if (bugReport.hasChanges())
			syncState = RepositoryTaskSyncState.OUTGOING;

		}
	}

	public BugzillaReport getBugReport() {
		return bugReport;
	}
	
	public String getTaskType() {
		if (bugReport != null && bugReport.getAttribute(BugzillaReportElement.BUG_SEVERITY) != null) {
			return bugReport.getAttribute(BugzillaReportElement.BUG_SEVERITY).getValue();
		} else {
			return null;
		}

	 * @param bugReport
	 *            The bugReport to set.
	 */
	public void setBugReport(BugzillaReport bugReport) {
		this.bugReport = bugReport;
		
		// TODO: remove?


	@Override
	public String getPriority() {
		if (bugReport != null && bugReport.getAttribute(BugzillaReportElement.PRIORITY) != null) {
			return bugReport.getAttribute(BugzillaReportElement.PRIORITY).getValue();
		} else {
			return super.getPriority();
		}




import java.util.List;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;

/**


	private File file;

	private ArrayList<BugzillaReport> list = new ArrayList<BugzillaReport>();

	protected int latestNewBugId = 0;


		}
	}

	public void add(BugzillaReport entry) {
		// add the entry to the list and write the file to disk
		list.add(entry);
		writeFile();


	public int find(int id) {
		for (int i = 0; i < list.size(); i++) {
			BugzillaReport currBug = list.get(i);
			if (currBug != null && (currBug.getId() == id) && !currBug.isLocallyCreated())
				return i;
		}
		return -1;
	}

	public ArrayList<BugzillaReport> elements() {
		return list;
	}



		// read in each of the offline reports in the file
		for (int nX = 0; nX < size; nX++) {
			BugzillaReport item = (BugzillaReport) in.readObject();
			// add the offline report to the offlineReports list
			list.add(item);
		}
		in.close();
	}

	public void remove(List<BugzillaReport> sel) {
		list.removeAll(sel);

		// rewrite the file so that the data is persistant




import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.jface.wizard.IWizard;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReport;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.BugzillaRemoteContextDelegate;
import org.eclipse.mylar.bugzilla.core.ReportAttachment;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaException;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaReportSubmitForm;

		return BugzillaPlugin.REPOSITORY_KIND;
	}

	public void saveBugReport(BugzillaReport bugzillaBug) {
		String handle = AbstractRepositoryTask.getHandle(bugzillaBug.getRepositoryUrl(), bugzillaBug.getId());
		ITask task = MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);
		if (task instanceof BugzillaTask) {
			BugzillaTask bugzillaTask = (BugzillaTask) task;
			bugzillaTask.setBugReport((BugzillaReport) bugzillaBug);

			if (bugzillaBug.hasChanges()) {
				bugzillaTask.setSyncState(RepositoryTaskSyncState.OUTGOING);


	}

	private BugzillaReport downloadReport(final BugzillaTask bugzillaTask) {
		try {
			return BugzillaRepositoryUtil.getBug(bugzillaTask.getRepositoryUrl(), AbstractRepositoryTask
					.getTaskIdAsInt(bugzillaTask.getHandleIdentifier()));

		}
	}

	private static void offlineStatusChange(AbstractRepositoryReport report, BugzillaOfflineStatus status,
			boolean forceSynch) {

		RepositoryTaskSyncState state = null;
		if (status == BugzillaOfflineStatus.SAVED_WITH_OUTGOING_CHANGES) {

			return;
		}

		String handle = AbstractRepositoryTask.getHandle(report.getRepositoryUrl(), report.getId());
		ITask task = MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);
		if (task != null && task instanceof BugzillaTask) {
			BugzillaTask bugTask = (BugzillaTask) task;

		}
	}

	public void submitBugReport(final BugzillaReport bugReport, final BugzillaReportSubmitForm form,
			IJobChangeListener listener) {

		if (forceSyncExecForTesting) {

		}
	}

	private void internalSubmitBugReport(BugzillaReport bugReport, BugzillaReportSubmitForm form) {
		try {
			form.submitReportToRepository();
			removeReport(bugReport);

			// TODO: avoid getting archive tasks?
			ITask task = MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);

			// TODO: re-enable synchronization of queries with task. Redundant?
			// Set<AbstractRepositoryQuery> queriesWithHandle =
			// MylarTaskListPlugin.getTaskListManager().getTaskList()
			// .getQueriesForHandle(task.getHandleIdentifier());
			// synchronize(queriesWithHandle, null, Job.INTERACTIVE, 0);

			// for (AbstractRepositoryQuery query : queriesWithHandle) {
			// synchronize(query, null);
			// }

	 * @param saveChosen
	 *            This is used to determine a refresh from a user save
	 */
	public BugzillaOfflineStatus saveOffline(final BugzillaReport bug, final boolean forceSynch) {

		BugzillaOfflineStatus status = BugzillaOfflineStatus.ERROR;


		return status;
	}

	// TODO: pull up
	private void internalSaveOffline(final BugzillaReport report, final boolean forceSynch) {
		// If there is already an offline report for this bug, update the file.
		if (((AbstractRepositoryReport) report).isSavedOffline()) {
			offlineReportsFile.update();
		} else {
			try {

				// // identical id.");
				// // return;
				// }
				BugzillaOfflineStatus offlineStatus = offlineReportsFile.add(report, false);
				((AbstractRepositoryReport) report).setOfflineState(true);
				// saveForced forced to false (hack)
				offlineStatusChange(report, offlineStatus, forceSynch);

			} catch (CoreException e) {
				MylarStatusHandler.fail(e, e.getMessage(), false);

		}
	}

	public static List<BugzillaReport> getOfflineBugs() {
		OfflineReportsFile file = BugzillaPlugin.getDefault().getOfflineReports();
		return file.elements();
	}

	public static void removeReport(BugzillaReport bug) {
		bug.setOfflineState(false);
		offlineStatusChange(bug, BugzillaOfflineStatus.DELETED, false);
		ArrayList<BugzillaReport> bugList = new ArrayList<BugzillaReport>();
		bugList.add(bug);
		BugzillaPlugin.getDefault().getOfflineReports().remove(bugList);
	}

	protected void updateOfflineState(AbstractRepositoryTask repositoryTask, boolean forceSync) {
		if (repositoryTask instanceof BugzillaTask) {
			BugzillaTask bugzillaTask = (BugzillaTask) repositoryTask;
			BugzillaReport downloadedReport = downloadReport(bugzillaTask);
			if (downloadedReport != null) {
				bugzillaTask.setBugReport(downloadedReport);
				saveOffline(downloadedReport, forceSync);

		if (task instanceof BugzillaTask) {
			BugzillaTask bugzillaTask = (BugzillaTask) task;
			if (bugzillaTask.getBugReport() != null) {
				for (ReportAttachment attachment : bugzillaTask.getBugReport().getAttachments()) {
					if (attachment.getDescription().equals(MYLAR_CONTEXT_DESCRIPTION)) {
						contextDelegates.add(new BugzillaRemoteContextDelegate(attachment));
					}
				}
				// for (Comment comment :
				// bugzillaTask.getBugReport().getComments()) {
				// if (comment.hasAttachment() &&
				// comment.getAttachmentDescription().equals(MYLAR_CONTEXT_DESCRIPTION))
				// {
				// contextDelegates.add(new
				// BugzillaRemoteContextDelegate(comment));
				// }
				// }
			}
		}
		return contextDelegates;




import javax.security.auth.login.LoginException;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.internal.bugzilla.ui.editor.ExistingBugEditorInput;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask.RepositoryTaskSyncState;


	private String bugTitle;

	private BugzillaReport offlineBug;

	private BugzillaTask bugTask;


	/**
	 * Returns the offline bug for this input's Bugzilla task
	 */
	public BugzillaReport getOfflineBug() {
		if (offline || bugTask.getSyncState() == RepositoryTaskSyncState.OUTGOING
				|| bugTask.getSyncState() == RepositoryTaskSyncState.CONFLICT)
			return offlineBug;

			return super.getBug();
	}

	public void setOfflineBug(BugzillaReport offlineBug) {
		this.offlineBug = offlineBug;
	}





import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.tasklist.ui.wizards.AbstractRepositorySettingsPage;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;

	private static final String TITLE = "Bugzilla Repository Settings";

	private static final String DESCRIPTION = "Example: https://bugs.eclipse.org/bugs (do not include index.cgi)";
	private AbstractRepositoryConnector connector;
	protected Combo repositoryVersionCombo;
	
	public BugzillaRepositorySettingsPage(AbstractRepositoryConnector connector) {
		super(TITLE, DESCRIPTION);
		this.connector = connector;
	}




import org.eclipse.core.resources.IMarker;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaAttributeListener;
import org.eclipse.mylar.internal.bugzilla.ui.editor.AbstractBugEditor;
import org.eclipse.mylar.internal.bugzilla.ui.editor.BugzillaOutlineNode;

	protected BugzillaTask bugTask;

	/** This bug report can be modified by the user and saved offline. */
	protected BugzillaReport offlineBug;

	private ExistingBugEditor bugzillaEditor;


	/**
	 * @return Returns the offlineBug.
	 */
	public BugzillaReport getOfflineBug() {
		return offlineBug;
	}


	// }
	// }

	public void makeNewPage(BugzillaReport serverBug, String newCommentText) {
		if (serverBug == null) {
			MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
					"Could not open bug.", "Bug #" + offlineBug.getId()




import org.eclipse.jface.text.TextViewer;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
import org.eclipse.mylar.bugzilla.core.Operation;

import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.compare.BugzillaCompareInput;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryConnector;
import org.eclipse.mylar.internal.tasklist.ui.TaskUiUtil;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.List;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Text;


	private static final String LABEL_COMPARE_BUTTON = "Compare";

	// private static final String ATTR_SUMMARY = "Summary";

	protected Set<String> removeCC = new HashSet<String>();



	protected Text addCommentsText;

	protected BugzillaReport bug;

	public String getNewCommentText() {
		return addCommentsTextBox.getText();

				radioData = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
				radioData.horizontalSpan = 1;
				radioData.widthHint = 120;

				// TODO: add condition for if opName = reassign to...
				String assignmentValue = "";
				if (opName.equals(REASSIGN_BUG_TO)) {
					assignmentValue = repository.getUserName();
				}
				radioOptions[i] = toolkit.createText(buttonComposite, assignmentValue);// ,

		super.addActionButtons(buttonComposite);

		compareButton = toolkit.createButton(buttonComposite, LABEL_COMPARE_BUTTON, SWT.NONE);
		// compareButton.setFont(TEXT_FONT);
		GridData compareButtonData = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
		// compareButtonData.widthHint = 100;
		// compareButtonData.heightHint = 20;
		// // compareButton.setText("Compare");
		compareButton.setLayoutData(compareButtonData);
		compareButton.addListener(SWT.Selection, new Listener() {
			public void handleEvent(Event e) {


			}
		});

		
		// TODO used for spell checking. Add back when we want to support this
		// checkSpellingButton = new Button(buttonComposite, SWT.NONE);
		// checkSpellingButton.setFont(TEXT_FONT);


	@Override
	protected String getTitleString() {
		// Attribute summary = bug.getAttribute(ATTR_SUMMARY);
		// String summaryVal = ((null != summary) ? summary.getNewValue() :
		// null);
		return bug.getLabel();// + ": " + checkText(summaryVal);
	}


		descriptionLayout.numColumns = 1;
		descriptionComposite.setLayout(descriptionLayout);
		// descriptionComposite.setBackground(background);
		// GridData descriptionData = new GridData(GridData.FILL_HORIZONTAL);
		// descriptionData.horizontalSpan = 1;
		// descriptionData.grabExcessVerticalSpace = false;
		// descriptionComposite.setLayoutData(descriptionData);
		// End Description Area


		// HEADER);

		// t.addListener(SWT.FocusIn, new DescriptionListener());
		// StyledText t = newLayout(descriptionComposite, 4,
		// bug.getDescription(), VALUE);
		// t.setFont(COMMENT_FONT);

		TextViewer viewer = addRepositoryText(repository, descriptionComposite, bug.getDescription());
		StyledText styledText = viewer.getTextWidget();
		styledText.addListener(SWT.FocusIn, new DescriptionListener());

		addCommentsData.heightHint = DESCRIPTION_HEIGHT;
		addCommentsData.grabExcessVerticalSpace = false;
		addCommentsComposite.setLayoutData(addCommentsData);
		// End Additional (read-only) Comments Area

		

		StyledText styledText = null;
		for (Iterator<Comment> it = bug.getComments().iterator(); it.hasNext();) {
			final Comment comment = it.next();
			
			// skip comment 0 as it is the description
			if(comment.getNumber() == 0) continue;
			
			ExpandableComposite ec = toolkit.createExpandableComposite(addCommentsComposite,
					ExpandableComposite.TREE_NODE);

			if (!it.hasNext()) {
				ec.setExpanded(true);
			}

			ec.setText(comment.getNumber() + ": " + comment.getAuthorName() + ", "
					+ simpleDateFormat.format(comment.getCreated()));

			ec.addExpansionListener(new ExpansionAdapter() {
				public void expansionStateChanged(ExpansionEvent e) {

			ec.setClient(ecComposite);
			toolkit.paintBordersFor(ec);

			
			// TODO: Attachments are no longer 'attached' to Comments
			
//			if (comment.hasAttachment()) {
//
//				Link attachmentLink = new Link(ecComposite, SWT.NONE);
//
//				String attachmentHeader;
//
//				if (!comment.isObsolete()) {
//					attachmentHeader = " Attached: " + comment.getAttachmentDescription() + " [<a>view</a>]";
//				} else {
//					attachmentHeader = " Deprecated: " + comment.getAttachmentDescription();
//				}
//				// String result = MessageFormat.format(attachmentHeader, new
//				// String[] { node
//				// .getLabelText() });
//
//				attachmentLink.addSelectionListener(new SelectionAdapter() {
//					/*
//					 * (non-Javadoc)
//					 * 
//					 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
//					 */
//					public void widgetSelected(SelectionEvent e) {
//						String address = repository.getUrl() + "/attachment.cgi?id=" + comment.getAttachmentId()
//								+ "&amp;action=view";
//						TaskUiUtil.openUrl(address, address, address);
//
//					}
//				});
//
//				attachmentLink.setText(attachmentHeader);
//
//			}

			// styledText = newLayout(ecComposite, 1, comment.getText(), VALUE);
			// styledText.addListener(SWT.FocusIn, new
			// CommentListener(comment));
			// styledText.setFont(COMMENT_FONT);
			//System.err.println(comment.getNumber()+"   "+comment.getText());
			TextViewer viewer = addRepositoryText(repository, ecComposite, comment.getText());
			styledText = viewer.getTextWidget();


		addCommentsText.setFont(COMMENT_FONT);
		toolkit.paintBordersFor(newCommentsComposite);
		GridData addCommentsTextData = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
		// addCommentsTextData.horizontalSpan = 4;
		addCommentsTextData.widthHint = DESCRIPTION_WIDTH;
		addCommentsTextData.heightHint = DESCRIPTION_HEIGHT;
		addCommentsTextData.grabExcessHorizontalSpace = true;


			public void handleEvent(Event event) {
				String sel = addCommentsText.getText();
				if (!(bug.getNewComment().equals(sel))) {
					bug.setNewComment(sel);					
					changeDirtyStatus(true);
				}
				validateInput();

		keyWordsList.setLayoutData(keyWordsTextData);

		// initialize the keywords list with valid values
		
		
		
		java.util.List<String> validKeywords = BugzillaPlugin.getDefault().getProductConfiguration(repository).getKeywords();
		
		if (validKeywords != null) {
			for (Iterator<String> it = validKeywords.iterator(); it.hasNext();) {
				String keyword = it.next();
				keyWordsList.add(keyword);
			}

		keyWordsList.addSelectionListener(new KeywordListener());
		keyWordsList.addListener(SWT.FocusIn, new GenericListener());
	}
	
	@Override
	protected void addCCList(FormToolkit toolkit, String ccValue, Composite attributesComposite) {
		newLayout(attributesComposite, 1, "Add CC:", PROPERTY);


			public void modifyText(ModifyEvent e) {
				changeDirtyStatus(true);
				AbstractRepositoryReportAttribute a = bug.getAttribute(BugzillaReportElement.NEWCC);
				if (a != null) {
					a.setValue(ccText.getText());
				}
			}


		ccListData.heightHint = 40;
		ccList.setLayoutData(ccListData);

		java.util.List<String> ccs = bug.getCC();
		Set<String> ccs = bug.getCC();
		if (ccs != null) {
			for (Iterator<String> it = ccs.iterator(); it.hasNext();) {
				String cc = it.next();
				ccList.add(cc);//HtmlStreamTokenizer.unescape(cc));
			}
		}



	@Override
	protected void updateBug() {
		bug.setHasChanged(true);
		// go through all of the attributes and update the main values to the
		// new ones
		// for (Iterator<AbstractRepositoryReportAttribute> it =
		// bug.getAttributes().iterator(); it.hasNext();) {
		// AbstractRepositoryReportAttribute a = it.next();
		// if (a.getNewValue() != null &&
		// a.getNewValue().compareTo(a.getValue()) != 0) {
		// bug.setHasChanged(true);
		// }
		// a.setValue(a.getNewValue());
		//
		// }
		// if (bug.getNewComment().compareTo(bug.getNewNewComment()) != 0) {
		// // TODO: Ask offline reports if this is true?
		// bug.setHasChanged(true);
		//		}

		// Update some other fields as well.
		// bug.setNewComment(bug.getNewNewComment());

	}



		// go through all of the attributes and restore the new values to the
		// main ones
		// for (Iterator<AbstractRepositoryReportAttribute> it =
		// bug.getAttributes().iterator(); it.hasNext();) {
		// AbstractRepositoryReportAttribute a = it.next();
		// a.setNewValue(a.getValue());
		// }

		// Restore some other fields as well.
		// bug.setNewNewComment(bug.getNewComment());
	}

	/**


		@Override
		protected IStatus run(IProgressMonitor monitor) {
			final BugzillaReport serverBug;
			try {
				serverBug = BugzillaRepositoryUtil.getBug(bug.getRepositoryUrl(), bug.getId());
				// If no bug was found on the server, throw an exception so that

			if (keyWordsList.getSelectionCount() == 1) {
				int index = keyWordsList.getSelectionIndex();
				String keyword = keyWordsList.getItem(index);
				if (getReport().getAttributeValue(BugzillaReportElement.KEYWORDS).equals(keyword))
					keyWordsList.deselectAll();
			}


					keywords.append(",");
				}
			}
			
			bug.setAttributeValue(BugzillaReportElement.KEYWORDS, keywords.toString());

			// update the keywords text field
			keywordsText.setText(keywords.toString());

		Operation o = bug.getSelectedOperation();
		if (o != null && o.getKnobName().compareTo("resolve") == 0
				&& (addCommentsText.getText() == null || addCommentsText.getText().equals(""))) {
			// TODO: Highlight (change to light red?) New Comment area to indicate need for message
			submitButton.setEnabled(false);
		} else {
			submitButton.setEnabled(true);

	@Override
	public void handleSummaryEvent() {
		String sel = summaryText.getText();
		AbstractRepositoryReportAttribute a = getReport().getAttribute(BugzillaReportElement.SHORT_DESC);
		if (!(a.getValue().equals(sel))) {
			a.setValue(sel);
			changeDirtyStatus(true);
		}
	}




 *******************************************************************************/
package org.eclipse.mylar.internal.bugzilla.ui.editor;

import java.util.Iterator;

import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylar.bugzilla.core.Attribute;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaReportSubmitForm;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaReportSubmitForm;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryConnector;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;

 */
public class NewBugEditor extends AbstractBugEditor {

	protected NewBugzillaReport bug;

	protected Text descriptionText;


	protected void updateBug() {
		// go through all of the attributes and update the main values to the
		// new ones
//		for (Iterator<AbstractRepositoryReportAttribute> it = bug.getAttributes().iterator(); it.hasNext();) {
//			AbstractRepositoryReportAttribute a = it.next();
//			a.setValue(a.getNewValue());
//		}

		// Update some other fields as well.
		bug.setSummary(newSummary);

	protected void restoreBug() {
		// go through all of the attributes and restore the new values to the
		// main ones
//		for (Iterator<AbstractRepositoryReportAttribute> it = bug.getAttributes().iterator(); it.hasNext();) {
//			AbstractRepositoryReportAttribute a = it.next();
//			a.setNewValue(a.getValue());
//		}
	}

	@SuppressWarnings("deprecation")

Lines 14-20 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/ui/editor/AbstractBugEditor.java (-264 / +458 lines)
14	import java.util.ArrayList;	14	import java.util.ArrayList;
15	import java.util.Arrays;	15	import java.util.Arrays;
16	import java.util.HashMap;	16	import java.util.HashMap;
17	import java.util.Iterator;
18	import java.util.List;	17	import java.util.List;
19	import java.util.Map;	18	import java.util.Map;
20	import java.util.Set;	19	import java.util.Set;
Lines 35-41 Link Here
35	import org.eclipse.jface.viewers.ISelectionProvider;	34	import org.eclipse.jface.viewers.ISelectionProvider;
36	import org.eclipse.jface.viewers.SelectionChangedEvent;	35	import org.eclipse.jface.viewers.SelectionChangedEvent;
37	import org.eclipse.jface.viewers.StructuredSelection;	36	import org.eclipse.jface.viewers.StructuredSelection;
38	import org.eclipse.mylar.bugzilla.core.Attribute;	37	import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReport;
		38	import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
		39	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
39	import org.eclipse.mylar.bugzilla.core.Comment;	40	import org.eclipse.mylar.bugzilla.core.Comment;
40	import org.eclipse.mylar.bugzilla.core.IBugzillaBug;	41	import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
41	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;	42	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
Lines 43-48 Link Here
43	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaAttributeListener;	44	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaAttributeListener;
44	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;	45	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
45	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaReportSelection;	46	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaReportSelection;
		47	import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
46	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryConnector;	48	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryConnector;
47	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;	49	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
48	import org.eclipse.mylar.internal.tasklist.ui.editors.MylarTaskEditor;	50	import org.eclipse.mylar.internal.tasklist.ui.editors.MylarTaskEditor;
Lines 170-176 Link Here
170		172
171	protected final int HORZ_INDENT = 0;	173	protected final int HORZ_INDENT = 0;
172		174
173	protected CCombo oSCombo;	175	protected CCombo attributeCombo;
174		176
175	protected CCombo versionCombo;	177	protected CCombo versionCombo;
176		178
Lines 257-263 Link Here
257		259
258	protected List<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>();	260	protected List<ISelectionChangedListener> selectionChangedListeners = new ArrayList<ISelectionChangedListener>();
259		261
260	protected HashMap<CCombo, String> comboListenerMap = new HashMap<CCombo, String>();	262	protected HashMap<CCombo, AbstractRepositoryReportAttribute> comboListenerMap = new HashMap<CCombo, AbstractRepositoryReportAttribute>();
261		263
262	private IBugzillaReportSelection lastSelected = null;	264	private IBugzillaReportSelection lastSelected = null;
263		265
Lines 309-317 Link Here
309	if (comboListenerMap.containsKey(combo)) {	311	if (comboListenerMap.containsKey(combo)) {
310	if (combo.getSelectionIndex() > -1) {	312	if (combo.getSelectionIndex() > -1) {
311	String sel = combo.getItem(combo.getSelectionIndex());	313	String sel = combo.getItem(combo.getSelectionIndex());
312	Attribute attribute = getBug().getAttribute(comboListenerMap.get(combo));	314	AbstractRepositoryReportAttribute attribute = comboListenerMap.get(combo);
313	if (sel != null && !(sel.equals(attribute.getNewValue()))) {	315	if (sel != null && !(sel.equals(attribute.getValue()))) {
314	attribute.setNewValue(sel);	316	attribute.setValue(sel);
315	for (IBugzillaAttributeListener client : attributesListeners) {	317	for (IBugzillaAttributeListener client : attributesListeners) {
316	client.attributeChanged(attribute.getName(), sel);	318	client.attributeChanged(attribute.getName(), sel);
317	}	319	}
Lines 382-387 Link Here
382	*/	384	*/
383	public abstract IBugzillaBug getBug();	385	public abstract IBugzillaBug getBug();
384		386
		387	// TODO: temporary as part of conversion to xml
		388	public AbstractRepositoryReport getReport() {
		389	return (AbstractRepositoryReport) getBug();
		390	}
		391
385	/**	392	/**
386	* @return Any currently selected text.	393	* @return Any currently selected text.
387	*/	394	*/
Lines 429-435 Link Here
429	Composite headerInfoComposite = toolkit.createComposite(editorComposite);	436	Composite headerInfoComposite = toolkit.createComposite(editorComposite);
430	headerInfoComposite.setLayout(new GridLayout(6, false));	437	headerInfoComposite.setLayout(new GridLayout(6, false));
431	toolkit.createLabel(headerInfoComposite, "Bug# ").setFont(TITLE_FONT);	438	toolkit.createLabel(headerInfoComposite, "Bug# ").setFont(TITLE_FONT);
432	toolkit.createText(headerInfoComposite, "" + getBug().getId());	439	toolkit.createText(headerInfoComposite, "" + getReport().getId());
433		440
434	toolkit.createLabel(headerInfoComposite, " Opened: ").setFont(TITLE_FONT);	441	toolkit.createLabel(headerInfoComposite, " Opened: ").setFont(TITLE_FONT);
435	String openedDateString = "";	442	String openedDateString = "";
Lines 490-495 Link Here
490	getSite().registerContextMenu("#BugEditor", contextMenuManager, getSite().getSelectionProvider());	497	getSite().registerContextMenu("#BugEditor", contextMenuManager, getSite().getSelectionProvider());
491	}	498	}
492		499
		500	// /**
		501	// * Creates the attribute layout, which contains most of the basic
		502	// attributes
		503	// * of the bug (some of which are editable).
		504	// */
		505	// protected void createAttributeLayout() {
		506	//
		507	// String title = getTitleString();
		508	// String keywords = "";
		509	// String url = "";
		510	//
		511	// Section section = toolkit.createSection(form.getBody(),
		512	// ExpandableComposite.TITLE_BAR \| Section.TWISTIE);
		513	// section.setText(LABEL_SECTION_ATTRIBUTES);
		514	// section.setExpanded(true);
		515	// section.setLayout(new GridLayout());
		516	// section.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		517	//
		518	// section.addExpansionListener(new IExpansionListener() {
		519	// public void expansionStateChanging(ExpansionEvent e) {
		520	// form.reflow(true);
		521	// }
		522	//
		523	// public void expansionStateChanged(ExpansionEvent e) {
		524	// form.reflow(true);
		525	// }
		526	// });
		527	//
		528	// // Attributes Composite- this holds all the combo fiels and text fields
		529	// Composite attributesComposite = toolkit.createComposite(section);
		530	// GridLayout attributesLayout = new GridLayout();
		531	// attributesLayout.numColumns = 4;
		532	// attributesLayout.horizontalSpacing = 14;
		533	// attributesLayout.verticalSpacing = 6;
		534	// attributesComposite.setLayout(attributesLayout);
		535	// GridData attributesData = new GridData(GridData.FILL_BOTH);
		536	// attributesData.horizontalSpan = 1;
		537	// attributesData.grabExcessVerticalSpace = false;
		538	// attributesComposite.setLayoutData(attributesData);
		539	// // attributesComposite.setBackground(background);
		540	// // End Attributes Composite
		541	//
		542	// section.setClient(attributesComposite);
		543	//
		544	// // Attributes Title Area
		545	// // Composite attributesTitleComposite = new
		546	// // Composite(attributesComposite, SWT.NONE);
		547	// // GridLayout attributesTitleLayout = new GridLayout();
		548	// // attributesTitleLayout.horizontalSpacing = 0;
		549	// // attributesTitleLayout.marginWidth = 0;
		550	// // attributesTitleComposite.setLayout(attributesTitleLayout);
		551	// // attributesTitleComposite.setBackground(background);
		552	// // GridData attributesTitleData = new
		553	// // GridData(GridData.HORIZONTAL_ALIGN_FILL);
		554	// // attributesTitleData.horizontalSpan = 4;
		555	// // attributesTitleData.grabExcessVerticalSpace = false;
		556	// // attributesTitleComposite.setLayoutData(attributesTitleData);
		557	// // End Attributes Title
		558	//
		559	// // Set the Attributes Title
		560	// // newAttributesLayout(attributesTitleComposite);
		561	// // titleLabel.setText(title);
		562	// bugzillaInput.setToolTipText(title);
		563	// int currentCol = 1;
564	//
565	// // String ccValue = null;
566	//
567	// // Populate Attributes
568	// for (Iterator<AbstractRepositoryReportAttribute> it =
569	// getReport().getAttributes().iterator(); it.hasNext();) {
570	// AbstractRepositoryReportAttribute attribute = it.next();
571	// String key = attribute.getID();
572	// String name = attribute.getName();
573	// String value = checkText(attribute.getValue());
574	// System.err.println(">>> AbstractBugEditor>> name: "+name+" key: "+key+"
575	// value:"+value);
576	// Map<String, String> values = attribute.getOptionValues();
577	//
578	// // make sure we don't try to display a hidden field
579	// if (attribute.isHidden() \|\| (key != null &&
580	// key.equals("status_whiteboard")))
581	// continue;
582	//
583	// if (values == null)
584	// values = new HashMap<String, String>();
585	//
586	// if (key == null)
587	// key = "";
588	//
589	// GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
590	// data.horizontalSpan = 1;
591	// data.horizontalIndent = HORZ_INDENT;
592	//
593	// if (key.equals(BugzillaReportElement.KEYWORDS.getKeyString())) {
594	// keywords = attribute.getValue();
595	// } else if (key.equals(BugzillaReportElement.CC.getKeyString())) {
596	// continue;
597	// } else if (key.equals(BugzillaReportElement.NEWCC.getKeyString())) {
598	// // force move to first column
599	// if (currentCol > 1) {
600	// while (currentCol <= attributesLayout.numColumns) {
601	// newLayout(attributesComposite, 1, "", PROPERTY);
602	// currentCol++;
603	// }
604	// }
605	// addCCList(toolkit, "", attributesComposite);
606	// } else if (key.equals(BugzillaReportElement.DEPENDSON.getKeyString())) {
607	// // Dependson and blocked are multi valued so need to explicitly
608	// // be parsed and shown in the AbstractBugEditor
609	// continue;
610	// } else if (key.equals(BugzillaReportElement.BLOCKED.getKeyString())) {
611	// // Dependson and blocked are multi valued so need to explicitly
612	// // be parsed and shown in the AbstractBugEditor
613	// continue;
614	// } else if (key.equals("bug_file_loc")) {
615	// url = value;
616	// } else if (key.equals("op_sys")) {
617	// // newLayout(attributesComposite, 1, name, PROPERTY);
618	// toolkit.createLabel(attributesComposite, name);
619	// // oSCombo = new Combo(attributesComposite, SWT.NO_BACKGROUND \|
620	// // SWT.MULTI \| SWT.V_SCROLL \| SWT.READ_ONLY);//SWT.NONE
621	// oSCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.READ_ONLY);
622	// // oSCombo = new Combo(attributesComposite, SWT.FLAT \|
623	// // SWT.READ_ONLY);
624	// toolkit.adapt(oSCombo, true, true);
625	// oSCombo.setFont(TEXT_FONT);
626	// oSCombo.setLayoutData(data);
627	// // oSCombo.setBackground(background);
628	// Set<String> s = values.keySet();
629	// String[] a = s.toArray(new String[s.size()]);
630	// Arrays.sort(a);
631	// for (int i = 0; i < a.length; i++) {
632	// oSCombo.add(a[i]);
633	// }
634	// if (oSCombo.indexOf(value) != -1) {
635	// oSCombo.select(oSCombo.indexOf(value));
636	// } else {
637	// oSCombo.select(oSCombo.indexOf("All"));
638	// }
639	// // oSCombo.addListener(SWT.Modify, this);
640	// oSCombo.addSelectionListener(new ComboSelectionListener(oSCombo));
641	// comboListenerMap.put(oSCombo, attribute);
642	// oSCombo.addListener(SWT.FocusIn, new GenericListener());
643	// currentCol += 2;
644	// } else if (key.equals("version")) {
645	// // newLayout(attributesComposite, 1, name, PROPERTY);
646	// toolkit.createLabel(attributesComposite, name);
647	// versionCombo = new CCombo(attributesComposite, SWT.FLAT \|
648	// SWT.NO_BACKGROUND \| SWT.MULTI \| SWT.V_SCROLL
649	// \| SWT.READ_ONLY);
650	// toolkit.adapt(versionCombo, true, true);
651	// versionCombo.setFont(TEXT_FONT);
652	// versionCombo.setLayoutData(data);
653	// // versionCombo.setBackground(background);
654	// Set<String> s = values.keySet();
655	// String[] a = s.toArray(new String[s.size()]);
656	// Arrays.sort(a);
657	// for (int i = 0; i < a.length; i++) {
658	// versionCombo.add(a[i]);
659	// }
660	// versionCombo.select(versionCombo.indexOf(value));
661	// // versionCombo.addListener(SWT.Modify, this);
662	// versionCombo.addSelectionListener(new
663	// ComboSelectionListener(versionCombo));
664	// versionCombo.addListener(SWT.FocusIn, new GenericListener());
665	// comboListenerMap.put(versionCombo, attribute);
666	// currentCol += 2;
667	// } else if (key.equals("priority")) {
668	// // newLayout(attributesComposite, 1, "Priority", PROPERTY);
669	// toolkit.createLabel(attributesComposite, name);
670	// priorityCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.V_SCROLL \|
671	// SWT.READ_ONLY);
672	// toolkit.adapt(priorityCombo, true, true);
673	// priorityCombo.setFont(TEXT_FONT);
674	// priorityCombo.setLayoutData(data);
675	// // priorityCombo.setBackground(background);
676	// Set<String> s = values.keySet();
677	// String[] a = s.toArray(new String[s.size()]);
678	// Arrays.sort(a);
679	// for (int i = 0; i < a.length; i++) {
680	// priorityCombo.add(a[i]);
681	// }
682	// priorityCombo.select(priorityCombo.indexOf(value));
683	// // priorityCombo.addListener(SWT.Modify, this);
684	// priorityCombo.addSelectionListener(new
685	// ComboSelectionListener(priorityCombo));
686	// priorityCombo.addListener(SWT.FocusIn, new GenericListener());
687	// comboListenerMap.put(priorityCombo, attribute);
688	// currentCol += 2;
689	// } else if (key.equals("bug_severity")) {
690	// // newLayout(attributesComposite, 1, name, PROPERTY);
691	// toolkit.createLabel(attributesComposite, name);
692	// severityCombo = new CCombo(attributesComposite, SWT.FLAT \|
693	// SWT.READ_ONLY);
694	// toolkit.adapt(severityCombo, true, true);
695	// severityCombo.setFont(TEXT_FONT);
696	// severityCombo.setLayoutData(data);
697	// // severityCombo.setBackground(background);
698	// Set<String> s = values.keySet();
699	// String[] a = s.toArray(new String[s.size()]);
700	// Arrays.sort(a);
701	// for (int i = 0; i < a.length; i++) {
702	// severityCombo.add(a[i]);
703	// }
704	// severityCombo.select(severityCombo.indexOf(value));
705	// severityCombo.addSelectionListener(new
706	// ComboSelectionListener(severityCombo));
707	// // severityCombo.addListener(SWT.Modify, this);
708	// severityCombo.addListener(SWT.FocusIn, new GenericListener());
709	// comboListenerMap.put(severityCombo, attribute);
710	// currentCol += 2;
711	// } else if (key.equals("target_milestone")) {
712	// // newLayout(attributesComposite, 1, name, PROPERTY);
713	// toolkit.createLabel(attributesComposite, name);
714	// milestoneCombo = new CCombo(attributesComposite, SWT.FLAT \|
715	// SWT.NO_BACKGROUND \| SWT.MULTI
716	// \| SWT.V_SCROLL \| SWT.READ_ONLY);
717	// toolkit.adapt(milestoneCombo, true, true);
718	// milestoneCombo.setFont(TEXT_FONT);
719	// milestoneCombo.setLayoutData(data);
720	// // milestoneCombo.setBackground(background);
721	// Set<String> s = values.keySet();
722	// String[] a = s.toArray(new String[s.size()]);
723	// Arrays.sort(a);
724	// for (int i = 0; i < a.length; i++) {
725	// milestoneCombo.add(a[i]);
726	// }
727	// milestoneCombo.select(milestoneCombo.indexOf(value));
728	// // milestoneCombo.addListener(SWT.Modify, this);
729	// milestoneCombo.addSelectionListener(new
730	// ComboSelectionListener(milestoneCombo));
731	// milestoneCombo.addListener(SWT.FocusIn, new GenericListener());
732	// comboListenerMap.put(milestoneCombo, attribute);
733	// currentCol += 2;
734	// } else if (key.equals("rep_platform")) {
735	// // newLayout(attributesComposite, 1, name, PROPERTY);
736	// toolkit.createLabel(attributesComposite, name);
737	// platformCombo = new CCombo(attributesComposite, SWT.FLAT \|
738	// SWT.NO_BACKGROUND \| SWT.MULTI \| SWT.V_SCROLL
739	// \| SWT.READ_ONLY);
740	// toolkit.adapt(platformCombo, true, true);
741	// platformCombo.setFont(TEXT_FONT);
742	// platformCombo.setLayoutData(data);
743	// // platformCombo.setBackground(background);
744	// Set<String> s = values.keySet();
745	// String[] a = s.toArray(new String[s.size()]);
746	// Arrays.sort(a);
747	// for (int i = 0; i < a.length; i++) {
748	// platformCombo.add(a[i]);
749	// }
750	// platformCombo.select(platformCombo.indexOf(value));
751	// // platformCombo.addListener(SWT.Modify, this);
752	// platformCombo.addSelectionListener(new
753	// ComboSelectionListener(platformCombo));
754	// platformCombo.addListener(SWT.FocusIn, new GenericListener());
755	// comboListenerMap.put(platformCombo, attribute);
756	// currentCol += 2;
757	// } else if (key.equals("product")) {
758	// // newLayout(attributesComposite, 1, name, PROPERTY);
759	// toolkit.createLabel(attributesComposite, name);
760	// // toolkit.createLabel(attributesComposite, value);
761	// Composite uneditableComp = toolkit.createComposite(attributesComposite);
762	// GridLayout textLayout = new GridLayout();
763	// textLayout.marginWidth = 1;
764	// uneditableComp.setLayout(textLayout);
765	// toolkit.createText(uneditableComp, value, SWT.READ_ONLY);//
766	// Label(attributesComposite,
767	// // value);
768	// // newLayout(attributesComposite, 1, value,
769	// // VALUE).addListener(SWT.FocusIn, new GenericListener());
770	// currentCol += 2;
771	// } else if (key.equals("assigned_to")) {
772	// // newLayout(attributesComposite, 1, name, PROPERTY);
773	// toolkit.createLabel(attributesComposite, name);
774	// assignedTo = new Text(attributesComposite, SWT.SINGLE \| SWT.WRAP);
775	// assignedTo.setFont(TEXT_FONT);
776	// assignedTo.setText(value);
777	// data = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
778	// data.horizontalSpan = 1;
779	// assignedTo.setLayoutData(data);
780	//
781	// assignedTo.addListener(SWT.KeyUp, new Listener() {
782	// public void handleEvent(Event event) {
783	// String sel = assignedTo.getText();
784	// AbstractRepositoryReportAttribute a = getReport().getAttribute(
785	// BugzillaReportElement.ASSIGNED_TO);
786	// if (!(a.getValue().equals(sel))) {
787	// a.setValue(sel);
788	// changeDirtyStatus(true);
789	// }
790	// }
791	// });
792	// assignedTo.addListener(SWT.FocusIn, new GenericListener());
793	//
794	// currentCol += 2;
795	// } else if (key.equals("component")) {
796	// // newLayout(attributesComposite, 1, name, PROPERTY);
797	// toolkit.createLabel(attributesComposite, name);
798	// componentCombo = new CCombo(attributesComposite, SWT.FLAT \|
799	// SWT.NO_BACKGROUND \| SWT.MULTI
800	// \| SWT.V_SCROLL \| SWT.READ_ONLY);
801	// toolkit.adapt(componentCombo, true, true);
802	// componentCombo.setFont(TEXT_FONT);
803	// componentCombo.setLayoutData(data);
804	// // componentCombo.setBackground(background);
805	// Set<String> s = values.keySet();
806	// String[] a = s.toArray(new String[s.size()]);
807	// Arrays.sort(a);
808	// for (int i = 0; i < a.length; i++) {
809	// componentCombo.add(a[i]);
810	// }
811	// componentCombo.select(componentCombo.indexOf(value));
812	// // componentCombo.addListener(SWT.Modify, this);
813	// componentCombo.addSelectionListener(new
814	// ComboSelectionListener(componentCombo));
815	// componentCombo.addListener(SWT.FocusIn, new GenericListener());
816	// comboListenerMap.put(componentCombo, attribute);
817	// currentCol += 2;
818	// } else if (name.equals("Summary")) {
819	// // Don't show the summary here.
820	// continue;
821	// } else if (name.equals("Last Modified")) {
822	// // Don't show last modified here.
823	// continue;
824	// } else if (name.equals("Bug#")) {
825	// // Don't show bug number here
826	// continue;
827	// } else if (key.equals("bug_status")) {
828	// // newLayout(attributesComposite, 1, name, PROPERTY);
829	// toolkit.createLabel(attributesComposite, name);
830	// Composite uneditableComp = toolkit.createComposite(attributesComposite);
831	// GridLayout textLayout = new GridLayout();
832	// textLayout.marginWidth = 1;
833	// uneditableComp.setLayout(textLayout);
834	// toolkit.createText(uneditableComp, value, SWT.READ_ONLY);//
835	// Label(attributesComposite,
836	// // value);
837	// // newLayout(attributesComposite, 1, value,
838	// // VALUE).addListener(SWT.FocusIn, new GenericListener());
839	// currentCol += 2;
840	// } else if (values.isEmpty()) {
841	// // newLayout(attributesComposite, 1, name, PROPERTY);
842	// toolkit.createLabel(attributesComposite, name);
843	// Composite uneditableComp = toolkit.createComposite(attributesComposite);
844	// GridLayout textLayout = new GridLayout();
845	// textLayout.marginWidth = 1;
846	// uneditableComp.setLayout(textLayout);
847	// toolkit.createText(uneditableComp, value, SWT.READ_ONLY);//
848	// Label(attributesComposite,
849	// // value);
850	// // newLayout(attributesComposite, 1, value,
851	// // VALUE).addListener(SWT.FocusIn, new GenericListener());
852	// currentCol += 2;
853	// }
854	// if (currentCol > attributesLayout.numColumns) {
855	// currentCol -= attributesLayout.numColumns;
856	// }
857	// }
858	// // End Populate Attributes
859	//
860	// // make sure that we are in the first column
861	// if (currentCol > 1) {
862	// while (currentCol <= attributesLayout.numColumns) {
863	// newLayout(attributesComposite, 1, "", PROPERTY);
864	// currentCol++;
865	// }
866	// }
867	//
868	// // URL field
869	// addUrlText(url, attributesComposite);
870	//
871	// // keywords text field (not editable)
872	// addKeywordsList(toolkit, keywords, attributesComposite);
873	// // if (ccValue != null) {
874	// // addCCList(toolkit, ccValue, attributesComposite);
875	// // }
876	// addSummaryText(attributesComposite);
877	// // End URL, Keywords, Summary Text Fields
878	// toolkit.paintBordersFor(attributesComposite);
879	// }
880
493	/**	881	/**
494	* Creates the attribute layout, which contains most of the basic attributes	882	* Creates the attribute layout, which contains most of the basic attributes
495	* of the bug (some of which are editable).	883	* of the bug (some of which are editable).
Lines 497-505 Link Here
497	protected void createAttributeLayout() {	885	protected void createAttributeLayout() {
498		886
499	String title = getTitleString();	887	String title = getTitleString();
500	String keywords = "";
501	String url = "";
502
503	Section section = toolkit.createSection(form.getBody(), ExpandableComposite.TITLE_BAR \| Section.TWISTIE);	888	Section section = toolkit.createSection(form.getBody(), ExpandableComposite.TITLE_BAR \| Section.TWISTIE);
504	section.setText(LABEL_SECTION_ATTRIBUTES);	889	section.setText(LABEL_SECTION_ATTRIBUTES);
505	section.setExpanded(true);	890	section.setExpanded(true);
Lines 516-522 Link Here
516	}	901	}
517	});	902	});
518		903
519	// Attributes Composite- this holds all the combo fiels and text fields	904	// Attributes Composite- this holds all the combo fields and text fields
520	Composite attributesComposite = toolkit.createComposite(section);	905	Composite attributesComposite = toolkit.createComposite(section);
521	GridLayout attributesLayout = new GridLayout();	906	GridLayout attributesLayout = new GridLayout();
522	attributesLayout.numColumns = 4;	907	attributesLayout.numColumns = 4;
Lines 527-822 Link Here
527	attributesData.horizontalSpan = 1;	912	attributesData.horizontalSpan = 1;
528	attributesData.grabExcessVerticalSpace = false;	913	attributesData.grabExcessVerticalSpace = false;
529	attributesComposite.setLayoutData(attributesData);	914	attributesComposite.setLayoutData(attributesData);
530	// attributesComposite.setBackground(background);
531	// End Attributes Composite
532
533	section.setClient(attributesComposite);	915	section.setClient(attributesComposite);
534
535	// Attributes Title Area
536	// Composite attributesTitleComposite = new
537	// Composite(attributesComposite, SWT.NONE);
538	// GridLayout attributesTitleLayout = new GridLayout();
539	// attributesTitleLayout.horizontalSpacing = 0;
540	// attributesTitleLayout.marginWidth = 0;
541	// attributesTitleComposite.setLayout(attributesTitleLayout);
542	// attributesTitleComposite.setBackground(background);
543	// GridData attributesTitleData = new
544	// GridData(GridData.HORIZONTAL_ALIGN_FILL);
545	// attributesTitleData.horizontalSpan = 4;
546	// attributesTitleData.grabExcessVerticalSpace = false;
547	// attributesTitleComposite.setLayoutData(attributesTitleData);
548	// End Attributes Title
549
550	// Set the Attributes Title
551	// newAttributesLayout(attributesTitleComposite);
552	// titleLabel.setText(title);
553	bugzillaInput.setToolTipText(title);	916	bugzillaInput.setToolTipText(title);
		917
554	int currentCol = 1;	918	int currentCol = 1;
555		919
556	String ccValue = null;	920	for (AbstractRepositoryReportAttribute attribute : getReport().getAttributes()) {
557		921
558	// Populate Attributes	922	// String key = attribute.getID();
559	for (Iterator<Attribute> it = getBug().getAttributes().iterator(); it.hasNext();) {
560	Attribute attribute = it.next();
561	String key = attribute.getParameterName();
562	String name = attribute.getName();	923	String name = attribute.getName();
563	String value = checkText(attribute.getValue());	924	String value = checkText(attribute.getValue());
564	Map<String, String> values = attribute.getOptionValues();	925	// System.err.println(">>> AbstractBugEditor>> name: "+name+"
565		926	// key:"+key+" value:"+value+" is hidden"+attribute.isHidden());
566	// make sure we don't try to display a hidden field	927	if (attribute.isHidden())
567	if (attribute.isHidden() \|\| (key != null && key.equals("status_whiteboard")))
568	continue;	928	continue;
569		929	Map<String, String> values = attribute.getOptionValues();
570	if (values == null)	930	if (values == null)
571	values = new HashMap<String, String>();	931	values = new HashMap<String, String>();
572		932
573	if (key == null)
574	key = "";
575
576	GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL);	933	GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
577	data.horizontalSpan = 1;	934	data.horizontalSpan = 1;
578	data.horizontalIndent = HORZ_INDENT;	935	data.horizontalIndent = HORZ_INDENT;
579		936
580	if (key.equals("short_desc") \|\| key.equals("keywords")) {	937	if (attribute.hasOptions() && !attribute.isReadOnly()) {
581	keywords = value;
582	} else if (key.equals("newcc")) {
583	ccValue = value;
584	if (value == null)
585	ccValue = "";
586	} else if (key.equals("bug_file_loc")) {
587	url = value;
588	} else if (key.equals("op_sys")) {
589	// newLayout(attributesComposite, 1, name, PROPERTY);
590	toolkit.createLabel(attributesComposite, name);
591	// oSCombo = new Combo(attributesComposite, SWT.NO_BACKGROUND \|
592	// SWT.MULTI \| SWT.V_SCROLL \| SWT.READ_ONLY);//SWT.NONE
593	oSCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.READ_ONLY);
594	// oSCombo = new Combo(attributesComposite, SWT.FLAT \|
595	// SWT.READ_ONLY);
596	toolkit.adapt(oSCombo, true, true);
597	oSCombo.setFont(TEXT_FONT);
598	oSCombo.setLayoutData(data);
599	// oSCombo.setBackground(background);
600	Set<String> s = values.keySet();
601	String[] a = s.toArray(new String[s.size()]);
602	Arrays.sort(a);
603	for (int i = 0; i < a.length; i++) {
604	oSCombo.add(a[i]);
605	}
606	if (oSCombo.indexOf(value) != -1) {
607	oSCombo.select(oSCombo.indexOf(value));
608	} else {
609	oSCombo.select(oSCombo.indexOf("All"));
610	}
611	// oSCombo.addListener(SWT.Modify, this);
612	oSCombo.addSelectionListener(new ComboSelectionListener(oSCombo));
613	comboListenerMap.put(oSCombo, name);
614	oSCombo.addListener(SWT.FocusIn, new GenericListener());
615	currentCol += 2;
616	} else if (key.equals("version")) {
617	// newLayout(attributesComposite, 1, name, PROPERTY);
618	toolkit.createLabel(attributesComposite, name);
619	versionCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.NO_BACKGROUND \| SWT.MULTI \| SWT.V_SCROLL
620	\| SWT.READ_ONLY);
621	toolkit.adapt(versionCombo, true, true);
622	versionCombo.setFont(TEXT_FONT);
623	versionCombo.setLayoutData(data);
624	// versionCombo.setBackground(background);
625	Set<String> s = values.keySet();
626	String[] a = s.toArray(new String[s.size()]);
627	Arrays.sort(a);
628	for (int i = 0; i < a.length; i++) {
629	versionCombo.add(a[i]);
630	}
631	versionCombo.select(versionCombo.indexOf(value));
632	// versionCombo.addListener(SWT.Modify, this);
633	versionCombo.addSelectionListener(new ComboSelectionListener(versionCombo));
634	versionCombo.addListener(SWT.FocusIn, new GenericListener());
635	comboListenerMap.put(versionCombo, name);
636	currentCol += 2;
637	} else if (key.equals("priority")) {
638	// newLayout(attributesComposite, 1, "Priority", PROPERTY);
639	toolkit.createLabel(attributesComposite, name);	938	toolkit.createLabel(attributesComposite, name);
640	priorityCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.V_SCROLL \| SWT.READ_ONLY);	939	attributeCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.READ_ONLY);
641	toolkit.adapt(priorityCombo, true, true);	940	toolkit.adapt(attributeCombo, true, true);
642	priorityCombo.setFont(TEXT_FONT);	941	attributeCombo.setFont(TEXT_FONT);
643	priorityCombo.setLayoutData(data);	942	attributeCombo.setLayoutData(data);
644	// priorityCombo.setBackground(background);
645	Set<String> s = values.keySet();	943	Set<String> s = values.keySet();
646	String[] a = s.toArray(new String[s.size()]);	944	String[] a = s.toArray(new String[s.size()]);
647	Arrays.sort(a);	945	Arrays.sort(a);
648	for (int i = 0; i < a.length; i++) {	946	for (int i = 0; i < a.length; i++) {
649	priorityCombo.add(a[i]);	947	attributeCombo.add(a[i]);
650	}	948	}
651	priorityCombo.select(priorityCombo.indexOf(value));	949	if (attributeCombo.indexOf(value) != -1) {
652	// priorityCombo.addListener(SWT.Modify, this);	950	attributeCombo.select(attributeCombo.indexOf(value));
653	priorityCombo.addSelectionListener(new ComboSelectionListener(priorityCombo));
654	priorityCombo.addListener(SWT.FocusIn, new GenericListener());
655	comboListenerMap.put(priorityCombo, name);
656	currentCol += 2;
657	} else if (key.equals("bug_severity")) {
658	// newLayout(attributesComposite, 1, name, PROPERTY);
659	toolkit.createLabel(attributesComposite, name);
660	severityCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.READ_ONLY);
661	toolkit.adapt(severityCombo, true, true);
662	severityCombo.setFont(TEXT_FONT);
663	severityCombo.setLayoutData(data);
664	// severityCombo.setBackground(background);
665	Set<String> s = values.keySet();
666	String[] a = s.toArray(new String[s.size()]);
667	Arrays.sort(a);
668	for (int i = 0; i < a.length; i++) {
669	severityCombo.add(a[i]);
670	}	951	}
671	severityCombo.select(severityCombo.indexOf(value));	952	attributeCombo.addSelectionListener(new ComboSelectionListener(attributeCombo));
672	severityCombo.addSelectionListener(new ComboSelectionListener(severityCombo));	953	comboListenerMap.put(attributeCombo, attribute);
673	// severityCombo.addListener(SWT.Modify, this);	954	attributeCombo.addListener(SWT.FocusIn, new GenericListener());
674	severityCombo.addListener(SWT.FocusIn, new GenericListener());
675	comboListenerMap.put(severityCombo, name);
676	currentCol += 2;	955	currentCol += 2;
677	} else if (key.equals("target_milestone")) {	956	} else {
678	// newLayout(attributesComposite, 1, name, PROPERTY);
679	toolkit.createLabel(attributesComposite, name);	957	toolkit.createLabel(attributesComposite, name);
680	milestoneCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.NO_BACKGROUND \| SWT.MULTI	958	Composite textFieldComposite = toolkit.createComposite(attributesComposite);
681	\| SWT.V_SCROLL \| SWT.READ_ONLY);
682	toolkit.adapt(milestoneCombo, true, true);
683	milestoneCombo.setFont(TEXT_FONT);
684	milestoneCombo.setLayoutData(data);
685	// milestoneCombo.setBackground(background);
686	Set<String> s = values.keySet();
687	String[] a = s.toArray(new String[s.size()]);
688	Arrays.sort(a);
689	for (int i = 0; i < a.length; i++) {
690	milestoneCombo.add(a[i]);
691	}
692	milestoneCombo.select(milestoneCombo.indexOf(value));
693	// milestoneCombo.addListener(SWT.Modify, this);
694	milestoneCombo.addSelectionListener(new ComboSelectionListener(milestoneCombo));
695	milestoneCombo.addListener(SWT.FocusIn, new GenericListener());
696	comboListenerMap.put(milestoneCombo, name);
697	currentCol += 2;
698	} else if (key.equals("rep_platform")) {
699	// newLayout(attributesComposite, 1, name, PROPERTY);
700	toolkit.createLabel(attributesComposite, name);
701	platformCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.NO_BACKGROUND \| SWT.MULTI \| SWT.V_SCROLL
702	\| SWT.READ_ONLY);
703	toolkit.adapt(platformCombo, true, true);
704	platformCombo.setFont(TEXT_FONT);
705	platformCombo.setLayoutData(data);
706	// platformCombo.setBackground(background);
707	Set<String> s = values.keySet();
708	String[] a = s.toArray(new String[s.size()]);
709	Arrays.sort(a);
710	for (int i = 0; i < a.length; i++) {
711	platformCombo.add(a[i]);
712	}
713	platformCombo.select(platformCombo.indexOf(value));
714	// platformCombo.addListener(SWT.Modify, this);
715	platformCombo.addSelectionListener(new ComboSelectionListener(platformCombo));
716	platformCombo.addListener(SWT.FocusIn, new GenericListener());
717	comboListenerMap.put(platformCombo, name);
718	currentCol += 2;
719	} else if (key.equals("product")) {
720	// newLayout(attributesComposite, 1, name, PROPERTY);
721	toolkit.createLabel(attributesComposite, name);
722	// toolkit.createLabel(attributesComposite, value);
723	Composite uneditableComp = toolkit.createComposite(attributesComposite);
724	GridLayout textLayout = new GridLayout();	959	GridLayout textLayout = new GridLayout();
725	textLayout.marginWidth = 1;	960	textLayout.marginWidth = 1;
726	uneditableComp.setLayout(textLayout);	961	textFieldComposite.setLayout(textLayout);
727	toolkit.createText(uneditableComp, value, SWT.READ_ONLY);// Label(attributesComposite,	962	GridData textData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
728	// value);	963	textData.horizontalSpan = 1;
729	// newLayout(attributesComposite, 1, value,	964	textData.widthHint = 135;
730	// VALUE).addListener(SWT.FocusIn, new GenericListener());	965
731	currentCol += 2;	966	if (attribute.isReadOnly()) {
732	} else if (key.equals("assigned_to")) {	967	final Text text = toolkit.createText(textFieldComposite, value, SWT.FLAT \| SWT.READ_ONLY);
733	// newLayout(attributesComposite, 1, name, PROPERTY);	968	text.setLayoutData(textData);
734	toolkit.createLabel(attributesComposite, name);	969	} else {
735	assignedTo = new Text(attributesComposite, SWT.BORDER \| SWT.SINGLE \| SWT.WRAP);	970	final Text text = toolkit.createText(textFieldComposite, value, SWT.FLAT);
736	assignedTo.setFont(TEXT_FONT);	971	text.setLayoutData(textData);
737	assignedTo.setText(value);	972	toolkit.paintBordersFor(textFieldComposite);
738	data = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);	973	text.setData(attribute);
739	data.horizontalSpan = 1;	974	text.addListener(SWT.KeyUp, new Listener() {
740	assignedTo.setLayoutData(data);	975	public void handleEvent(Event event) {
741		976	String sel = text.getText();
742	assignedTo.addListener(SWT.KeyUp, new Listener() {	977	AbstractRepositoryReportAttribute a = (AbstractRepositoryReportAttribute) text.getData();
743	public void handleEvent(Event event) {	978	if (!(a.getValue().equals(sel))) {
744	String sel = assignedTo.getText();	979	a.setValue(sel);
745	Attribute a = getBug().getAttribute("Assign To");	980	changeDirtyStatus(true);
746	if (!(a.getNewValue().equals(sel))) {	981	}
747	a.setNewValue(sel);
748	changeDirtyStatus(true);
749	}	982	}
750	}	983	});
751	});	984	text.addListener(SWT.FocusIn, new GenericListener());
752	assignedTo.addListener(SWT.FocusIn, new GenericListener());
753
754	currentCol += 2;
755	} else if (key.equals("component")) {
756	// newLayout(attributesComposite, 1, name, PROPERTY);
757	toolkit.createLabel(attributesComposite, name);
758	componentCombo = new CCombo(attributesComposite, SWT.FLAT \| SWT.NO_BACKGROUND \| SWT.MULTI
759	\| SWT.V_SCROLL \| SWT.READ_ONLY);
760	toolkit.adapt(componentCombo, true, true);
761	componentCombo.setFont(TEXT_FONT);
762	componentCombo.setLayoutData(data);
763	// componentCombo.setBackground(background);
764	Set<String> s = values.keySet();
765	String[] a = s.toArray(new String[s.size()]);
766	Arrays.sort(a);
767	for (int i = 0; i < a.length; i++) {
768	componentCombo.add(a[i]);
769	}	985	}
770	componentCombo.select(componentCombo.indexOf(value));	986
771	// componentCombo.addListener(SWT.Modify, this);
772	componentCombo.addSelectionListener(new ComboSelectionListener(componentCombo));
773	componentCombo.addListener(SWT.FocusIn, new GenericListener());
774	comboListenerMap.put(componentCombo, name);
775	currentCol += 2;
776	} else if (name.equals("Summary")) {
777	// Don't show the summary here.
778	continue;
779	} else if (name.equals("Last Modified")) {
780	// Don't show last modified here.
781	continue;
782	} else if (name.equals("Bug#")) {
783	// Don't show bug number here
784	continue;
785	} else if (values.isEmpty()) {
786	// newLayout(attributesComposite, 1, name, PROPERTY);
787	toolkit.createLabel(attributesComposite, name);
788	Composite uneditableComp = toolkit.createComposite(attributesComposite);
789	GridLayout textLayout = new GridLayout();
790	textLayout.marginWidth = 1;
791	uneditableComp.setLayout(textLayout);
792	toolkit.createText(uneditableComp, value, SWT.READ_ONLY);// Label(attributesComposite,
793	// value);
794	// newLayout(attributesComposite, 1, value,
795	// VALUE).addListener(SWT.FocusIn, new GenericListener());
796	currentCol += 2;	987	currentCol += 2;
797	}	988	}
798	if (currentCol > attributesLayout.numColumns) {	989	if (currentCol > attributesLayout.numColumns) {
799	currentCol -= attributesLayout.numColumns;	990	currentCol -= attributesLayout.numColumns;
800	}	991	}
		992
801	}	993	}
802	// End Populate Attributes
803		994
804	// make sure that we are in the first column	995	// make sure that we are in the first column
805	if (currentCol > 1) {	996	if (currentCol > 1) {
806	while (currentCol <= attributesLayout.numColumns) {	997	while (currentCol <= attributesLayout.numColumns) {
807	newLayout(attributesComposite, 1, "", PROPERTY);	998	toolkit.createLabel(attributesComposite, "");
		999	// newLayout(attributesComposite, 1, "", PROPERTY);
808	currentCol++;	1000	currentCol++;
809	}	1001	}
810	}	1002	}
811		1003
812	// URL, Keywords, Summary Text Fields	1004	// Perhaps these should be performed in subclass eventually
813	addUrlText(url, attributesComposite);	1005
		1006	addCCList(toolkit, "", attributesComposite);
		1007
		1008	// URL field
		1009	addUrlText(getReport().getAttributeValue(BugzillaReportElement.BUG_FILE_LOC), attributesComposite);
814		1010
815	// keywords text field (not editable)	1011	// keywords text field (not editable)
816	addKeywordsList(toolkit, keywords, attributesComposite);	1012	addKeywordsList(toolkit, getReport().getAttributeValue(BugzillaReportElement.KEYWORDS), attributesComposite);
817	if (ccValue != null) {	1013
818	addCCList(toolkit, ccValue, attributesComposite);
819	}
820	addSummaryText(attributesComposite);	1014	addSummaryText(attributesComposite);
821	// End URL, Keywords, Summary Text Fields	1015	// End URL, Keywords, Summary Text Fields
822	toolkit.paintBordersFor(attributesComposite);	1016	toolkit.paintBordersFor(attributesComposite);
Lines 843-851 Link Here
843	urlText.addListener(SWT.KeyUp, new Listener() {	1037	urlText.addListener(SWT.KeyUp, new Listener() {
844	public void handleEvent(Event event) {	1038	public void handleEvent(Event event) {
845	String sel = urlText.getText();	1039	String sel = urlText.getText();
846	Attribute a = getBug().getAttribute("URL");	1040	AbstractRepositoryReportAttribute a = getReport().getAttribute(BugzillaReportElement.BUG_FILE_LOC);
847	if (!(a.getNewValue().equals(sel))) {	1041	if (!(a.getValue().equals(sel))) {
848	a.setNewValue(sel);	1042	a.setValue(sel);
849	changeDirtyStatus(true);	1043	changeDirtyStatus(true);
850	}	1044	}
851	}	1045	}
Lines 1187-1198 Link Here
1187	public void saveBug() {	1381	public void saveBug() {
1188	try {	1382	try {
1189	updateBug();	1383	updateBug();
1190	IBugzillaBug bug = getBug();	1384	// IBugzillaBug bug = getBug();
1191		1385
1192	final BugzillaRepositoryConnector bugzillaRepositoryClient = (BugzillaRepositoryConnector) MylarTaskListPlugin	1386	final BugzillaRepositoryConnector bugzillaRepositoryClient = (BugzillaRepositoryConnector) MylarTaskListPlugin
1193	.getRepositoryManager().getRepositoryConnector(BugzillaPlugin.REPOSITORY_KIND);	1387	.getRepositoryManager().getRepositoryConnector(BugzillaPlugin.REPOSITORY_KIND);
1194	changeDirtyStatus(false);	1388	changeDirtyStatus(false);
1195	bugzillaRepositoryClient.saveBugReport(bug);	1389	bugzillaRepositoryClient.saveBugReport((BugzillaReport) getReport());
1196	} catch (Exception e) {	1390	} catch (Exception e) {
1197	MylarStatusHandler.fail(e, "bug save offline failed", true);	1391	MylarStatusHandler.fail(e, "bug save offline failed", true);
1198	}	1392	}
Lines 1336-1342 Link Here
1336	*/	1530	*/
1337	protected class GenericListener implements Listener {	1531	protected class GenericListener implements Listener {
1338	public void handleEvent(Event event) {	1532	public void handleEvent(Event event) {
1339	IBugzillaBug bug = getBug();	1533	BugzillaReport bug = (BugzillaReport) getReport();
1340	fireSelectionChanged(new SelectionChangedEvent(selectionProvider, new StructuredSelection(	1534	fireSelectionChanged(new SelectionChangedEvent(selectionProvider, new StructuredSelection(
1341	new BugzillaReportSelection(bug.getId(), bug.getRepositoryUrl(), bug.getLabel(), false, bug	1535	new BugzillaReportSelection(bug.getId(), bug.getRepositoryUrl(), bug.getLabel(), false, bug
1342	.getSummary()))));	1536	.getSummary()))));





package org.eclipse.mylar.internal.bugzilla.ui.editor;

import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;

/**
 * The <code>IEditorInput</code> implementation for <code>NewBugEditor</code>.
 */
public class NewBugEditorInput extends AbstractBugEditorInput {

	protected NewBugzillaReport bug;

	/**
	 * Creates a new <code>NewBugEditorInput</code>.

	 * @param bug
	 *            The bug for this editor input.
	 */
	public NewBugEditorInput(NewBugzillaReport bug) {
		this.bug = bug;
	}


	}

	@Override
	public NewBugzillaReport getBug() {
		return bug;
	}





import java.util.ArrayList;
import java.util.Iterator;

import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.Comment;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaReportSelection;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.ui.BugzillaImages;
import org.eclipse.swt.graphics.Image;


	public static BugzillaOutlineNode parseBugReport(IBugzillaBug bug) {
		// Choose the appropriate parsing function based on
		// the type of IBugzillaBug.
		if (bug instanceof NewBugzillaReport) {
			return parseBugReport((NewBugzillaReport) bug);
		} else if (bug instanceof BugzillaReport) {
			return parseBugReport((BugzillaReport) bug);
		} else {
			return null;
		}

	 *            The <code>NewBugModel</code> that needs parsing.
	 * @return The tree of <code>BugzillaOutlineNode</code>'s.
	 */
	protected static BugzillaOutlineNode parseBugReport(NewBugzillaReport bug) {
		int bugId = bug.getId();
		String bugServer = bug.getRepositoryUrl();
		Image bugImage = BugzillaImages.getImage(BugzillaImages.BUG);

	 *            The <code>BugReport</code> that needs parsing.
	 * @return The tree of <code>BugzillaOutlineNode</code>'s.
	 */
	protected static BugzillaOutlineNode parseBugReport(BugzillaReport bug) {

		int bugId = bug.getId();
		String bugServer = bug.getRepositoryUrl();

		BugzillaOutlineNode comments = null;
		for (Iterator<Comment> iter = bug.getComments().iterator(); iter.hasNext();) {
			Comment comment = iter.next();
			// first comment is the bug description
			if(comment.getNumber() == 0) continue;
			if (comments == null) {
				comments = new BugzillaOutlineNode(bugId, bugServer, "Comments", defaultImage, comment, bug
						.getSummary());





import javax.security.auth.login.LoginException;

import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;


	protected int bugId;

	protected BugzillaReport bug;

	/**
	 * Creates a new <code>ExistingBugEditorInput</code>.

	 * @param bug
	 *            The bug for this editor input.
	 */
	public ExistingBugEditorInput(BugzillaReport bug) {
		this.bug = bug;
		this.bugId = bug.getId();
		repository = MylarTaskListPlugin.getRepositoryManager().getRepository(BugzillaPlugin.REPOSITORY_KIND,

	}

	@Override
	public BugzillaReport getBug() {
		return bug;
	}





import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.hyperlink.IHyperlink;
import org.eclipse.mylar.bugzilla.core.BugzillaReport;
import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.ui.editor.ExistingBugEditor;
import org.eclipse.mylar.internal.bugzilla.ui.editor.ExistingBugEditorInput;
import org.eclipse.mylar.internal.bugzilla.ui.editor.NewBugEditorInput;

	}

	public static void closeEditor(IWorkbenchPage page, IBugzillaBug bug) {
		if (bug instanceof NewBugzillaReport) {
			IEditorInput input = new NewBugEditorInput((NewBugzillaReport) bug);
			IEditorPart bugEditor = page.findEditor(input);
			if (bugEditor != null) {
				page.closeEditor(bugEditor, false);
			}
		} else if (bug instanceof BugzillaReport) {
			IEditorInput input = new ExistingBugEditorInput((BugzillaReport) bug);
			IEditorPart bugEditor = page.findEditor(input);
			if (bugEditor != null) {
				page.closeEditor(bugEditor, false);




import org.eclipse.mylar.internal.bugzilla.core.BugzillaException;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.PossibleBugzillaFailureException;
import org.eclipse.mylar.internal.bugzilla.ui.BugzillaUiPlugin;
import org.eclipse.mylar.internal.bugzilla.ui.WebBrowserDialog;

	protected boolean fromDialog = false;

	/** The model used to store all of the data for the wizard */
	protected NewBugzillaReport model;

	/**
	 * Flag to indicate if the wizard can be completed based on the attributes

	public AbstractBugWizard(TaskRepository repository) {
		super();
		this.repository = repository;
		model = new NewBugzillaReport(repository.getUrl());
		id = null; // Since there is no bug posted yet.
		super.setDefaultPageImageDescriptor(BugzillaUiPlugin.imageDescriptorFromPlugin(
				"org.eclipse.mylar.internal.bugzilla.ui", "icons/wizban/bug-wizard.gif"));




import org.eclipse.core.runtime.Status;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
import org.eclipse.mylar.internal.bugzilla.ui.editor.AbstractBugEditor;
import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
import org.eclipse.swt.SWT;

	public void saveDataToModel() {
		// get the model that we are using
		AbstractBugWizard wizard = (AbstractBugWizard) getWizard();
		NewBugzillaReport nbm = wizard.model;

		nbm.setDescription(descriptionText.getText());
		nbm.setSummary(summaryText.getText());

		// go through each of the attributes and sync their values with the
		// combo boxes
		for (Iterator<AbstractRepositoryReportAttribute> it = nbm.getAttributes().iterator(); it.hasNext();) {
			AbstractRepositoryReportAttribute attribute = it.next();
			String key = attribute.getName();
			Map<String, String> values = attribute.getOptionValues();

			try {
				if (values == null)
					values = new HashMap<String, String>();
				if (key.equals(BugzillaReportElement.OP_SYS.toString())) {
					String os = oSCombo.getItem(oSCombo.getSelectionIndex());
					attribute.setValue(os);
				} else if (key.equals(BugzillaReportElement.VERSION.toString())) {
					String version = versionCombo.getItem(versionCombo.getSelectionIndex());
					attribute.setValue(version);
				} else if (key.equals(BugzillaReportElement.BUG_SEVERITY.toString())) {
					String severity = severityCombo.getItem(severityCombo.getSelectionIndex());
					attribute.setValue(severity);
				} else if (key.equals(BugzillaReportElement.REP_PLATFORM.toString())) {
					String platform = platformCombo.getItem(platformCombo.getSelectionIndex());
					attribute.setValue(platform);
				} else if (key.equals(BugzillaReportElement.TARGET_MILESTONE.toString())) {
					int index = milestoneCombo.getSelectionIndex();
					if(index >= 0) {
						String milestone = milestoneCombo.getItem(milestoneCombo.getSelectionIndex());
						attribute.setValue(milestone);
					}
				} else if (key.equals(BugzillaReportElement.COMPONENT.toString())) {
					String component = componentCombo.getItem(componentCombo.getSelectionIndex());
					attribute.setValue(component);
				} else if (key.equals(BugzillaReportElement.PRIORITY.toString())) {
					String priority = priorityCombo.getItem(priorityCombo.getSelectionIndex());
					attribute.setValue(priority);
				} else if (key.equals(BugzillaReportElement.BUG_FILE_LOC.toString())) {
					if (urlText != null) {
						String url = urlText.getText();
						if (url.equalsIgnoreCase("http://"))
							url = "";
						attribute.setValue(url);
					}					
				} else if (key.equals(BugzillaReportElement.ASSIGNED_TO.toString())) {
					String assignTo = assignedToText.getText();
					attribute.setValue(assignTo);
				} else {


		// get the model for the new bug
		AbstractBugWizard wizard = (AbstractBugWizard) getWizard();
		NewBugzillaReport nbm = wizard.model;

		// Set the current platform and OS on the model
		setPlatformOptions(nbm);

		newLayout(attributesComposite, 1, nbm.getProduct(), VALUE);

		// Populate Attributes
		for (Iterator<AbstractRepositoryReportAttribute> it = nbm.getAttributes().iterator(); it.hasNext();) {
			AbstractRepositoryReportAttribute attribute = it.next();
			String key = attribute.getID();
			String name = attribute.getName();
			String value = checkText(attribute.getValue());
			Map<String, String> values = attribute.getOptionValues();

			data.horizontalIndent = HORZ_INDENT;
			data.widthHint = 150;
			// create and populate the combo fields for the attributes
			if (key.equals(BugzillaReportElement.OP_SYS.getKeyString())) {
				newLayout(attributesComposite, 1, name, PROPERTY);
				oSCombo = new Combo(attributesComposite, SWT.NO_BACKGROUND | SWT.MULTI | SWT.V_SCROLL | SWT.READ_ONLY);


					index = 0;
				oSCombo.select(index);
				oSCombo.addListener(SWT.Modify, this);
			} else if (key.equals(BugzillaReportElement.VERSION.getKeyString())) {
				newLayout(attributesComposite, 1, name, PROPERTY);

				versionCombo = new Combo(attributesComposite, SWT.NO_BACKGROUND | SWT.MULTI | SWT.V_SCROLL

					index = 0;
				versionCombo.select(index);
				versionCombo.addListener(SWT.Modify, this);
			} else if (key.equals(BugzillaReportElement.BUG_SEVERITY.getKeyString())) {
				newLayout(attributesComposite, 1, name, PROPERTY);
				severityCombo = new Combo(attributesComposite, SWT.NO_BACKGROUND | SWT.MULTI | SWT.V_SCROLL
						| SWT.READ_ONLY);

				severityCombo.select(index);
				severityCombo.addListener(SWT.Modify, this);

			} else if (key.equals(BugzillaReportElement.REP_PLATFORM.getKeyString())) {
				newLayout(attributesComposite, 1, name, PROPERTY);
				platformCombo = new Combo(attributesComposite, SWT.NO_BACKGROUND | SWT.MULTI | SWT.V_SCROLL
						| SWT.READ_ONLY);

					index = 0;
				platformCombo.select(index);
				platformCombo.addListener(SWT.Modify, this);
			} else if (key.equals(BugzillaReportElement.TARGET_MILESTONE.getKeyString())) {
				newLayout(attributesComposite, 1, name, PROPERTY);
				milestoneCombo = new Combo(attributesComposite, SWT.NO_BACKGROUND | SWT.MULTI | SWT.V_SCROLL
						| SWT.READ_ONLY);

				milestoneCombo.addListener(SWT.Modify, this);
				//if(s.isEmpty()) milestoneCombo.setEnabled(false);
				mileExist = true;
			} else if (key.equals(BugzillaReportElement.COMPONENT.getKeyString())) {
				newLayout(attributesComposite, 1, name, PROPERTY);
				componentCombo = new Combo(attributesComposite, SWT.NO_BACKGROUND | SWT.MULTI | SWT.V_SCROLL
						| SWT.READ_ONLY);

					index = 0;
				componentCombo.select(index);
				componentCombo.addListener(SWT.Modify, this);
			} else if (key.equals(BugzillaReportElement.PRIORITY.getKeyString())) {
				newLayout(attributesComposite, 1, name, PROPERTY);
				priorityCombo = new Combo(attributesComposite, SWT.NO_BACKGROUND | SWT.MULTI | SWT.V_SCROLL
						| SWT.READ_ONLY);

				priorityCombo.select(index);
				priorityCombo.addListener(SWT.Modify, this);
				priExist = true;
			} else if (key.equals(BugzillaReportElement.BUG_FILE_LOC.getKeyString())) {
				url = value;
			} else {
				// do nothing if it isn't a standard value to change

	
		GridData urlTextData;
		if (url != null) {			
			newLayout(textComposite, 1, BugzillaReportElement.BUG_FILE_LOC.toString(), PROPERTY);
			urlText = new Text(textComposite, SWT.BORDER | SWT.SINGLE | SWT.WRAP);
			urlTextData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);


		}

		GridData summaryTextData;
		newLayout(textComposite, 1, BugzillaReportElement.ASSIGNED_TO.toString(), PROPERTY);
		Label l = new Label(textComposite, SWT.NONE);
		l.setText("(if email is incorrect submit will not proceed)");
		summaryTextData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);

		assignedToText.setText("");

		// add the summary text field
		newLayout(textComposite, 1, BugzillaReportElement.SHORT_DESC.toString(), PROPERTY);
		summaryText = new Text(textComposite, SWT.BORDER | SWT.SINGLE | SWT.WRAP);
		summaryTextData = new GridData(GridData.HORIZONTAL_ALIGN_FILL);


	 * @param newBugModel
	 *            The bug to set the options for
	 */
	public void setPlatformOptions(NewBugzillaReport newBugModel) {
		try {
			// A Map from Java's OS and Platform to Buzilla's
			Map<String, String> java2buzillaOSMap = new HashMap<String, String>();

			java2buzillaOSMap.put("macosx", "MacOS X");
			java2buzillaOSMap.put("qnx", "QNX-Photon");
			java2buzillaOSMap.put("solaris", "Solaris");
			java2buzillaOSMap.put("win32", "Windows");

			// Get OS Lookup Map
			// Check that the result is in Values, if it is not, set it to other
			AbstractRepositoryReportAttribute opSysAttribute = newBugModel.getAttribute(BugzillaReportElement.OP_SYS);
			AbstractRepositoryReportAttribute platformAttribute = newBugModel.getAttribute(BugzillaReportElement.REP_PLATFORM);

			String OS = Platform.getOS();
			String platform = Platform.getOSArch();




import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
import org.eclipse.mylar.internal.bugzilla.core.BugzillaRepositoryUtil;
import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
import org.eclipse.mylar.internal.bugzilla.ui.BugzillaUiPlugin;
import org.eclipse.mylar.internal.tasklist.ui.views.TaskRepositoriesView;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;

		this.bugWizard = bugWiz;
		this.repository = repository;
		setImageDescriptor(BugzillaUiPlugin.imageDescriptorFromPlugin("org.eclipse.mylar.bugzilla.ui",
				"icons/wizban/bug-wizard.gif"));
	}

	protected ProgressMonitorDialog monitorDialog = new ProgressMonitorDialog(BugzillaPlugin.getDefault()

									"Bugzilla could not log you in to get the information you requested since login name or password is incorrect.\nPlease check your settings in the bugzilla preferences. ");
					BugzillaPlugin.log(exception);
				} catch (IOException exception) {
					MessageDialog.openError(null, "Connection Error",
							"\nPlease check your settings in the bugzilla preferences. ");
							null,
							"Connection Error","\nPlease check your settings in the bugzilla preferences. ");
				} finally {
					monitor.done();
					monitorDialog.close();

				bugWizard.model.setParsedProductsStatus(true);

			} catch (Exception e) {
				bugWizard.model.setConnected(false);
				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
					public void run() {
						MessageDialog.openError(Display.getDefault().getActiveShell(), NEW_BUGZILLA_TASK_ERROR_TITLE,
								"Unable to get products. Ensure proper repository configuration in "
										+ TaskRepositoriesView.NAME + ".");
					}
				});
			}

		// save the product information to the model
		saveDataToModel();
		NewBugzillaReportWizard wizard = (NewBugzillaReportWizard) getWizard();
		NewBugzillaReport model = wizard.model;

		// try to get the attributes from the bugzilla server
		try {
			if (!model.hasParsedAttributes()) {
				BugzillaRepositoryUtil.setupNewBugAttributes(repository, model);
				String serverUrl = repository.getUrl();
//				if (model.isConnected()) {
//					BugzillaRepositoryUtil.setupNewBugAttributes(serverUrl, model, false);
//				} else {
				
					BugzillaRepositoryUtil.setupBugAttributes(serverUrl, model);
//				}
				model.setParsedAttributesStatus(true);
			}

			if (prevProduct == null) {
				bugWizard.setAttributePage(new WizardAttributesPage(workbench));
				bugWizard.addPage(bugWizard.getAttributePage());
			} else {
				// selected product has changed
				// will createControl again with new attributes in model
				bugWizard.getAttributePage().setControl(null);
			}
			// }
		} catch (final Exception e) {
			e.printStackTrace();
			PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {

							.getLocalizedMessage()
							+ " Ensure proper repository configuration in " + TaskRepositoriesView.NAME + ".");
				}
			});
			// MylarStatusHandler.fail(e, e.getLocalizedMessage()+" Ensure
			// proper repository configuration in
			// "+TaskRepositoriesView.NAME+".", true);
			// BugzillaPlugin.getDefault().logAndShowExceptionDetailsDialog(e,
			// "occurred.", "Bugzilla Error");
		}
		return super.getNextPage();
	}

	 */
	private void saveDataToModel() {
		// Gets the model
		NewBugzillaReport model = bugWizard.model;

		prevProduct = model.getProduct();
		model.setProduct((listBox.getSelection())[0]);

Return to bug 136219

Lines 17-45 Link Here

(-)src/org/eclipse/mylar/bugzilla/core/BugzillaRemoteContextDelegate.java (-9 / +9 lines)
17		17
18	/**	18	/**
19	* @author Rob Elves	19	* @author Rob Elves
20	* TODO: Find a better spot for this	20	* TODO: Use of this delegate probably isn't necessary anymore
21	*/	21	*/
22	public class BugzillaRemoteContextDelegate implements IRemoteContextDelegate {	22	public class BugzillaRemoteContextDelegate implements IRemoteContextDelegate {
23		23
24	private Comment comment;	24	private ReportAttachment attachment;
25		25
26	public BugzillaRemoteContextDelegate(Comment comment) {	26	public BugzillaRemoteContextDelegate(ReportAttachment attachment) {
27	this.comment = comment;	27	this.attachment = attachment;
28	}	28	}
29	public Date getDate() {	29	public Date getDate() {
30	return comment.getCreated();	30	return attachment.getDateCreated();
31	}	31	}
32		32
33	public String getAuthor() {	33	public String getAuthor() {
34	return comment.getAuthor();	34	return attachment.getAuthor();
35	}	35	}
36		36
37	public String getComment() {	37	public String getComment() {
38	return comment.getText().trim();	38	return attachment.getDescription();
39	}	39	}
40		40
41	public int getId() {	41	public int getId() {
42	return comment.getAttachmentId();	42	return attachment.getId();
43	}	43	}
44		44
45	}	45	}

Removed Link Here

(-)src/org/eclipse/mylar/bugzilla/core/BugReport.java (-555 lines)
1	/*******************************************************************************
2	* Copyright (c) 2003 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.mylar.bugzilla.core;
12
13	import java.io.Serializable;
14	import java.io.UnsupportedEncodingException;
15	import java.nio.charset.Charset;
16	import java.util.ArrayList;
17	import java.util.Date;
18	import java.util.HashMap;
19	import java.util.HashSet;
20	import java.util.Iterator;
21	import java.util.List;
22	import java.util.Set;
23
24	import org.eclipse.core.runtime.IStatus;
25	import org.eclipse.core.runtime.Status;
26	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
27	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
28
29	/**
30	* A bug report entered in Bugzilla.
31	*
32	* @author Mik Kersten (hardening of prototype)
33	*/
34	public class BugReport implements Serializable, IBugzillaBug {
35
36	private static final String ATTR_REPORTER = "Reporter";
37
38	private static final String ATTR_RESOLUTION = "Resolution";
39
40	private static final String ATTR_ASSIGNED_TO = "Assigned To";
41
42	public static final String ATTR_SUMMARY = "Summary";
43
44	public static final String ATTR_STATUS = "Status";
45
46	public static final String ATTR_PRIORITY = "Priority";
47
48	public static final String VAL_STATUS_VERIFIED = "VERIFIED";
49
50	public static final String VAL_STATUS_CLOSED = "CLOSED";
51
52	public static final String VAL_STATUS_RESOLVED = "RESOLVED";
53
54	public static final String VAL_STATUS_NEW = "NEW";
55
56	public static final String KEY_MILESTONE = "target_milestone";
57
58	public static final String ATTRIBUTE_URL = "URL";
59
60	public static final String ATTRIBUTE_PRIORITY = "Priority";
61
62	public static final String ATTRIBUTE_COMPONENT = "Component";
63
64	public static final String ATTRIBUTE_VERSION = "Version";
65
66	public static final String ATTRIBUTE_PLATFORM = "Platform";
67
68	public static final String ATTRIBUTE_MILESTONE = "Target Milestone";
69
70	public static final String ATTRIBUTE_OS = "OS";
71
72	public static final String ATTRIBUTE_SEVERITY = "Severity";
73
74	private static final long serialVersionUID = 3258693199936631348L;
75
76	/** Bug id */
77	protected final int id;
78
79	/** The bug's server */
80	protected final String repositoryUrl;
81
82	/** Description of the bug */
83	protected String description;
84
85	/** Creation timestamp */
86	protected Date created;
87
88	/** Modification timestamp */
89	protected Date lastModified = null;
90
91	/** The bugs valid keywords */
92	protected List<String> validKeywords;
93
94	/** The operations that can be done on the bug */
95	protected List<Operation> operations = new ArrayList<Operation>();
96
97	/** Bug attributes (status, resolution, etc.) */
98	protected HashMap<String, Attribute> attributes = new HashMap<String, Attribute>();
99
100	// / Attachments (Id, Description) /
101	// protected HashMap<Integer, String> attachements = new HashMap<Integer, String>();
102
103	/** The keys for the bug attributes */
104	protected ArrayList<String> attributeKeys = new ArrayList<String>();
105
106	/** A list of comments */
107	protected ArrayList<Comment> comments = new ArrayList<Comment>();
108
109	/** The value for the new comment to add (text that is saved) */
110	protected String newComment = "";
111
112	/** The new value for the new comment to add (text from submit editor) */
113	protected String newNewComment = "";
114
115	/** CC list */
116	protected HashSet<String> cc = new HashSet<String>();
117
118	/** The operation that was selected to do to the bug */
119	protected Operation selectedOperation = null;
120
121	/** Whether or not this bug report is saved offline. */
122	protected boolean savedOffline = false;
123
124	protected boolean hasChanges = false;
125
126	protected String charset = null;
127
128	public BugReport(int id, String server) {
129	this.id = id;
130	this.repositoryUrl = server;
131	}
132
133	/**
134	* Get the bugs id
135	*
136	* @return The bugs id
137	*/
138	public int getId() {
139	return id;
140	}
141
142	public String getRepositoryUrl() {
143	return repositoryUrl;
144	}
145
146	public String getLabel() {
147	return id + ": " + getSummary();
148	}
149
150	/**
151	* Get the bugs description
152	*
153	* @return The description of the bug
154	*/
155	public String getDescription() {
156	return description;
157	}
158
159	/**
160	* Set the description of the bug
161	*
162	* @param description
163	* The description to set the bug to have
164	*/
165	public void setDescription(String description) {
166	this.description = decodeStringFromCharset(description);
167	}
168
169	/**
170	* Get the summary for the bug
171	*
172	* @return The bugs summary
173	*/
174	public String getSummary() {
175	if (getAttribute(ATTR_SUMMARY) == null) {
176	BugzillaPlugin.log(new Status(IStatus.ERROR, IBugzillaConstants.PLUGIN_ID, IStatus.ERROR,
177	"null summary for: " + id, null));
178	return "";
179	}
180	return getAttribute(ATTR_SUMMARY).getValue();
181	}
182
183	/**
184	* Set the summary of the bug
185	*
186	* @param summary
187	* The summary to set the bug to have
188	*/
189	public void setSummary(String summary) {
190	Attribute attribute = new Attribute(ATTR_SUMMARY);
191	attribute.setValue(summary);
192	addAttribute(attribute);
193	}
194
195	private String decodeStringFromCharset(String string) {
196	String decoded = string;
197	if (charset != null && string != null && Charset.availableCharsets().containsKey(charset)) {
198	try {
199	decoded = new String(string.getBytes(), charset);
200	} catch (UnsupportedEncodingException e) {
201	// ignore
202	}
203	}
204	return decoded;
205	}
206
207	/**
208	* Get the date that the bug was created
209	*
210	* @return The bugs creation date
211	*/
212	public Date getCreated() {
213	return created;
214	}
215
216	/**
217	* Set the bugs creation date
218	*
219	* @param created
220	* The date the the bug was created
221	*/
222	public void setCreated(Date created) {
223	this.created = created;
224	}
225
226	public Attribute getAttribute(String key) {
227	return attributes.get(key);
228	}
229
230	/**
231	* Get the list of attributes for this bug
232	*
233	* @return An <code>ArrayList</code> of the bugs attributes
234	*/
235	public List<Attribute> getAttributes() {
236	// create an array list to store the attributes in
237	ArrayList<Attribute> attributeEntries = new ArrayList<Attribute>(attributeKeys.size());
238
239	// go through each of the attribute keys
240	for (Iterator<String> it = attributeKeys.iterator(); it.hasNext();) {
241	// get the key for the attribute
242	String key = it.next();
243
244	// get the attribute and add it to the list
245	Attribute attribute = attributes.get(key);
246	attributeEntries.add(attribute);
247	}
248
249	// return the list of attributes for the bug
250	return attributeEntries;
251	}
252
253	public Attribute getAttributeForKnobName(String knobName) {
254	for (Iterator<String> it = attributeKeys.iterator(); it.hasNext();) {
255	String key = it.next();
256
257	Attribute attribute = attributes.get(key);
258	if (attribute != null && attribute.getParameterName() != null
259	&& attribute.getParameterName().compareTo(knobName) == 0) {
260	return attribute;
261	}
262	}
263
264	return null;
265	}
266
267	/**
268	* @param attribute
269	* The attribute to add to the bug
270	*/
271	public void addAttribute(Attribute attribute) {
272	if (!attributes.containsKey(attribute.getName())) {
273	attributeKeys.add(attribute.getName());
274	}
275
276	attribute.setValue(decodeStringFromCharset(attribute.getValue()));
277
278	// put the value of the attribute into the map, using its name as the
279	// key
280	attributes.put(attribute.getName(), attribute);
281	}
282
283	/**
284	* Get the comments posted on the bug
285	*
286	* @return A list of comments for the bug
287	*/
288	public ArrayList<Comment> getComments() {
289	return comments;
290	}
291
292	/**
293	* Add a comment to the bug
294	*
295	* @param comment
296	* The comment to add to the bug
297	*/
298	public void addComment(Comment comment) {
299	Comment preceding = null;
300	if (comments.size() > 0) {
301	// if there are some comments, get the last comment and set the next
302	// value to be the new comment
303	preceding = comments.get(comments.size() - 1);
304	preceding.setNext(comment);
305	}
306	// set the comments previous value to the preceeding one
307	comment.setPrevious(preceding);
308
309	comment.setText(decodeStringFromCharset(comment.getText()));
310	// add the comment to the comment list
311	comments.add(comment);
312	}
313
314	/**
315	* Get the person who reported the bug
316	*
317	* @return The person who reported the bug
318	*/
319	public String getReporter() {
320	return getAttribute(ATTR_REPORTER).getValue();
321	}
322
323	/**
324	* Get the person to whom this bug is assigned
325	*
326	* @return The person who is assigned to this bug
327	*/
328	public String getAssignedTo() {
329	return getAttribute(ATTR_ASSIGNED_TO).getValue();
330	}
331
332	/**
333	* Get the resolution of the bug
334	*
335	* @return The resolution of the bug
336	*/
337	public String getResolution() {
338	return getAttribute(ATTR_RESOLUTION).getValue();
339	}
340
341	/**
342	* Get the status of the bug
343	*
344	* @return The bugs status
345	*/
346	public String getStatus() {
347	return getAttribute(ATTR_STATUS).getValue();
348	}
349
350	/**
351	* Get the keywords for the bug
352	*
353	* @return The keywords for the bug
354	*/
355	public List<String> getKeywords() {
356	return validKeywords;
357	}
358
359	/**
360	* Set the keywords for the bug
361	*
362	* @param keywords
363	* The keywords to set the bug to have
364	*/
365	public void setKeywords(List<String> keywords) {
366	this.validKeywords = keywords;
367	}
368
369	/**
370	* Get the set of addresses in the CC list
371	*
372	* @return A <code>Set</code> of addresses in the CC list
373	*/
374	public Set<String> getCC() {
375	return cc;
376	}
377
378	/**
379	* Add an email to the bugs CC list
380	*
381	* @param email
382	* The email address to add to the CC list
383	*/
384	public void addCC(String email) {
385	cc.add(email);
386	}
387
388	/**
389	* Remove an address from the bugs CC list
390	*
391	* @param email
392	* the address to be removed from the CC list
393	* @return <code>true</code> if the email is in the set and it was removed
394	*/
395	public boolean removeCC(String email) {
396	return cc.remove(email);
397	}
398
399	/**
400	* Get the new comment that is to be added to the bug
401	*
402	* @return The new comment
403	*/
404	public String getNewComment() {
405	return newComment;
406	}
407
408	/**
409	* Set the new comment that will be added to the bug
410	*
411	* @param newComment
412	* The new comment to add to the bug
413	*/
414	public void setNewComment(String newComment) {
415	this.newComment = newComment;
416	newNewComment = newComment;
417	}
418
419	/**
420	* @return the new value of the new NewComment.
421	*/
422	public String getNewNewComment() {
423	return newNewComment;
424	}
425
426	/**
427	* Set the new value of the new NewComment
428	*
429	* @param newNewComment
430	* The new value of the new NewComment.
431	*/
432	public void setNewNewComment(String newNewComment) {
433	this.newNewComment = newNewComment;
434	}
435
436	/**
437	* Get all of the operations that can be done to the bug
438	*
439	* @return The operations that can be done to the bug
440	*/
441	public List<Operation> getOperations() {
442	return operations;
443	}
444
445	/**
446	* Add an operation to the bug
447	*
448	* @param o
449	* The operation to add
450	*/
451	public void addOperation(Operation o) {
452	operations.add(o);
453	}
454
455	/**
456	* Get an operation from the bug based on its display name
457	*
458	* @param displayText
459	* The display text for the operation
460	* @return The operation that has the display text
461	*/
462	public Operation getOperation(String displayText) {
463	Iterator<Operation> itr = operations.iterator();
464	while (itr.hasNext()) {
465	Operation o = itr.next();
466	String opName = o.getOperationName();
467	opName = opName.replaceAll("</.*>", "");
468	opName = opName.replaceAll("<.*>", "");
469	if (opName.equals(displayText))
470	return o;
471	}
472	return null;
473	}
474
475	/**
476	* Set the selected operation
477	*
478	* @param o
479	* The selected operation
480	*/
481	public void setSelectedOperation(Operation o) {
482	selectedOperation = o;
483	}
484
485	/**
486	* Get the selected operation
487	*
488	* @return The selected operation
489	*/
490	public Operation getSelectedOperation() {
491	return selectedOperation;
492	}
493
494	public boolean isSavedOffline() {
495	return savedOffline;
496	}
497
498	public boolean isLocallyCreated() {
499	return false;
500	}
501
502	public void setOfflineState(boolean newOfflineState) {
503	savedOffline = newOfflineState;
504	}
505
506	public boolean hasChanges() {
507	return hasChanges;
508	}
509
510	public void setHasChanged(boolean b) {
511	hasChanges = b;
512	}
513
514	public boolean isResolved() {
515	Attribute status = getAttribute(ATTR_STATUS);
516	return status != null && isResolvedStatus(getAttribute(ATTR_STATUS).getValue());
517	}
518
519	/**
520	* TODO: move?
521	*/
522	public static boolean isResolvedStatus(String status) {
523	if (status != null) {
524	return status.equals(VAL_STATUS_RESOLVED) \|\| status.equals(VAL_STATUS_CLOSED)
525	\|\| status.equals(VAL_STATUS_VERIFIED);
526	} else {
527	return false;
528	}
529	}
530
531	public String getCharset() {
532	return charset;
533	}
534
535	public void setCharset(String charset) {
536	this.charset = charset;
537	}
538
539	public Date getLastModified() {
540	return lastModified;
541	}
542
543	public void setLastModified(Date date) {
544	this.lastModified = date;
545	}
546
547
548	// public void addAttachment(int id, String description) {
549	// attachements.put(id, description);
550	// }
551	//
552	// public HashMap<Integer, String> getAttachements() {
553	// return attachements;
554	// }
555	}

Removed Link Here

(-)src/org/eclipse/mylar/bugzilla/core/Attribute.java (-178 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.bugzilla.core;
13
14	import java.io.Serializable;
15	import java.util.LinkedHashMap;
16	import java.util.Map;
17
18	/**
19	* Class representing a Bugzilla report attribute that can be changed on the
20	* server.
21	*/
22	public class Attribute implements Serializable {
23	/** Automatically generated serialVersionUID */
24	private static final long serialVersionUID = 3257009873370757424L;
25
26	private boolean hidden = false;
27
28	/** Attribute name */
29	private String name;
30
31	/** Name of the option used when updating the attribute on the server */
32	private String parameterName;
33
34	/** Legal values of the attribute */
35	private LinkedHashMap<String, String> optionValues;
36
37	/**
38	* Attribute's value (input field or selected option; value that is saved or
39	* from the server)
40	*/
41	private String value;
42
43	/** Attributes new Value (value chosen in submit editor) */
44	private String newValue;
45
46	/**
47	* Constructor
48	*
49	* @param name
50	* The name of the attribute
51	*/
52	public Attribute(String name) {
53	// initialize the name and its legal values
54	this.name = name;
55	optionValues = new LinkedHashMap<String, String>();
56	}
57
58	/**
59	* Get the attribute's name
60	*
61	* @return The name of the attribute
62	*/
63	public String getName() {
64	return name;
65	}
66
67	/**
68	* Get name of the option used when updating the attribute on the server
69	*
70	* @return The name of the option for server updates
71	*/
72	public String getParameterName() {
73	return parameterName;
74	}
75
76	/**
77	* Get whether the attribute can be edited by the used
78	*
79	* @return <code>true</code> if the attribute can be edited by the user
80	*/
81	public boolean isEditable() {
82	return optionValues.size() > 0;
83	}
84
85	/**
86	* Get the legal values for the option
87	*
88	* @return The <code>Map</code> of legal values for the option.
89	*/
90	public Map<String, String> getOptionValues() {
91	return optionValues;
92	}
93
94	/**
95	* Get the value of the attribute
96	*
97	* @return A <code>String</code> of the attributes value
98	*/
99	public String getValue() {
100	return value;
101	}
102
103	/**
104	* Set the value of the attribute
105	*
106	* @param value
107	* The new value of the attribute
108	*/
109	public void setValue(String value) {
110	this.value = value;
111	newValue = value;
112	}
113
114	/**
115	* Set the new value of the attribute
116	*
117	* @param newVal
118	* The new value of the attribute
119	*/
120	public void setNewValue(String newVal) {
121	newValue = newVal;
122	}
123
124	/**
125	* Get the new value for the attribute
126	*
127	* @return The new value
128	*/
129	public String getNewValue() {
130	return newValue;
131	}
132
133	/**
134	* Sets the name of the option used when updating the attribute on the
135	* server
136	*
137	* @param parameterName
138	* The name of the option when updating from the server
139	*/
140	public void setParameterName(String parameterName) {
141	this.parameterName = parameterName;
142	}
143
144	/**
145	* Adds an attribute option value
146	*
147	* @param readableValue
148	* The value displayed on the screen
149	* @param parameterValue
150	* The option value used when sending the form to the server
151	*/
152	public void addOptionValue(String readableValue, String parameterValue) {
153	optionValues.put(readableValue, parameterValue);
154	}
155
156	/**
157	* Determine if the field was hidden or not
158	*
159	* @return True if the field was hidden
160	*/
161	public boolean isHidden() {
162	return hidden;
163	}
164
165	/**
166	* Set whether the field was hidden in the bug
167	*
168	* @param b
169	* Whether the field was hidden or not
170	*/
171	public void setHidden(boolean b) {
172	hidden = b;
173	}
174
175	public String toString() {
176	return "(" + getName() + " : " + getValue() + ")";
177	}
178	}

Lines 10-34 Link Here

(-)src/org/eclipse/mylar/bugzilla/core/IBugzillaBug.java (-38 / +78 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.mylar.bugzilla.core;	11	package org.eclipse.mylar.bugzilla.core;
12		12
13	import java.io.Serializable;
14	import java.util.Date;	13	import java.util.Date;
15	import java.util.List;	14	import java.util.List;
16		15
17
18	/**	16	/**
19	* Interface representing a Bugzilla bug report.	17	* Interface representing a Bugzilla bug report.
20	*/	18	*/
21	public interface IBugzillaBug extends Serializable {	19	public interface IBugzillaBug { // extends Serializable
22		20
23	/**	21	// /**
24	* @return bug's id.	22	// * @return bug's id.
25	*/	23	// */
26	public int getId();	24	// public int getId();
27		25	//
28	/**	26	// /**
29	* @return the server for this bug.	27	// * @return the server for this bug.
30	*/	28	// */
31	public String getRepositoryUrl();	29	// public String getRepositoryUrl();
32		30
33	/**	31	/**
34	* @return the title label for this bug.	32	* @return the title label for this bug.
Lines 59-96 Link Here
59	*/	57	*/
60	public void setSummary(String newSummary);	58	public void setSummary(String newSummary);
61		59
62	/**	60	// /**
63	* Get an attribute given its key	61	// * Get an attribute given its key
64	*	62	// *
65	* @return The value of the attribute or <code>null</code> if not present	63	// * @return The value of the attribute or <code>null</code> if not present
66	*/	64	// */
67	public Attribute getAttribute(String key);	65	// public AbstractRepositoryReportAttribute getAttribute(String key);
		66	//
		67	// /**
		68	// * @return the attributes for this bug.
		69	// */
		70	// public List<AbstractRepositoryReportAttribute> getAttributes();
		71
		72	// /**
		73	// * @return <code>true</code> if this bug report is saved offline.
		74	// */
		75	// public boolean isSavedOffline();
		76
		77	// /**
		78	// * @return <code>true</code> if this bug was created locally, and does not
		79	// * yet exist on a bugzilla server.
		80	// */
		81	// public boolean isLocallyCreated();
		82
		83	// /**
		84	// * Sets whether or not this bug is saved offline.
		85	// *
		86	// * @param newOfflineState
		87	// * <code>true</code> if this bug is saved offline
		88	// */
		89	// public void setOfflineState(boolean newOfflineState);
		90
		91	// public boolean hasChanges();
		92
		93	public void addCC(String email);
		94
		95	public void addOperation(Operation o);
		96
		97	public String getAssignedTo();
		98
		99	public List<String> getCC();
68		100
69	/**	101	public List<String> getKeywords();
70	* @return the attributes for this bug.
71	*/
72	public List<Attribute> getAttributes();
73		102
74	/**	103	public String getNewComment();
75	* @return <code>true</code> if this bug report is saved offline.
76	*/
77	public boolean isSavedOffline();
78		104
79	/**	105	// public String getNewNewComment();
80	* @return <code>true</code> if this bug was created locally, and does not	106	public void setNewComment(String newComment);
81	* yet exist on a bugzilla server.
82	*/
83	public boolean isLocallyCreated();
84		107
85	/**	108	// public void setNewNewComment(String newNewComment);
86	* Sets whether or not this bug is saved offline.
87	*
88	* @param newOfflineState
89	* <code>true</code> if this bug is saved offline
90	*/
91	public void setOfflineState(boolean newOfflineState);	109	public void setOfflineState(boolean newOfflineState);
92		110
93	public boolean hasChanges();	111	//public Operation getOperation(String displayText);
		112
		113	public List<Operation> getOperations();
		114
		115	public String getReporter();
		116
		117	public String getResolution();
		118
		119	public void setSelectedOperation(Operation o);
		120
		121	public Operation getSelectedOperation();
		122
		123	public String getStatus();
		124
		125	public boolean isResolved();
		126
		127	public void removeCC(String email);
		128
		129	// public void setCreated(Date created);
		130	public void setKeywords(List<String> keywords);
		131
		132	// public void setLastModified(Date date);
		133	public String getProduct();
94		134
95	/**	135	/**
96	* Get the date that the bug was created	136	* Get the date that the bug was created

Lines 22-29 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/core/compare/BugzillaCompareNode.java (-8 / +8 lines)
22	import org.eclipse.compare.ITypedElement;	22	import org.eclipse.compare.ITypedElement;
23	import org.eclipse.compare.structuremergeviewer.IStructureComparator;	23	import org.eclipse.compare.structuremergeviewer.IStructureComparator;
24	import org.eclipse.core.runtime.CoreException;	24	import org.eclipse.core.runtime.CoreException;
25	import org.eclipse.mylar.bugzilla.core.Attribute;	25	import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
26	import org.eclipse.mylar.bugzilla.core.BugReport;	26	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
27	import org.eclipse.mylar.bugzilla.core.Comment;	27	import org.eclipse.mylar.bugzilla.core.Comment;
28	import org.eclipse.swt.graphics.Image;	28	import org.eclipse.swt.graphics.Image;
29	import org.eclipse.ui.ISharedImages;	29	import org.eclipse.ui.ISharedImages;
Lines 190-196 Link Here
190	* The <code>BugReport</code> that needs parsing.	190	* The <code>BugReport</code> that needs parsing.
191	* @return The tree of <code>BugzillaCompareNode</code>'s.	191	* @return The tree of <code>BugzillaCompareNode</code>'s.
192	*/	192	*/
193	public static BugzillaCompareNode parseBugReport(BugReport bug) {	193	public static BugzillaCompareNode parseBugReport(BugzillaReport bug) {
194	Image defaultImage = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_DEF_VIEW);	194	Image defaultImage = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_DEF_VIEW);
195	BugzillaCompareNode topNode = new BugzillaCompareNode("Bug #" + bug.getId(), null, defaultImage);	195	BugzillaCompareNode topNode = new BugzillaCompareNode("Bug #" + bug.getId(), null, defaultImage);
196	Date creationDate = bug.getCreated();	196	Date creationDate = bug.getCreated();
Lines 211-218 Link Here
211		211
212	Image attributeImage = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT);	212	Image attributeImage = PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_ELEMENT);
213	BugzillaCompareNode attributes = new BugzillaCompareNode("Attributes", null, attributeImage);	213	BugzillaCompareNode attributes = new BugzillaCompareNode("Attributes", null, attributeImage);
214	for (Iterator<Attribute> iter = bug.getAttributes().iterator(); iter.hasNext();) {	214	for (Iterator<AbstractRepositoryReportAttribute> iter = bug.getAttributes().iterator(); iter.hasNext();) {
215	Attribute attribute = iter.next();	215	AbstractRepositoryReportAttribute attribute = iter.next();
216	if (attribute.getName().compareTo("delta_ts") == 0 \|\| attribute.getName().compareTo("Last Modified") == 0	216	if (attribute.getName().compareTo("delta_ts") == 0 \|\| attribute.getName().compareTo("Last Modified") == 0
217	\|\| attribute.getName().compareTo("longdesclength") == 0)	217	\|\| attribute.getName().compareTo("longdesclength") == 0)
218	continue;	218	continue;
Lines 220-226 Link Here
220	// attribute's new	220	// attribute's new
221	// value, which is what is in the submit viewer.	221	// value, which is what is in the submit viewer.
222		222
223	attributes.addChild(new BugzillaCompareNode(attribute.getName(), attribute.getNewValue(), attributeImage));	223	attributes.addChild(new BugzillaCompareNode(attribute.getName(), attribute.getValue(), attributeImage));
224	}	224	}
225	topNode.addChild(attributes);	225	topNode.addChild(attributes);
226		226
Lines 229-240 Link Here
229	BugzillaCompareNode comments = new BugzillaCompareNode("Comments", null, defaultImage);	229	BugzillaCompareNode comments = new BugzillaCompareNode("Comments", null, defaultImage);
230	for (Iterator<Comment> iter = bug.getComments().iterator(); iter.hasNext();) {	230	for (Iterator<Comment> iter = bug.getComments().iterator(); iter.hasNext();) {
231	Comment comment = iter.next();	231	Comment comment = iter.next();
232	String bodyString = "Comment from " + comment.getAuthorName() + ":\n\n" + comment.getText();	232	String bodyString = "Comment from " + comment.getAuthorName() + ":\n\n" + comment.getText();
233	comments.addChild(new BugzillaCompareNode(comment.getCreated().toString(), bodyString, defaultImage));	233	comments.addChild(new BugzillaCompareNode(comment.getCreated().toString(), bodyString, defaultImage));
234	}	234	}
235	topNode.addChild(comments);	235	topNode.addChild(comments);
236		236
237	topNode.addChild(new BugzillaCompareNode("New Comment", bug.getNewNewComment(), defaultImage));	237	topNode.addChild(new BugzillaCompareNode("New Comment", bug.getNewComment(), defaultImage));
238		238
239	BugzillaCompareNode ccList = new BugzillaCompareNode("CC List", null, defaultImage);	239	BugzillaCompareNode ccList = new BugzillaCompareNode("CC List", null, defaultImage);
240	for (Iterator<String> iter = bug.getCC().iterator(); iter.hasNext();) {	240	for (Iterator<String> iter = bug.getCC().iterator(); iter.hasNext();) {

Lines 35-45 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/core/BugzillaPlugin.java (-125 / +158 lines)
35	import org.eclipse.jface.dialogs.ErrorDialog;	35	import org.eclipse.jface.dialogs.ErrorDialog;
36	import org.eclipse.jface.dialogs.MessageDialog;	36	import org.eclipse.jface.dialogs.MessageDialog;
37	import org.eclipse.jface.preference.IPreferenceStore;	37	import org.eclipse.jface.preference.IPreferenceStore;
38	import org.eclipse.mylar.bugzilla.core.IBugzillaBug;	38	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
39	import org.eclipse.mylar.internal.bugzilla.core.internal.FavoritesFile;	39	import org.eclipse.mylar.internal.bugzilla.core.internal.FavoritesFile;
40	import org.eclipse.mylar.internal.bugzilla.core.internal.OfflineReportsFile;	40	import org.eclipse.mylar.internal.bugzilla.core.internal.OfflineReportsFile;
41	import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryConfiguration;	41	import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryConfiguration;
42	import org.eclipse.mylar.internal.bugzilla.core.internal.ServerConfigurationFactory;	42	import org.eclipse.mylar.internal.bugzilla.core.internal.RepositoryConfigurationFactory;
43	import org.eclipse.mylar.internal.bugzilla.core.search.IBugzillaResultEditorMatchAdapter;	43	import org.eclipse.mylar.internal.bugzilla.core.search.IBugzillaResultEditorMatchAdapter;
44	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;	44	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
45	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;	45	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
Lines 105-125 Link Here
105	Authenticator.setDefault(authenticator);	105	Authenticator.setDefault(authenticator);
106		106
107	// Removed since not repository specific	107	// Removed since not repository specific
108	//setDefaultQueryOptions();	108	// setDefaultQueryOptions();
109		109
110	readFavoritesFile();	110	readFavoritesFile();
111	readOfflineReportsFile();	111	readOfflineReportsFile();
112		112
113	// final Set<TaskRepository> repositories = MylarTaskListPlugin.getRepositoryManager().getRepositories(	113	// final Set<TaskRepository> repositories =
114	// REPOSITORY_KIND);	114	// MylarTaskListPlugin.getRepositoryManager().getRepositories(
115	// for (TaskRepository repository : repositories) {	115	// REPOSITORY_KIND);
116	// readCachedProductConfiguration(repository.getUrl());	116	// for (TaskRepository repository : repositories) {
117	// }	117	// readCachedProductConfiguration(repository.getUrl());
118		118	// }
		119
119	migrateOldAuthenticationData();	120	migrateOldAuthenticationData();
120	}	121	}
121		122
122
123	@SuppressWarnings("unchecked")	123	@SuppressWarnings("unchecked")
124	private void migrateOldAuthenticationData() {	124	private void migrateOldAuthenticationData() {
125	String OLD_PREF_SERVER = "BUGZILLA_SERVER";	125	String OLD_PREF_SERVER = "BUGZILLA_SERVER";
Lines 141-154 Link Here
141	password = pwd;	141	password = pwd;
142	}	142	}
143	TaskRepository repository;	143	TaskRepository repository;
144	// try {	144	// try {
145	repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, serverUrl);	145	repository = new TaskRepository(BugzillaPlugin.REPOSITORY_KIND, serverUrl);
146	repository.setAuthenticationCredentials(user, password);	146	repository.setAuthenticationCredentials(user, password);
147	MylarTaskListPlugin.getRepositoryManager().addRepository(repository);	147	MylarTaskListPlugin.getRepositoryManager().addRepository(repository);
148	BugzillaPlugin.getDefault().getPreferenceStore().setValue(OLD_PREF_SERVER, "");	148	BugzillaPlugin.getDefault().getPreferenceStore().setValue(OLD_PREF_SERVER, "");
149	// } catch (MalformedURLException e) {	149	// } catch (MalformedURLException e) {
150	// MylarStatusHandler.fail(e, "could not create default repository", true);	150	// MylarStatusHandler.fail(e, "could not create default repository",
151	// }	151	// true);
		152	// }
152	try {	153	try {
153	// reset the authorization	154	// reset the authorization
154	Platform.addAuthorizationInfo(BugzillaPreferencePage.FAKE_URL, "Bugzilla",	155	Platform.addAuthorizationInfo(BugzillaPreferencePage.FAKE_URL, "Bugzilla",
Lines 188-211 Link Here
188	BugzillaPreferencePage.initDefaults(store);	189	BugzillaPreferencePage.initDefaults(store);
189	}	190	}
190		191
191	// /**	192	// /**
192	// * // * Get the name of the bugzilla server // * // *	193	// * // * Get the name of the bugzilla server // * // *
193	// *	194	// *
194	// * @return A string containing the prefered name of the bugzilla server //	195	// * @return A string containing the prefered name of the bugzilla server //
195	// */	196	// */
196	// // public String getServerName() {	197	// // public String getServerName() {
197	// // return	198	// // return
198	// // plugin.getPreferenceStore().getString(IBugzillaConstants.BUGZILLA_SERVER);	199	// //
199	// // }	200	// plugin.getPreferenceStore().getString(IBugzillaConstants.BUGZILLA_SERVER);
200	// public boolean isServerCompatability218() {	201	// // }
201	// return IBugzillaConstants.SERVER_218.equals(getPreferenceStore().getString(IBugzillaConstants.SERVER_VERSION))	202	// public boolean isServerCompatability218() {
202	// \|\| IBugzillaConstants.SERVER_220.equals(getPreferenceStore().getString(	203	// return
203	// IBugzillaConstants.SERVER_VERSION));	204	// IBugzillaConstants.SERVER_218.equals(getPreferenceStore().getString(IBugzillaConstants.SERVER_VERSION))
204	// }	205	// \|\| IBugzillaConstants.SERVER_220.equals(getPreferenceStore().getString(
205	//	206	// IBugzillaConstants.SERVER_VERSION));
206	// public boolean isServerCompatability220() {	207	// }
207	// return IBugzillaConstants.SERVER_220.equals(getPreferenceStore().getString(IBugzillaConstants.SERVER_VERSION));	208	//
208	// }	209	// public boolean isServerCompatability220() {
		210	// return
		211	// IBugzillaConstants.SERVER_220.equals(getPreferenceStore().getString(IBugzillaConstants.SERVER_VERSION));
		212	// }
209		213
210	/**	214	/**
211	* Get the most recent query key for the preferences	215	* Get the most recent query key for the preferences
Lines 216-237 Link Here
216	return plugin.getPreferenceStore().getString(IBugzillaConstants.MOST_RECENT_QUERY);	220	return plugin.getPreferenceStore().getString(IBugzillaConstants.MOST_RECENT_QUERY);
217	}	221	}
218		222
219	public RepositoryConfiguration getProductConfiguration(String serverUrl) {	223	public RepositoryConfiguration getProductConfiguration(TaskRepository repository) {
220	if(! repositoryConfigurations.containsKey(serverUrl)) {	224	if (!repositoryConfigurations.containsKey(repository.getUrl())) {
221	try {	225	try {
222	repositoryConfigurations.put(serverUrl, ServerConfigurationFactory.getInstance().getConfiguration(	226	repositoryConfigurations.put(repository.getUrl(), RepositoryConfigurationFactory.getInstance().getConfiguration(
223	serverUrl));	227	repository));
224	} catch (IOException e) {	228	} catch (IOException e) {
225	MessageDialog	229	MessageDialog.openInformation(null, "Retrieval of Bugzilla Configuration",
226	.openInformation(	230	"Bugzilla configuration retrieval failed.");
227	null,
228	"Retrieval of Bugzilla Configuration", "Bugzilla configuration retrieval failed.");
229	}	231	}
230	}	232	}
231		233
232	return repositoryConfigurations.get(serverUrl);	234	return repositoryConfigurations.get(repository.getUrl());
233	}	235	}
234		236
		237
		238	// public RepositoryConfiguration getProductConfiguration(String serverUrl) {
		239	// if (!repositoryConfigurations.containsKey(serverUrl)) {
		240	// try {
		241	// repositoryConfigurations.put(serverUrl, RepositoryConfigurationFactory.getInstance().getConfiguration(
		242	// serverUrl));
		243	// } catch (IOException e) {
		244	// MessageDialog.openInformation(null, "Retrieval of Bugzilla Configuration",
		245	// "Bugzilla configuration retrieval failed.");
		246	// }
		247	// }
		248	//
		249	// return repositoryConfigurations.get(serverUrl);
		250	// }
		251
235	protected void setProductConfiguration(String serverUrl, RepositoryConfiguration repositoryConfiguration) {	252	protected void setProductConfiguration(String serverUrl, RepositoryConfiguration repositoryConfiguration) {
236	repositoryConfigurations.put(serverUrl, repositoryConfiguration);	253	repositoryConfigurations.put(serverUrl, repositoryConfiguration);
237	// this.productConfiguration = productConfiguration;	254	// this.productConfiguration = productConfiguration;
Lines 262-275 Link Here
262	try {	279	try {
263	offlineReportsFile = new OfflineReportsFile(offlineReportsPath.toFile());	280	offlineReportsFile = new OfflineReportsFile(offlineReportsPath.toFile());
264	} catch (Exception e) {	281	} catch (Exception e) {
265	MylarStatusHandler.fail(e, "could not restore offline Bugzilla reports file", true);	282	MylarStatusHandler.fail(e, "could not restore offline Bugzilla reports file, creating new one", false);
266	// logAndShowExceptionDetailsDialog(e, "occurred while restoring saved offline Bugzilla reports.",	283	// logAndShowExceptionDetailsDialog(e, "occurred while restoring
267	// "Bugzilla Offline Reports Error");	284	// saved offline Bugzilla reports.",
268	offlineReportsPath.toFile().delete();	285	// "Bugzilla Offline Reports Error");
269	try {	286	if (offlineReportsPath.toFile().delete()) {
270	offlineReportsFile = new OfflineReportsFile(offlineReportsPath.toFile());	287	try {
271	} catch (IOException e1) {	288	offlineReportsFile = new OfflineReportsFile(offlineReportsPath.toFile());
272	MylarStatusHandler.fail(e, "could not reset offline Bugzilla reports file", true);	289	} catch (Exception e1) {
		290	MylarStatusHandler.fail(e, "could not reset offline Bugzilla reports file", true);
		291	}
		292	} else {
		293	MylarStatusHandler.fail(null, "reset of Bugzilla offline reports file failed", true);
273	}	294	}
274	}	295	}
275	}	296	}
Lines 292-329 Link Here
292	return configFile;	313	return configFile;
293	}	314	}
294		315
295	// /**	316	// /**
296	// * Reads cached product configuration and stores it in the	317	// * Reads cached product configuration and stores it in the
297	// * <code>productConfiguration</code> field.	318	// * <code>productConfiguration</code> field.
298	// *	319	// *
299	// * TODO remove this?	320	// * TODO remove this?
300	// */	321	// */
301	// private void readCachedProductConfiguration(String serverUrl) {	322	// private void readCachedProductConfiguration(String serverUrl) {
302	// IPath configFile = getProductConfigurationCachePath(serverUrl);	323	// IPath configFile = getProductConfigurationCachePath(serverUrl);
303	//	324	//
304	// try {	325	// try {
305	// productConfigurations.put(serverUrl, ServerConfigurationFactory.getInstance().readConfiguration(	326	// productConfigurations.put(serverUrl,
306	// configFile.toFile()));	327	// ServerConfigurationFactory.getInstance().readConfiguration(
307	// } catch (IOException ex) {	328	// configFile.toFile()));
308	// try {	329	// } catch (IOException ex) {
309	// log(ex);	330	// try {
310	// productConfigurations.put(serverUrl, ServerConfigurationFactory.getInstance().getConfiguration(	331	// log(ex);
311	// serverUrl));	332	// productConfigurations.put(serverUrl,
312	// } catch (IOException e) {	333	// ServerConfigurationFactory.getInstance().getConfiguration(
313	// log(e);	334	// serverUrl));
314	// MessageDialog	335	// } catch (IOException e) {
315	// .openInformation(	336	// log(e);
316	// null,	337	// MessageDialog
317	// "Bugzilla product attributes check",	338	// .openInformation(
318	// "An error occurred while restoring saved Bugzilla product attributes: \n\n"	339	// null,
319	// + ex.getMessage()	340	// "Bugzilla product attributes check",
320	// + "\n\nUpdating them from the server also caused an error:\n\n"	341	// "An error occurred while restoring saved Bugzilla product attributes:
321	// + e.getMessage()	342	// \n\n"
322	// + "\n\nCheck the server URL in Bugzila preferences.\n"	343	// + ex.getMessage()
323	// + "Offline submission of new bugs will be disabled until valid product attributes have been loaded.");	344	// + "\n\nUpdating them from the server also caused an error:\n\n"
324	// }	345	// + e.getMessage()
325	// }	346	// + "\n\nCheck the server URL in Bugzila preferences.\n"
326	// }	347	// + "Offline submission of new bugs will be disabled until valid product
		348	// attributes have been loaded.");
		349	// }
		350	// }
		351	// }
327		352
328	/**	353	/**
329	* Returns the path to the file cacheing the product configuration.	354	* Returns the path to the file cacheing the product configuration.
Lines 391-397 Link Here
391	/**	416	/**
392	* @return a list of the BugReports saved offline.	417	* @return a list of the BugReports saved offline.
393	*/	418	*/
394	public List<IBugzillaBug> getSavedBugReports() {	419	public List<BugzillaReport> getSavedBugReports() {
395	return offlineReportsFile.elements();	420	return offlineReportsFile.elements();
396	}	421	}
397		422
Lines 432-473 Link Here
432	return getPreferenceStore().getInt(IBugzillaConstants.MAX_RESULTS);	457	return getPreferenceStore().getInt(IBugzillaConstants.MAX_RESULTS);
433	}	458	}
434		459
435	// private void setDefaultQueryOptions() {	460	// private void setDefaultQueryOptions() {
436	// // get the preferences store for the bugzilla preferences	461	// // get the preferences store for the bugzilla preferences
437	// IPreferenceStore prefs = getPreferenceStore();	462	// IPreferenceStore prefs = getPreferenceStore();
438	//	463	//
439	// prefs.setDefault(IBugzillaConstants.VALUES_STATUS, BugzillaRepositoryUtil	464	// prefs.setDefault(IBugzillaConstants.VALUES_STATUS, BugzillaRepositoryUtil
440	// .queryOptionsToString(IBugzillaConstants.DEFAULT_STATUS_VALUES));	465	// .queryOptionsToString(IBugzillaConstants.DEFAULT_STATUS_VALUES));
441	//	466	//
442	// prefs.setDefault(IBugzillaConstants.VALUSE_STATUS_PRESELECTED, BugzillaRepositoryUtil	467	// prefs.setDefault(IBugzillaConstants.VALUSE_STATUS_PRESELECTED,
443	// .queryOptionsToString(IBugzillaConstants.DEFAULT_PRESELECTED_STATUS_VALUES));	468	// BugzillaRepositoryUtil
444	//	469	// .queryOptionsToString(IBugzillaConstants.DEFAULT_PRESELECTED_STATUS_VALUES));
445	// prefs.setDefault(IBugzillaConstants.VALUES_RESOLUTION, BugzillaRepositoryUtil	470	//
446	// .queryOptionsToString(IBugzillaConstants.DEFAULT_RESOLUTION_VALUES));	471	// prefs.setDefault(IBugzillaConstants.VALUES_RESOLUTION,
447	//	472	// BugzillaRepositoryUtil
448	// prefs.setDefault(IBugzillaConstants.VALUES_SEVERITY, BugzillaRepositoryUtil	473	// .queryOptionsToString(IBugzillaConstants.DEFAULT_RESOLUTION_VALUES));
449	// .queryOptionsToString(IBugzillaConstants.DEFAULT_SEVERITY_VALUES));	474	//
450	//	475	// prefs.setDefault(IBugzillaConstants.VALUES_SEVERITY,
451	// prefs.setDefault(IBugzillaConstants.VALUES_PRIORITY, BugzillaRepositoryUtil	476	// BugzillaRepositoryUtil
452	// .queryOptionsToString(IBugzillaConstants.DEFAULT_PRIORITY_VALUES));	477	// .queryOptionsToString(IBugzillaConstants.DEFAULT_SEVERITY_VALUES));
453	//	478	//
454	// prefs.setDefault(IBugzillaConstants.VALUES_HARDWARE, BugzillaRepositoryUtil	479	// prefs.setDefault(IBugzillaConstants.VALUES_PRIORITY,
455	// .queryOptionsToString(IBugzillaConstants.DEFAULT_HARDWARE_VALUES));	480	// BugzillaRepositoryUtil
456	//	481	// .queryOptionsToString(IBugzillaConstants.DEFAULT_PRIORITY_VALUES));
457	// prefs.setDefault(IBugzillaConstants.VALUES_OS, BugzillaRepositoryUtil	482	//
458	// .queryOptionsToString(IBugzillaConstants.DEFAULT_OS_VALUES));	483	// prefs.setDefault(IBugzillaConstants.VALUES_HARDWARE,
459	//	484	// BugzillaRepositoryUtil
460	// prefs.setDefault(IBugzillaConstants.VALUES_PRODUCT, BugzillaRepositoryUtil	485	// .queryOptionsToString(IBugzillaConstants.DEFAULT_HARDWARE_VALUES));
461	// .queryOptionsToString(IBugzillaConstants.DEFAULT_PRODUCT_VALUES));	486	//
462	//	487	// prefs.setDefault(IBugzillaConstants.VALUES_OS, BugzillaRepositoryUtil
463	// prefs.setDefault(IBugzillaConstants.VALUES_COMPONENT, BugzillaRepositoryUtil	488	// .queryOptionsToString(IBugzillaConstants.DEFAULT_OS_VALUES));
464	// .queryOptionsToString(IBugzillaConstants.DEFAULT_COMPONENT_VALUES));	489	//
465	//	490	// prefs.setDefault(IBugzillaConstants.VALUES_PRODUCT,
466	// prefs.setDefault(IBugzillaConstants.VALUES_VERSION, BugzillaRepositoryUtil	491	// BugzillaRepositoryUtil
467	// .queryOptionsToString(IBugzillaConstants.DEFAULT_VERSION_VALUES));	492	// .queryOptionsToString(IBugzillaConstants.DEFAULT_PRODUCT_VALUES));
468	//	493	//
469	// prefs.setDefault(IBugzillaConstants.VALUES_TARGET, BugzillaRepositoryUtil	494	// prefs.setDefault(IBugzillaConstants.VALUES_COMPONENT,
470	// .queryOptionsToString(IBugzillaConstants.DEFAULT_TARGET_VALUES));	495	// BugzillaRepositoryUtil
471	// }	496	// .queryOptionsToString(IBugzillaConstants.DEFAULT_COMPONENT_VALUES));
472		497	//
		498	// prefs.setDefault(IBugzillaConstants.VALUES_VERSION,
		499	// BugzillaRepositoryUtil
		500	// .queryOptionsToString(IBugzillaConstants.DEFAULT_VERSION_VALUES));
		501	//
		502	// prefs.setDefault(IBugzillaConstants.VALUES_TARGET, BugzillaRepositoryUtil
		503	// .queryOptionsToString(IBugzillaConstants.DEFAULT_TARGET_VALUES));
		504	// }
		505
473	}	506	}

Lines 19-26 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/core/search/BugzillaSearchResultCollector.java (-4 / +5 lines)
19	import org.eclipse.core.resources.ResourcesPlugin;	19	import org.eclipse.core.resources.ResourcesPlugin;
20	import org.eclipse.core.runtime.CoreException;	20	import org.eclipse.core.runtime.CoreException;
21	import org.eclipse.core.runtime.IProgressMonitor;	21	import org.eclipse.core.runtime.IProgressMonitor;
22	import org.eclipse.mylar.bugzilla.core.BugReport;	22	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
23	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;	23	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
		24	import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
24	import org.eclipse.search.ui.NewSearchUI;	25	import org.eclipse.search.ui.NewSearchUI;
25	import org.eclipse.search.ui.text.Match;	26	import org.eclipse.search.ui.text.Match;
26		27
Lines 120-134 Link Here
120	* Returns a map where BugReport's attributes are entered into a Map using	121	* Returns a map where BugReport's attributes are entered into a Map using
121	* the same key/value pairs as those created on a search hit marker.	122	* the same key/value pairs as those created on a search hit marker.
122	*/	123	*/
123	public static Map<String, Object> getAttributeMap(BugReport bug) {	124	public static Map<String, Object> getAttributeMap(BugzillaReport bug) {
124	HashMap<String, Object> map = new HashMap<String, Object>();	125	HashMap<String, Object> map = new HashMap<String, Object>();
125	map.put(IBugzillaConstants.HIT_MARKER_ATTR_ID, new Integer(bug.getId()));	126	map.put(IBugzillaConstants.HIT_MARKER_ATTR_ID, new Integer(bug.getId()));
126	map.put(IBugzillaConstants.HIT_MARKER_ATTR_REPOSITORY, bug.getRepositoryUrl());	127	map.put(IBugzillaConstants.HIT_MARKER_ATTR_REPOSITORY, bug.getRepositoryUrl());
127	map.put(IBugzillaConstants.HIT_MARKER_ATTR_DESC, bug.getDescription());	128	map.put(IBugzillaConstants.HIT_MARKER_ATTR_DESC, bug.getDescription());
128	map.put(IBugzillaConstants.HIT_MARKER_ATTR_SEVERITY,	129	map.put(IBugzillaConstants.HIT_MARKER_ATTR_SEVERITY,
129	mapValue(bug.getAttribute("Severity").getValue(), severity));	130	mapValue(bug.getAttribute(BugzillaReportElement.BUG_SEVERITY).getValue(), severity));
130	map.put(IBugzillaConstants.HIT_MARKER_ATTR_PRIORITY,	131	map.put(IBugzillaConstants.HIT_MARKER_ATTR_PRIORITY,
131	mapValue(bug.getAttribute("Priority").getValue(), priority));	132	mapValue(bug.getAttribute(BugzillaReportElement.PRIORITY).getValue(), priority));
132	map.put(IBugzillaConstants.HIT_MARKER_ATTR_PLATFORM, bug.getAttribute("Hardware").getValue());	133	map.put(IBugzillaConstants.HIT_MARKER_ATTR_PLATFORM, bug.getAttribute("Hardware").getValue());
133	map.put(IBugzillaConstants.HIT_MARKER_ATTR_STATE, mapValue(bug.getStatus(), state));	134	map.put(IBugzillaConstants.HIT_MARKER_ATTR_STATE, mapValue(bug.getStatus(), state));
134	map.put(IBugzillaConstants.HIT_MARKER_ATTR_RESULT, mapValue(bug.getResolution(), result));	135	map.put(IBugzillaConstants.HIT_MARKER_ATTR_RESULT, mapValue(bug.getResolution(), result));

Added Link Here

(-)src/org/eclipse/mylar/bugzilla/core/ReportAttachment.java (+85 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.bugzilla.core;
13
14	import java.io.Serializable;
15	import java.text.SimpleDateFormat;
16	import java.util.Date;
17
18	import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
19
20	/**
21	* TODO: Make generic. This currently represents Bugzilla attachments only
22	* @author relves
23	*/
24	public class ReportAttachment extends AttributeContainer implements Serializable {
25
26	private static final long serialVersionUID = -9123545810321250785L;
27
28	/** Parser for dates in the report */
29	private static SimpleDateFormat creation_ts_date_format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
30
31	private boolean isObsolete = false;
32
33	private Date created;
34
35	public boolean isObsolete() {
36	return isObsolete;
37	}
38
39	public void setObsolete(boolean isObsolete) {
40	this.isObsolete = isObsolete;
41	}
42
43
44	/**
45	* may return null if date is unknown/unparseable
46	*/
47	public Date getDateCreated() {
48	if(created == null) {
49	//created = Calendar.getInstance().getTime();
50	try {
51	created = creation_ts_date_format.parse(getAttributeValue(BugzillaReportElement.DATE));
52	} catch (Exception e) {
53	}
54	}
55	return created;
56	}
57
58	/**
59	* Currently returns empty string. XML from bugzilla
60	* doesn't include who attached directly in attachment data
61	* TODO: Retrieve from associated comment
62	* @return
63	*/
64	public String getAuthor() {
65	return "";
66	}
67
68	public String getDescription() {
69	//System.err.println(getAttributeValue(BugzillaReportElement.DESC));
70	return getAttributeValue(BugzillaReportElement.DESC);
71	}
72
73	public int getId() {
74	try {
75	return Integer.parseInt(getAttributeValue(BugzillaReportElement.ATTACHID));
76	} catch (NumberFormatException e) {
77	return -1;
78	}
79	}
80
81	public Object getContentType() {
82	return getAttributeValue(BugzillaReportElement.CTYPE);
83	}
84
85	}

Removed Link Here

(-)src/org/eclipse/mylar/tests/misc/BugzillaStackTraceTest.java (-196 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11	////Created on Oct 12, 2004
12	package org.eclipse.mylar.tests.misc;
13
14	import java.io.File;
15	import java.io.FileReader;
16	import java.io.Reader;
17	import java.util.ArrayList;
18	import java.util.List;
19
20	import junit.framework.TestCase;
21
22	import org.eclipse.core.runtime.Path;
23	import org.eclipse.mylar.bugzilla.tests.BugzillaTestPlugin;
24	import org.eclipse.mylar.core.tests.support.FileTool;
25	import org.eclipse.mylar.internal.bugs.search.BugzillaMylarSearchOperation;
26	import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;
27	import org.eclipse.mylar.internal.bugzilla.core.search.BugzillaSearchHit;
28	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaReportNode;
29	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.StackTrace;
30
31	/**
32	* Class to test the Bridge methods that do not require server queries
33	*
34	* @author Shawn Minto
35	*/
36	public class BugzillaStackTraceTest extends TestCase {
37
38	private static final String TEST_FILE_LOC = "testdata/reports-stacktrace/";
39
40	private static final String BUGZILLA_SERVER_NAME = "https://bugs.eclipse.org/bugs";
41
42	/**
43	* Test that the regular expression escaping mechanism works properly
44	*/
45	public void testREGEX() {
46	String r = ".*+(){}[]^$\|?/\\";
47	String r2 = StackTrace.escapeForRegex(r);
48	String ans = "\\.\\*\\+\\(\\)\\{\\}\\[\\]\\^\\$\\\|\\?\\/\\\\";
49	String msg = "Regular Expression matching wrong:\nwas: " + r2 + "\nshould be:" + ans;
50	assertTrue(msg, r2.equals(ans));
51	}
52
53	// /**
54	// * Test parsing the bug for multiple stacks in in
55	// */
56	// public void testMultipleStacksDiffComments(){
57	// // REPORT_REPOSITORY 4862 - 2 stack traces - 1 in description, 1 in
58	// comment - text
59	// before and after
60	// performParse(4862, "4862.html", 2, false);
61	// }
62
63	// /**
64	// * Test parsing the bug for a single stack in the description with some
65	// * text before it
66	// */
67	// public void testSingleStackCodeBeforeInDescription(){
68	// // REPORT_REPOSITORY 76388 - 1 stack trace - description - text before
69	// and formatted
70	// ugly
71	// performParse(76388, "76388.html", 1, false);
72	// }
73
74	/**
75	* Test parsing the bug for a single stack trace in the description with
76	* text before and after it
77	*/
78	public void testSingleStackCodeBeforeAndAfterInDescription() {
79
80	// REPORT_REPOSITORY 76146 - 1 stack trace - description - text before
81	// and code after
82	performParse(76146, "76146.html", 1, false);
83	}
84
85	/**
86	* Test parsing a bug that has 1 stack trace in the description with no
87	* extra text, but has lines in it that span 3 lines
88	*/
89	public void testSingleStackPoorFormatInDescription() {
90	// REPORT_REPOSITORY 67395 - 1 stack trace - description - no extra
91	// text, 1 at line
92	// spans 3 lines
93	performParse(67395, "67395.html", 1, false);
94	}
95
96	/**
97	* Test parsing a bug with no stack traces and no qualified exception names
98	*/
99	public void testNoStackNoQualified() {
100	// REPORT_REPOSITORY 4548 - no stack traces, no qualified reference to
101	// an exception
102	performParse(4548, "4548.html", 0, false);
103	}
104
105	/**
106	* Test parsing a bug with no stack traces, but a qualified reference to an
107	* exception
108	*/
109	public void testNoStackQual() {
110	// REPORT_REPOSITORY 1 - no stack traces, qualified reference to
111	// exception - made up
112	// bug
113	performParse(1, "1.html", 0, false);
114	}
115
116	/**
117	* Test parsing of a bug with 1 stack trace and multiple qualified
118	* references
119	*/
120	public void testSingleStackQual() {
121	// REPORT_REPOSITORY 2 - 1 stack trace- 2 qual ref, stack trace, 1 qual
122	// ref - made up
123	// bug
124	performParse(2, "2.html", 1, false);
125	}
126
127	/**
128	* Test parsing of a bug with many stacks traces in a single comment
129	*/
130	public void testMultipleStackSingleComment() {
131	// REPORT_REPOSITORY 40152 - 1 stack trace- 2 qual ref, stack trace, 1
132	// qual ref - made
133	// up bug
134	performParse(40152, "40152.html", 33, false);
135	}
136
137	/**
138	* Print out the stack traces
139	*
140	* @param l
141	* List of stack traces
142	*/
143	private void printStackTraces(List<StackTrace> l) {
144	System.out.println("\n\n");
145	for (int i = 0; i < l.size(); i++) {
146	StackTrace trace = l.get(i);
147	System.out.println("***************?????????????????***************\n");
148	System.out.println("OFFSET: " + trace.getOffset() + " LENGTH: " + trace.getLength());
149	System.out.println(trace.getStackTrace());
150	System.out.println("***************?????????????????***************\n\n");
151	}
152	}
153
154	private void performParse(int bugNumber, String bugFileName, int numTracesExpected, boolean printStackTraces) {
155
156	BugzillaSearchHit hit = new BugzillaSearchHit("<TEST-SERVER>", bugNumber, "", "", "", "", "", "", "", ""); // stack
157	// trace
158	// in
159	// desc
160	// and
161	// com
162
163	// create a new doi info
164	BugzillaReportNode doi = new BugzillaReportNode(0, hit, false);
165	try {
166
167	// read the bug in from a file
168	File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(TEST_FILE_LOC + bugFileName)); // used
169	// if
170	// run
171	// as a
172	// plugin
173	// test
174	// File f = new File(TEST_FILE_LOC+bugFileName); // used if run as a
175	// standalone test
176	Reader reader = new FileReader(f);
177	doi.setBug(BugParser.parseBug(reader, hit.getId(), BUGZILLA_SERVER_NAME, true, null, null, null));
178	reader.close();
179	} catch (Exception e) {
180	e.printStackTrace();
181	}
182
183	// do a second pass parse on the bug
184	List<BugzillaReportNode> l = new ArrayList<BugzillaReportNode>();
185	l.add(doi);
186	BugzillaMylarSearchOperation.secondPassBugzillaParser(l);
187
188	// make sure that we received the right number of stack traces back
189	// System.out.println("* REPORT_REPOSITORY " + hit.getId() + " *");
190	// System.out.println("NumStackTraces = " +
191	// doi.getStackTraces().size());
192	assertEquals("Wrong Number stack traces", numTracesExpected, doi.getStackTraces().size());
193	if (printStackTraces)
194	printStackTraces(doi.getStackTraces());
195	}
196	}

Added Link Here

(-)developer/scratch/bugzilla/BugzillaParserTestNoBug.java (+47 lines)
1	/*******************************************************************************
2	* Copyright (c) 2003 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.mylar.bugzilla.tests;
12
13	import java.io.File;
14	import java.io.FileReader;
15	import java.io.Reader;
16
17	import junit.framework.TestCase;
18
19	import org.eclipse.core.runtime.Path;
20	import org.eclipse.mylar.bugzilla.core.BugReport;
21	import org.eclipse.mylar.core.tests.support.FileTool;
22	import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;
23
24	/**
25	* Tests for parsing Bugzilla reports
26	*/
27	public class BugzillaParserTestNoBug extends TestCase {
28
29	public BugzillaParserTestNoBug() {
30	super();
31	}
32
33	public BugzillaParserTestNoBug(String arg0) {
34	super(arg0);
35	}
36
37	public void testBugNotFound() throws Exception {
38
39	File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
40	"testdata/pages/bug-not-found-eclipse.html"));
41
42	Reader in = new FileReader(f);
43
44	BugReport bug = BugParser.parseBug(in, 666, "<server>", false, null, null, null);
45	assertNull(bug);
46	}
47	}

Added Link Here

(-)developer/scratch/bugzilla/BugzillaNewBugParserTestVE.java (+225 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.bugzilla.tests;
13
14	import java.io.File;
15	import java.io.FileReader;
16	import java.io.Reader;
17	import java.util.Iterator;
18	import java.util.List;
19	import java.util.Map;
20
21	import junit.framework.TestCase;
22
23	import org.eclipse.core.runtime.Path;
24	import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
25	import org.eclipse.mylar.core.tests.support.FileTool;
26	import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
27	import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;
28
29	/**
30	* Tests NewBugParser -- parses product attributes
31	*/
32	public class BugzillaNewBugParserTestVE extends TestCase {
33
34	public BugzillaNewBugParserTestVE() {
35	super();
36	}
37
38	public BugzillaNewBugParserTestVE(String arg0) {
39	super(arg0);
40	}
41
42	public void testProductVE() throws Exception {
43	File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/ve-page.html"));
44
45	Reader in = new FileReader(f);
46
47	NewBugzillaReport nbm = new NewBugzillaReport();
48	new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
49	// **
50
51	// attributes for this but model
52	List<AbstractRepositoryReportAttribute> attributes = nbm.getAttributes();
53	// printList(attributes);
54
55	Iterator<AbstractRepositoryReportAttribute> itr = attributes.iterator();
56	AbstractRepositoryReportAttribute att = itr.next();
57
58	// Attribute: Severity
59	assertEquals("Attribute: Severity", "Severity", att.getName());
60
61	Map<String, String> attOptions = att.getOptionValues(); // HashMap of
62	// options for the
63	// current
64	// attribute
65	Object[] options = attOptions.keySet().toArray(); // Array of keys for
66	// the options of the
67	// current attribute
68	assertEquals("# Severity options", 7, options.length);
69
70	int i = 0;
71	while (i < options.length) {
72	assertEquals("severity options", "blocker", options[i++]);
73	assertEquals("severity options", "critical", options[i++]);
74	assertEquals("severity options", "major", options[i++]);
75	assertEquals("severity options", "normal", options[i++]);
76	assertEquals("severity options", "minor", options[i++]);
77	assertEquals("severity options", "trivial", options[i++]);
78	assertEquals("severity options", "enhancement", options[i++]);
79	}
80
81	// Attribute: product
82	att = itr.next();
83	assertEquals("Attribute: product", "product", att.getName());
84
85	attOptions = att.getOptionValues();
86	options = attOptions.keySet().toArray();
87	assertEquals("No product options", 0, options.length);
88
89	// Attribute: AssignedTo
90	att = itr.next();
91	assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());
92
93	attOptions = att.getOptionValues();
94	options = attOptions.keySet().toArray();
95	assertEquals("No AssignedTo options", 0, options.length);
96
97	// Attribute: OS
98	att = itr.next();
99	assertEquals("Attribute: OS", "OS", att.getName());
100
101	attOptions = att.getOptionValues();
102	options = attOptions.keySet().toArray();
103	assertEquals("# of options", 20, options.length);
104
105	i = 0;
106	while (i < options.length) {
107	assertEquals("OS options", "All", options[i++]);
108	assertEquals("OS options", "AIX Motif", options[i++]);
109	assertEquals("OS options", "Windows 95", options[i++]);
110	assertEquals("OS options", "Windows 98", options[i++]);
111	assertEquals("OS options", "Windows CE", options[i++]);
112	assertEquals("OS options", "Windows ME", options[i++]);
113	assertEquals("OS options", "Windows 2000", options[i++]);
114	assertEquals("OS options", "Windows NT", options[i++]);
115	assertEquals("OS options", "Windows XP", options[i++]);
116	assertEquals("OS options", "Windows All", options[i++]);
117	assertEquals("OS options", "MacOS X", options[i++]);
118	assertEquals("OS options", "Linux", options[i++]);
119	assertEquals("OS options", "Linux-GTK", options[i++]);
120	assertEquals("OS options", "Linux-Motif", options[i++]);
121	assertEquals("OS options", "HP-UX", options[i++]);
122	assertEquals("OS options", "Neutrino", options[i++]);
123	assertEquals("OS options", "QNX-Photon", options[i++]);
124	assertEquals("OS options", "Solaris", options[i++]);
125	assertEquals("OS options", "Unix All", options[i++]);
126	assertEquals("OS options", "other", options[i++]);
127	}
128
129	// Attribute: Version
130	att = itr.next();
131	assertEquals("Attribute: Version", "Version", att.getName());
132
133	// attOptions = (HashMap) att.getOptionValues();
134	options = att.getOptionValues().keySet().toArray();
135	assertEquals("# Version options", 3, options.length);
136
137	i = 0;
138	while (i < options.length) {
139	assertEquals("Version options", "0.5.0", options[i++]);
140	assertEquals("Version options", "1.0.0", options[i++]);
141	assertEquals("Version options", "unspecified", options[i++]);
142	}
143
144	// Attribute: Platform
145	att = itr.next();
146	assertEquals("Attribute: Platform", "Platform", att.getName());
147
148	options = att.getOptionValues().keySet().toArray();
149	assertEquals("# Platform options", 6, options.length);
150
151	i = 0;
152	while (i < options.length) {
153	assertEquals("Platform options", "All", options[i++]);
154	assertEquals("Platform options", "Macintosh", options[i++]);
155	assertEquals("Platform options", "PC", options[i++]);
156	assertEquals("Platform options", "Power PC", options[i++]);
157	assertEquals("Platform options", "Sun", options[i++]);
158	assertEquals("Platform options", "Other", options[i++]);
159	}
160
161	att = itr.next();
162	assertEquals("Attribute: Component", "Component", att.getName());
163
164	options = att.getOptionValues().keySet().toArray();
165	assertEquals("# Component options", 6, options.length);
166
167	i = 0;
168	while (i < options.length) {
169	assertEquals("Component options", "CDE", options[i++]);
170	assertEquals("Component options", "Doc", options[i++]);
171	assertEquals("Component options", "Java Core", options[i++]);
172	assertEquals("Component options", "Java Model (JEM)", options[i++]);
173	assertEquals("Component options", "JFC/Swing", options[i++]);
174	assertEquals("Component options", "SWT", options[i++]);
175	}
176
177	// Attribute: bug_status
178	att = itr.next();
179	assertEquals("Attribute: bug_status", "bug_status", att.getName());
180
181	options = att.getOptionValues().keySet().toArray();
182	assertEquals("No bug_status options", 0, options.length);
183
184	// Attribute: form_name
185	att = itr.next();
186	assertEquals("Attribute: form_name", "form_name", att.getName());
187
188	options = att.getOptionValues().keySet().toArray();
189	assertEquals("No form_name options", 0, options.length);
190
191	// Attribute: bug_file_loc
192	att = itr.next();
193	assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());
194
195	options = att.getOptionValues().keySet().toArray();
196	assertEquals("No bug_file_loc options", 0, options.length);
197
198	// Attribute: priority
199	att = itr.next();
200	assertEquals("Attribute: priority", "priority", att.getName());
201
202	options = att.getOptionValues().keySet().toArray();
203	assertEquals("No priority options", 0, options.length);
204
205	}
206
207	// private void printList(List<Attribute> attributes) {
208	//
209	// Iterator<Attribute> itr = attributes.iterator();
210	// System.out.println("Attributes for this Product:");
211	// System.out.println("============================");
212	//
213	// while (itr.hasNext()) {
214	// Attribute attr = itr.next();
215	// System.out.println();
216	// System.out.println(attr.getName() + ": ");
217	// System.out.println("-----------");
218	//
219	// Map<String, String> options = attr.getOptionValues();
220	// Object[] it = options.keySet().toArray();
221	// for (int i = 0; i < it.length; i++)
222	// System.out.println((String) it[i]);
223	// }
224	// }
225	}

Added Link Here

(-)developer/scratch/bugzilla/Bugzilla220ParserTest.java (+92 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.bugzilla.tests;
13
14	import java.io.File;
15	import java.io.FileReader;
16	import java.io.Reader;
17
18	import junit.framework.TestCase;
19
20	import org.eclipse.core.runtime.Path;
21	import org.eclipse.mylar.bugzilla.core.BugReport;
22	import org.eclipse.mylar.core.tests.support.FileTool;
23	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
24	import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
25	import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;
26	import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;
27
28	/**
29	* @author Mik Kersten
30	* @author Rob Elves
31	*/
32	public class Bugzilla220ParserTest extends TestCase {
33
34	public static final String TEST_SERVER = IBugzillaConstants.ECLIPSE_BUGZILLA_URL;
35
36	private static final String PRODUCT_MYLAR = "Mylar";
37
38	private static final String PRODUCT_TEST = "TestProduct";
39
40	public void testId220() throws Exception {
41
42	File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
43	"testdata/pages/test-report-220.html"));
44	Reader in = new FileReader(f);
45
46	BugReport bug = BugParser.parseBug(in, 7, TEST_SERVER, false, null, null, null);
47
48	assertEquals(7, bug.getId());
49	assertEquals("summary", bug.getSummary());
50	assertEquals("7", bug.getAttribute("Bug#").getValue());
51	assertEquals("7", bug.getAttribute("id").getValue());
52	}
53
54	public void testId2201() throws Exception {
55
56	File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(
57	"testdata/pages/test-report-2201.html"));
58	Reader in = new FileReader(f);
59
60	BugReport bug = BugParser.parseBug(in, 125527, TEST_SERVER, false, null, null, null);
61
62	assertEquals(125527, bug.getId());
63	assertEquals("bugzilla refresh incorrect for new reports and newly opened hits", bug.getSummary());
64	assertEquals("125527", bug.getAttribute("Bug#").getValue());
65	assertEquals("125527", bug.getAttribute("id").getValue());
66	}
67
68	public void testNewBugProduct220() throws Exception {
69
70	NewBugzillaReport nbm = new NewBugzillaReport();
71
72	File f = FileTool
73	.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/enter-bug220.html"));
74	Reader in = new FileReader(f);
75
76	new NewBugParser(in).parseBugAttributes(nbm, true);
77	assertEquals(PRODUCT_TEST, nbm.getAttribute("product").getValue());
78	}
79
80	public void testNewBugProduct2201() throws Exception {
81
82	NewBugzillaReport nbm = new NewBugzillaReport();
83
84	File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(),
85	new Path("testdata/pages/enter-bug2201.html"));
86	Reader in = new FileReader(f);
87
88	new NewBugParser(in).parseBugAttributes(nbm, true);
89	assertEquals(PRODUCT_MYLAR, nbm.getAttribute("product").getValue());
90	}
91
92	}

Added Link Here

(-)developer/scratch/bugzilla/BugzillaStackTraceTest.java (+196 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11	////Created on Oct 12, 2004
12	package org.eclipse.mylar.tests.misc;
13
14	import java.io.File;
15	import java.io.FileReader;
16	import java.io.Reader;
17	import java.util.ArrayList;
18	import java.util.List;
19
20	import junit.framework.TestCase;
21
22	import org.eclipse.core.runtime.Path;
23	import org.eclipse.mylar.bugzilla.tests.BugzillaTestPlugin;
24	import org.eclipse.mylar.core.tests.support.FileTool;
25	import org.eclipse.mylar.internal.bugs.search.BugzillaMylarSearchOperation;
26	import org.eclipse.mylar.internal.bugzilla.core.internal.BugParser;
27	import org.eclipse.mylar.internal.bugzilla.core.search.BugzillaSearchHit;
28	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaReportNode;
29	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.StackTrace;
30
31	/**
32	* Class to test the Bridge methods that do not require server queries
33	*
34	* @author Shawn Minto
35	*/
36	public class BugzillaStackTraceTest extends TestCase {
37
38	private static final String TEST_FILE_LOC = "testdata/reports-stacktrace/";
39
40	private static final String BUGZILLA_SERVER_NAME = "https://bugs.eclipse.org/bugs";
41
42	/**
43	* Test that the regular expression escaping mechanism works properly
44	*/
45	public void testREGEX() {
46	String r = ".*+(){}[]^$\|?/\\";
47	String r2 = StackTrace.escapeForRegex(r);
48	String ans = "\\.\\*\\+\\(\\)\\{\\}\\[\\]\\^\\$\\\|\\?\\/\\\\";
49	String msg = "Regular Expression matching wrong:\nwas: " + r2 + "\nshould be:" + ans;
50	assertTrue(msg, r2.equals(ans));
51	}
52
53	// /**
54	// * Test parsing the bug for multiple stacks in in
55	// */
56	// public void testMultipleStacksDiffComments(){
57	// // REPORT_REPOSITORY 4862 - 2 stack traces - 1 in description, 1 in
58	// comment - text
59	// before and after
60	// performParse(4862, "4862.html", 2, false);
61	// }
62
63	// /**
64	// * Test parsing the bug for a single stack in the description with some
65	// * text before it
66	// */
67	// public void testSingleStackCodeBeforeInDescription(){
68	// // REPORT_REPOSITORY 76388 - 1 stack trace - description - text before
69	// and formatted
70	// ugly
71	// performParse(76388, "76388.html", 1, false);
72	// }
73
74	/**
75	* Test parsing the bug for a single stack trace in the description with
76	* text before and after it
77	*/
78	public void testSingleStackCodeBeforeAndAfterInDescription() {
79
80	// REPORT_REPOSITORY 76146 - 1 stack trace - description - text before
81	// and code after
82	performParse(76146, "76146.html", 1, false);
83	}
84
85	/**
86	* Test parsing a bug that has 1 stack trace in the description with no
87	* extra text, but has lines in it that span 3 lines
88	*/
89	public void testSingleStackPoorFormatInDescription() {
90	// REPORT_REPOSITORY 67395 - 1 stack trace - description - no extra
91	// text, 1 at line
92	// spans 3 lines
93	performParse(67395, "67395.html", 1, false);
94	}
95
96	/**
97	* Test parsing a bug with no stack traces and no qualified exception names
98	*/
99	public void testNoStackNoQualified() {
100	// REPORT_REPOSITORY 4548 - no stack traces, no qualified reference to
101	// an exception
102	performParse(4548, "4548.html", 0, false);
103	}
104
105	/**
106	* Test parsing a bug with no stack traces, but a qualified reference to an
107	* exception
108	*/
109	public void testNoStackQual() {
110	// REPORT_REPOSITORY 1 - no stack traces, qualified reference to
111	// exception - made up
112	// bug
113	performParse(1, "1.html", 0, false);
114	}
115
116	/**
117	* Test parsing of a bug with 1 stack trace and multiple qualified
118	* references
119	*/
120	public void testSingleStackQual() {
121	// REPORT_REPOSITORY 2 - 1 stack trace- 2 qual ref, stack trace, 1 qual
122	// ref - made up
123	// bug
124	performParse(2, "2.html", 1, false);
125	}
126
127	/**
128	* Test parsing of a bug with many stacks traces in a single comment
129	*/
130	public void testMultipleStackSingleComment() {
131	// REPORT_REPOSITORY 40152 - 1 stack trace- 2 qual ref, stack trace, 1
132	// qual ref - made
133	// up bug
134	performParse(40152, "40152.html", 33, false);
135	}
136
137	/**
138	* Print out the stack traces
139	*
140	* @param l
141	* List of stack traces
142	*/
143	private void printStackTraces(List<StackTrace> l) {
144	System.out.println("\n\n");
145	for (int i = 0; i < l.size(); i++) {
146	StackTrace trace = l.get(i);
147	System.out.println("***************?????????????????***************\n");
148	System.out.println("OFFSET: " + trace.getOffset() + " LENGTH: " + trace.getLength());
149	System.out.println(trace.getStackTrace());
150	System.out.println("***************?????????????????***************\n\n");
151	}
152	}
153
154	private void performParse(int bugNumber, String bugFileName, int numTracesExpected, boolean printStackTraces) {
155
156	BugzillaSearchHit hit = new BugzillaSearchHit("<TEST-SERVER>", bugNumber, "", "", "", "", "", "", "", ""); // stack
157	// trace
158	// in
159	// desc
160	// and
161	// com
162
163	// create a new doi info
164	BugzillaReportNode doi = new BugzillaReportNode(0, hit, false);
165	try {
166
167	// read the bug in from a file
168	File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path(TEST_FILE_LOC + bugFileName)); // used
169	// if
170	// run
171	// as a
172	// plugin
173	// test
174	// File f = new File(TEST_FILE_LOC+bugFileName); // used if run as a
175	// standalone test
176	Reader reader = new FileReader(f);
177	doi.setBug(BugParser.parseBug(reader, hit.getId(), BUGZILLA_SERVER_NAME, true, null, null, null));
178	reader.close();
179	} catch (Exception e) {
180	e.printStackTrace();
181	}
182
183	// do a second pass parse on the bug
184	List<BugzillaReportNode> l = new ArrayList<BugzillaReportNode>();
185	l.add(doi);
186	BugzillaMylarSearchOperation.secondPassBugzillaParser(l);
187
188	// make sure that we received the right number of stack traces back
189	// System.out.println("* REPORT_REPOSITORY " + hit.getId() + " *");
190	// System.out.println("NumStackTraces = " +
191	// doi.getStackTraces().size());
192	assertEquals("Wrong Number stack traces", numTracesExpected, doi.getStackTraces().size());
193	if (printStackTraces)
194	printStackTraces(doi.getStackTraces());
195	}
196	}

Added Link Here

(-)developer/scratch/bugzilla/NewBugParser.java (+427 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.internal.bugzilla.core.internal;
13
14	import java.io.IOException;
15	import java.io.Reader;
16	import java.text.ParseException;
17
18	import javax.security.auth.login.LoginException;
19
20	import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
21	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
22	import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
23	import org.eclipse.mylar.internal.bugzilla.core.internal.HtmlStreamTokenizer.Token;
24
25	/**
26	* @author Shawn Minto
27	*
28	* This class parses the valid attribute values for a new bug
29	*/
30	class NewBugParser {
31	/** Tokenizer used on the stream */
32	private HtmlStreamTokenizer tokenizer;
33
34	/** Flag for whether we need to try to get the product or not */
35	private static boolean getProd = false;
36
37	public NewBugParser(Reader in) {
38	tokenizer = new HtmlStreamTokenizer(in, null);
39	}
40
41	/**
42	* Parse the new bugs valid attributes
43	*
44	* @param nbm
45	* A reference to a NewBugModel where all of the information is
46	* stored
47	* @throws IOException
48	* @throws ParseException
49	* @throws LoginException
50	*/
51	public void parseBugAttributes(NewBugzillaReport nbm, boolean retrieveProducts) throws IOException, ParseException,
52	LoginException {
53	nbm.attributes.clear(); // clear any attriubtes in bug model from a
54	// previous product
55
56	NewBugParser.getProd = retrieveProducts;
57
58	// create a new bug report and set the parser state to the start state
59	ParserState state = ParserState.START;
60	String attribute = null;
61
62	boolean isTitle = false;
63	boolean possibleBadLogin = false;
64	boolean isErrorState = false;
65	String title = "";
66	// Default error message
67	String errorMsg = "Bugzilla could not get the needed bug attribute since your login name or password is incorrect. Please check your settings in the bugzilla preferences.";
68
69	for (Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer.nextToken()) {
70	// make sure that bugzilla doesn't want us to login
71	if (token.getType() == Token.TAG && ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.TITLE
72	&& !((HtmlTag) (token.getValue())).isEndTag()) {
73	isTitle = true;
74	continue;
75	}
76
77	if (isTitle) {
78	// get all of the data in the title tag to compare with
79	if (token.getType() != Token.TAG) {
80	title += ((StringBuffer) token.getValue()).toString().toLowerCase() + " ";
81	continue;
82	} else if (token.getType() == Token.TAG
83	&& ((HtmlTag) token.getValue()).getTagType() == HtmlTag.Type.TITLE
84	&& ((HtmlTag) token.getValue()).isEndTag()) {
85	// check if the title looks like we may have a problem with
86	// login
87	if (title.indexOf("login") != -1) {
88	possibleBadLogin = true; // generic / default msg
89	// passed to constructor re:
90	// bad login
91	}
92	if ((title.indexOf("invalid") != -1 && title.indexOf("password") != -1)
93	\|\| title.indexOf("check e-mail") != -1 \|\| title.indexOf("error") != -1) {
94	possibleBadLogin = true;
95	isErrorState = true; // set flag so appropriate msg
96	// is provide for the exception
97	errorMsg = ""; // error message will be parsed from
98	// error page
99	}
100
101	isTitle = false;
102	title = "";
103	}
104	continue;
105	}
106
107	// we have found the start of an attribute name
108	if ((state == ParserState.ATT_NAME \|\| state == ParserState.START) && token.getType() == Token.TAG) {
109	HtmlTag tag = (HtmlTag) token.getValue();
110	if (tag.getTagType() == HtmlTag.Type.TD && "right".equalsIgnoreCase(tag.getAttribute("align"))) {
111	// parse the attribute's name
112	attribute = parseAttributeName();
113	if(attribute != null && attribute.contains(IBugzillaConstants.INVALID_2201_ATTRIBUTE_IGNORED)) {
114	continue;
115	}
116	if (attribute == null)
117	continue;
118	state = ParserState.ATT_VALUE;
119	continue;
120	}
121
122	if (tag.getTagType() == HtmlTag.Type.TD && "#ff0000".equalsIgnoreCase(tag.getAttribute("bgcolor"))) {
123	state = ParserState.ERROR;
124	continue;
125	}
126	}
127
128	// we have found the start of attribute values
129	if (state == ParserState.ATT_VALUE && token.getType() == Token.TAG) {
130	HtmlTag tag = (HtmlTag) token.getValue();
131	if (tag.getTagType() == HtmlTag.Type.TD) {
132	// parse the attribute values
133	parseAttributeValue(nbm, attribute);
134
135	state = ParserState.ATT_NAME;
136	attribute = null;
137	continue;
138	}
139	}
140	// page being parsed contains an Error message
141	// parse error message so it can be given to the constructor of the
142	// exception
143	// so an appropriate error message is displayed
144	if (state == ParserState.ERROR && isErrorState) {
145	// tag should be text token, not a tag
146	// get the error message
147	if (token.getType() == Token.TEXT) {
148	// get string value of next token to add to error messgage
149	// unescape the string so any escape sequences parsed appear
150	// unescaped in the details pane
151	errorMsg += HtmlStreamTokenizer.unescape(((StringBuffer) token.getValue()).toString()) + " ";
152	}
153	// expect </font> tag to indicate end of error end msg
154	// set next state to continue parsing remainder of page
155	else if (token.getType() == Token.TAG
156	&& ((HtmlTag) (token.getValue())).getTagType() == HtmlTag.Type.FONT
157	&& ((HtmlTag) (token.getValue())).isEndTag()) {
158	state = ParserState.ATT_NAME;
159	}
160	continue;
161	}
162
163	if ((state == ParserState.ATT_NAME \|\| state == ParserState.START) && token.getType() == Token.TAG) {
164	HtmlTag tag = (HtmlTag) token.getValue();
165	if (tag.getTagType() == HtmlTag.Type.INPUT && tag.getAttribute("type") != null
166	&& "hidden".equalsIgnoreCase(tag.getAttribute("type").trim())) {
167	AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(tag.getAttribute("name"));
168	a.setID(tag.getAttribute("name"));
169	a.setValue(tag.getAttribute("value"));
170	a.setHidden(true);
171	nbm.attributes.put(a.getName(), a);
172	continue;
173	}
174	}
175	}
176
177	if (possibleBadLogin && (nbm.getAttributes() == null \|\| nbm.getAttributes().size() == 0)) {
178	throw new LoginException(errorMsg);
179	}
180	}
181
182	/**
183	* Parse the case where we have found an attribute name
184	*
185	* @param tokenizer
186	* The tokenizer to use to find the name
187	* @return The name of the attribute
188	* @throws IOException
189	* @throws ParseException
190	*/
191	private String parseAttributeName() throws IOException, ParseException {
192	StringBuffer sb = new StringBuffer();
193
194	parseTableCell(sb);
195	HtmlStreamTokenizer.unescape(sb);
196	// remove the colon if there is one
197	if (sb.length() == 0)
198	return null;
199	if (sb.charAt(sb.length() - 1) == ':') {
200	sb.deleteCharAt(sb.length() - 1);
201	}
202	return sb.toString();
203	}
204
205	/**
206	* Reads text into a StringBuffer until it encounters a close table cell tag
207	* (</TD>) or start of another cell. The text is appended to the
208	* existing value of the buffer. <b>NOTE:</b> Does not handle nested cells!
209	*
210	* @param tokenizer
211	* @param sb
212	* @throws IOException
213	* @throws ParseException
214	*/
215	private void parseTableCell(StringBuffer sb) throws IOException, ParseException {
216	boolean noWhitespace = false;
217	for (HtmlStreamTokenizer.Token token = tokenizer.nextToken(); token.getType() != Token.EOF; token = tokenizer
218	.nextToken()) {
219	if (token.getType() == Token.TAG) {
220	HtmlTag tag = (HtmlTag) token.getValue();
221	if (tag.getTagType() == HtmlTag.Type.TD) {
222	if (!tag.isEndTag()) {
223	tokenizer.pushback(token);
224	}
225	break;
226	}
227	noWhitespace = token.getWhitespace().length() == 0;
228	} else if (token.getType() == Token.TEXT) {
229	// if there was no whitespace between the tag and the
230	// preceding text, don't insert whitespace before this text
231	// unless it is there in the source
232	if (!noWhitespace && token.getWhitespace().length() > 0 && sb.length() > 0) {
233	sb.append(' ');
234	}
235	sb.append((StringBuffer) token.getValue());
236	}
237	}
238	}
239
240	/**
241	* Parse the case where we have found attribute values
242	*
243	* @param nbm
244	* The NewBugModel that is to contain information about a new bug
245	* @param attributeName
246	* The name of the attribute that we are parsing
247	* @param tokenizer
248	* The tokenizer to use for parsing
249	* @throws IOException
250	* @throws ParseException
251	*/
252	private void parseAttributeValue(NewBugzillaReport nbm, String attributeName) throws IOException, ParseException {
253
254	HtmlStreamTokenizer.Token token = tokenizer.nextToken();
255	if (token.getType() == Token.TAG) {
256	HtmlTag tag = (HtmlTag) token.getValue();
257	if (tag.getTagType() == HtmlTag.Type.SELECT && !tag.isEndTag()) {
258	String parameterName = tag.getAttribute("name");
259	parseSelect(nbm, attributeName, parameterName);
260	} else if (tag.getTagType() == HtmlTag.Type.INPUT && !tag.isEndTag()) {
261	parseInput(nbm, attributeName, tag);
262	} else if (!tag.isEndTag()) {
263	parseAttributeValueCell(nbm, attributeName);
264	}
265	} else {
266	StringBuffer sb = new StringBuffer();
267	if (token.getType() == Token.TEXT) {
268	sb.append((StringBuffer) token.getValue());
269	parseAttributeValueCell(nbm, attributeName, sb);
270	}
271	}
272	}
273
274	/**
275	* Parse the case where the attribute value is just text in a table cell
276	*
277	* @param attributeName
278	* The name of the attribute we are parsing
279	* @param tokenizer
280	* The tokenizer to use for parsing
281	* @throws IOException
282	* @throws ParseException
283	*/
284	private void parseAttributeValueCell(NewBugzillaReport nbm, String attributeName) throws IOException, ParseException {
285	StringBuffer sb = new StringBuffer();
286
287	parseAttributeValueCell(nbm, attributeName, sb);
288	}
289
290	private void parseAttributeValueCell(NewBugzillaReport nbm, String attributeName, StringBuffer sb) throws IOException,
291	ParseException {
292
293	parseTableCell(sb);
294	HtmlStreamTokenizer.unescape(sb);
295
296	// if we need the product we will get it
297	if (getProd && attributeName.equalsIgnoreCase("product")) {
298	nbm.setProduct(sb.toString());
299	}
300	}
301
302	/**
303	* Parse the case where the attribute value is an input
304	*
305	* @param nbm
306	* The new bug model to add information that we get to
307	* @param attributeName
308	* The name of the attribute that we are parsing
309	* @param tag
310	* The HTML tag that we are currently on
311	* @throws IOException
312	*/
313	private static void parseInput(NewBugzillaReport nbm, String attributeName, HtmlTag tag) throws IOException {
314
315	AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(attributeName);
316	a.setID(tag.getAttribute("name"));
317	String value = tag.getAttribute("value");
318	if (value == null)
319	value = "";
320
321	// if we found the summary, add it to the bug report
322	if (attributeName.equalsIgnoreCase("summary")) {
323	nbm.setSummary(value);
324	} else if (attributeName.equalsIgnoreCase("Attachments")) {
325	// do nothing - not a problem after 2.14
326	} else if (attributeName.equalsIgnoreCase("add cc")) {
327	// do nothing
328	} else if (attributeName.toLowerCase().startsWith("cc")) {
329	// do nothing cc's are options not inputs
330	} else {
331	// otherwise just add the attribute
332	a.setValue(value);
333	nbm.attributes.put(attributeName, a);
334	}
335	}
336
337	/**
338	* Parse the case where the attribute value is an option
339	*
340	* @param nbm
341	* The NewBugModel that we are storing information in
342	* @param attributeName
343	* The name of the attribute that we are parsing
344	* @param parameterName
345	* The SELECT tag's name
346	* @param tokenizer
347	* The tokenizer that we are using for parsing
348	* @throws IOException
349	* @throws ParseException
350	*/
351	private void parseSelect(NewBugzillaReport nbm, String attributeName, String parameterName) throws IOException,
352	ParseException {
353
354	boolean first = false;
355	AbstractRepositoryReportAttribute a = new AbstractRepositoryReportAttribute(attributeName);
356	a.setID(parameterName);
357
358	HtmlStreamTokenizer.Token token = tokenizer.nextToken();
359	while (token.getType() != Token.EOF) {
360	if (token.getType() == Token.TAG) {
361	HtmlTag tag = (HtmlTag) token.getValue();
362	if (tag.getTagType() == HtmlTag.Type.SELECT && tag.isEndTag())
363	break;
364	if (tag.getTagType() == HtmlTag.Type.OPTION && !tag.isEndTag()) {
365	String optionName = tag.getAttribute("value");
366	boolean selected = tag.hasAttribute("selected");
367	StringBuffer optionText = new StringBuffer();
368	for (token = tokenizer.nextToken(); token.getType() == Token.TEXT; token = tokenizer.nextToken()) {
369	if (optionText.length() > 0) {
370	optionText.append(' ');
371	}
372	optionText.append((StringBuffer) token.getValue());
373	}
374	a.addOptionValue(optionText.toString(), optionName);
375
376	if (selected \|\| first) {
377	a.setValue(optionText.toString());
378	first = false;
379	}
380	} else {
381	token = tokenizer.nextToken();
382	}
383	} else {
384	token = tokenizer.nextToken();
385	}
386	}
387
388	if (!(nbm.attributes).containsKey(attributeName)) {
389	(nbm.attributes).put(attributeName, a);
390	}
391	}
392
393	/**
394	* Enum class for describing current state of Bugzilla report parser.
395	*/
396	private static class ParserState {
397	/** An instance of the start state */
398	protected static final ParserState START = new ParserState("start");
399
400	/** An instance of the state when the parser found an attribute name */
401	protected static final ParserState ATT_NAME = new ParserState("att_name");
402
403	/** An instance of the state when the parser found an attribute value */
404	protected static final ParserState ATT_VALUE = new ParserState("att_value");
405
406	/** An instance of the state when an error page is found */
407	protected static final ParserState ERROR = new ParserState("error");
408
409	/** State's human-readable name */
410	private String name;
411
412	/**
413	* Constructor
414	*
415	* @param description -
416	* The states human readable name
417	*/
418	private ParserState(String description) {
419	this.name = description;
420	}
421
422	@Override
423	public String toString() {
424	return name;
425	}
426	}
427	}

Lines 11-24 Link Here

(-)src/org/eclipse/mylar/tasklist/tests/BugzillaTaskTest.java (-9 / +21 lines)
11		11
12	package org.eclipse.mylar.tasklist.tests;	12	package org.eclipse.mylar.tasklist.tests;
13		13
		14	import java.util.Calendar;
14	import java.util.Date;	15	import java.util.Date;
15		16
16	import junit.framework.TestCase;	17	import junit.framework.TestCase;
17		18
18	import org.eclipse.mylar.bugzilla.core.Attribute;	19	import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReportAttribute;
19	import org.eclipse.mylar.bugzilla.core.BugReport;	20	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
		21	import org.eclipse.mylar.bugzilla.core.BugzillaReportAttribute;
20	import org.eclipse.mylar.bugzilla.core.Comment;	22	import org.eclipse.mylar.bugzilla.core.Comment;
21	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;	23	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
		24	import org.eclipse.mylar.internal.bugzilla.core.internal.BugzillaReportElement;
22	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaTask;	25	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaTask;
23		26
24	/**	27	/**
Lines 40-57 Link Here
40		43
41	public void testCompletionDate() {	44	public void testCompletionDate() {
42	BugzillaTask task = new BugzillaTask("handle", "description", true);	45	BugzillaTask task = new BugzillaTask("handle", "description", true);
43	BugReport report = new BugReport(1, IBugzillaConstants.ECLIPSE_BUGZILLA_URL);	46	BugzillaReport report = new BugzillaReport(1, IBugzillaConstants.ECLIPSE_BUGZILLA_URL);
44	task.setBugReport(report);	47	task.setBugReport(report);
45	assertNull(task.getCompletionDate());	48	assertNull(task.getCompletionDate());
46		49
47	Date now = new Date();	50	Calendar calendar = Calendar.getInstance();
48	report.addComment(new Comment(report, 1, now, "author", "author-name"));	51	calendar.set(Calendar.MILLISECOND, 0);
		52	calendar.getTimeInMillis();
		53	Date now = new Date(calendar.getTimeInMillis());
		54
		55	Comment comment = new Comment(report, 1);
		56	AbstractRepositoryReportAttribute attribute = new BugzillaReportAttribute(BugzillaReportElement.CREATION_TS);
		57	attribute.setValue(Comment.creation_ts_date_format.format(now));
		58	comment.addAttribute(BugzillaReportElement.CREATION_TS, attribute);
		59	report.addComment(comment);
49	assertNull(task.getCompletionDate());	60	assertNull(task.getCompletionDate());
50		61
51	Attribute resolvedAttribute = new Attribute(BugReport.ATTR_STATUS);	62	AbstractRepositoryReportAttribute resolvedAttribute = new BugzillaReportAttribute(BugzillaReportElement.BUG_STATUS);
52	resolvedAttribute.setValue(BugReport.VAL_STATUS_RESOLVED);	63	resolvedAttribute.setValue(BugzillaReport.VAL_STATUS_RESOLVED);
53	report.addAttribute(resolvedAttribute);	64	report.addAttribute(BugzillaReportElement.BUG_STATUS, resolvedAttribute);
54	assertEquals(now, task.getCompletionDate());	65	assertNotNull(task.getCompletionDate());
		66	assertEquals(Comment.creation_ts_date_format.format(now), Comment.creation_ts_date_format.format(task.getCompletionDate()));
55		67
56	}	68	}
57		69

Lines 18-25 Link Here

(-)src/org/eclipse/mylar/internal/bugs/BugzillaReportCache.java (-10 / +9 lines)
18		18
19	import org.eclipse.core.runtime.IPath;	19	import org.eclipse.core.runtime.IPath;
20	import org.eclipse.core.runtime.Platform;	20	import org.eclipse.core.runtime.Platform;
21	import org.eclipse.mylar.bugzilla.core.BugReport;	21	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
22	import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
23	import org.eclipse.mylar.internal.bugzilla.core.BugzillaTools;	22	import org.eclipse.mylar.internal.bugzilla.core.BugzillaTools;
24	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaCacheFile;	23	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaCacheFile;
25	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;	24	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
Lines 29-37 Link Here
29	*/	28	*/
30	public class BugzillaReportCache {	29	public class BugzillaReportCache {
31		30
32	private Map<String, BugReport> cache = new HashMap<String, BugReport>();	31	private Map<String, BugzillaReport> cache = new HashMap<String, BugzillaReport>();
33		32
34	public void cache(String handle, BugReport report) {	33	public void cache(String handle, BugzillaReport report) {
35	cache.put(handle, report);	34	cache.put(handle, report);
36	cacheFile.add(report);	35	cacheFile.add(report);
37	}	36	}
Lines 41-47 Link Here
41	cacheFile.removeAll();	40	cacheFile.removeAll();
42	}	41	}
43		42
44	public BugReport getFromCache(String bugHandle) {	43	public BugzillaReport getFromCache(String bugHandle) {
45	return cache.get(bugHandle);	44	return cache.get(bugHandle);
46	}	45	}
47		46
Lines 62-78 Link Here
62		61
63	try {	62	try {
64	cacheFile = new BugzillaCacheFile(cachPath.toFile());	63	cacheFile = new BugzillaCacheFile(cachPath.toFile());
65	ArrayList<IBugzillaBug> cached = cacheFile.elements();	64	ArrayList<BugzillaReport> cached = cacheFile.elements();
66	for (IBugzillaBug bug : cached) {	65	for (BugzillaReport bug : cached) {
67	if (bug instanceof BugReport)	66	if (bug instanceof BugzillaReport)
68	cache.put(BugzillaTools.getHandle(bug), (BugReport) bug);	67	cache.put(BugzillaTools.getHandle(bug), (BugzillaReport) bug);
69	}	68	}
70	} catch (Exception e) {	69	} catch (Exception e) {
71	MylarStatusHandler.log(e, "occurred while restoring saved offline Bugzilla reports.");	70	MylarStatusHandler.log(e, "occurred while restoring saved offline Bugzilla reports.");
72	}	71	}
73	}	72	}
74		73
75	public BugReport getCached(String handle) {	74	public BugzillaReport getCached(String handle) {
76	return cache.get(handle);	75	return cache.get(handle);
77	}	76	}
78	}	77	}

Lines 28-34 Link Here

(-)src/org/eclipse/mylar/internal/bugs/search/BugzillaMylarSearchOperation.java (-4 / +4 lines)
28	import org.eclipse.jdt.core.IMember;	28	import org.eclipse.jdt.core.IMember;
29	import org.eclipse.jdt.core.IType;	29	import org.eclipse.jdt.core.IType;
30	import org.eclipse.jface.resource.ImageDescriptor;	30	import org.eclipse.jface.resource.ImageDescriptor;
31	import org.eclipse.mylar.bugzilla.core.BugReport;	31	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
32	import org.eclipse.mylar.bugzilla.core.Comment;	32	import org.eclipse.mylar.bugzilla.core.Comment;
33	import org.eclipse.mylar.internal.bugs.MylarBugsPlugin;	33	import org.eclipse.mylar.internal.bugs.MylarBugsPlugin;
34	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;	34	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
Lines 220-226 Link Here
220		220
221	// we have a bugzilla task, so get the bug report	221	// we have a bugzilla task, so get the bug report
222	BugzillaTask bugTask = (BugzillaTask) task;	222	BugzillaTask bugTask = (BugzillaTask) task;
223	BugReport bug = bugTask.getBugReport();	223	BugzillaReport bug = bugTask.getBugReport();
224		224
225	// parse the bug report for the element that we are searching	225	// parse the bug report for the element that we are searching
226	// for	226	// for
Lines 252-258 Link Here
252	* @param bug	252	* @param bug
253	* The bug to search in	253	* The bug to search in
254	*/	254	*/
255	private boolean search(String elementName, BugReport bug) {	255	private boolean search(String elementName, BugzillaReport bug) {
256		256
257	if (bug == null)	257	if (bug == null)
258	return false; // MIK: added null check here	258	return false; // MIK: added null check here
Lines 373-379 Link Here
373		373
374	// get the bug report so that we have all of the data	374	// get the bug report so that we have all of the data
375	// - descriptions, comments, etc	375	// - descriptions, comments, etc
376	BugReport b = null;	376	BugzillaReport b = null;
377	try {	377	try {
378	b = info.getBug();	378	b = info.getBug();
379	} catch (Exception e) {	379	} catch (Exception e) {

Lines 13-25 Link Here

(-)src/org/eclipse/mylar/internal/ui/actions/ContextAttachAction.java (-8 / +1 lines)
13		13
14	import org.eclipse.jface.action.IAction;	14	import org.eclipse.jface.action.IAction;
15	import org.eclipse.jface.dialogs.Dialog;	15	import org.eclipse.jface.dialogs.Dialog;
16	import org.eclipse.jface.dialogs.MessageDialog;
17	import org.eclipse.jface.viewers.ISelection;	16	import org.eclipse.jface.viewers.ISelection;
18	import org.eclipse.jface.wizard.WizardDialog;	17	import org.eclipse.jface.wizard.WizardDialog;
19	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;	18	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
20	import org.eclipse.mylar.internal.tasklist.ui.views.TaskListView;	19	import org.eclipse.mylar.internal.tasklist.ui.views.TaskListView;
21	import org.eclipse.mylar.internal.tasklist.ui.wizards.ContextAttachWizard;	20	import org.eclipse.mylar.internal.tasklist.ui.wizards.ContextAttachWizard;
22	import org.eclipse.mylar.provisional.core.MylarPlugin;
23	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask;	21	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryTask;
24	import org.eclipse.mylar.provisional.tasklist.ITask;	22	import org.eclipse.mylar.provisional.tasklist.ITask;
25	import org.eclipse.swt.widgets.Shell;	23	import org.eclipse.swt.widgets.Shell;
Lines 44-55 Link Here
44	public void run(IAction action) {	42	public void run(IAction action) {
45	ITask task = TaskListView.getDefault().getSelectedTask();	43	ITask task = TaskListView.getDefault().getSelectedTask();
46	if (task instanceof AbstractRepositoryTask) {	44	if (task instanceof AbstractRepositoryTask) {
47	try {	45	try {
48	if (!MylarPlugin.getContextManager().hasContext(task.getHandleIdentifier())) {
49	MessageDialog.openInformation(null, "Attach Context", "No context exists for selected task.");
50	return;
51	}
52
53	ContextAttachWizard wizard = new ContextAttachWizard((AbstractRepositoryTask)task);	46	ContextAttachWizard wizard = new ContextAttachWizard((AbstractRepositoryTask)task);
54	Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();	47	Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
55	if (wizard != null && shell != null && !shell.isDisposed()) {	48	if (wizard != null && shell != null && !shell.isDisposed()) {

Removed Link Here

(-)src/org/eclipse/mylar/bugzilla/tests/BugzillaNewBugParserTestCDT.java (-213 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.bugzilla.tests;
13
14	import java.io.File;
15	import java.io.FileReader;
16	import java.io.Reader;
17	import java.util.Iterator;
18	import java.util.List;
19	import java.util.Map;
20
21	import junit.framework.TestCase;
22
23	import org.eclipse.core.runtime.Path;
24	import org.eclipse.mylar.bugzilla.core.Attribute;
25	import org.eclipse.mylar.core.tests.support.FileTool;
26	import org.eclipse.mylar.internal.bugzilla.core.NewBugModel;
27	import org.eclipse.mylar.internal.bugzilla.core.internal.NewBugParser;
28
29	/**
30	* Tests NewBugParser -- parses product attributes for new bug reports
31	*/
32	public class BugzillaNewBugParserTestCDT extends TestCase {
33
34	public BugzillaNewBugParserTestCDT() {
35	super();
36	}
37
38	public BugzillaNewBugParserTestCDT(String arg0) {
39	super(arg0);
40	}
41
42	public void testProductCDT() throws Exception {
43
44	File f = FileTool.getFileInPlugin(BugzillaTestPlugin.getDefault(), new Path("testdata/pages/cdt-page.html"));
45
46	Reader in = new FileReader(f);
47
48	NewBugModel nbm = new NewBugModel();
49	new NewBugParser(in).parseBugAttributes(nbm, true); // ** TRUE vs FALSE
50	// **
51
52	// attributes for this bug model
53	List<Attribute> attributes = nbm.getAttributes();
54	// printList(attributes);
55
56	Iterator<Attribute> itr = attributes.iterator();
57	Attribute att = itr.next();
58
59	// Attribute: Severity
60	assertEquals("Attribute: Severity", "Severity", att.getName());
61
62	Map<String, String> attOptions = att.getOptionValues(); // HashMap of
63	// options for the
64	// current
65	// attribute
66	Object[] options = attOptions.keySet().toArray(); // Array of keys for
67	// the options of the
68	// current attribute
69	assertEquals("# Severity options", 7, options.length);
70
71	int i = 0;
72	while (i < options.length) {
73	assertEquals("severity options", "blocker", options[i++]);
74	assertEquals("severity options", "critical", options[i++]);
75	assertEquals("severity options", "major", options[i++]);
76	assertEquals("severity options", "normal", options[i++]);
77	assertEquals("severity options", "minor", options[i++]);
78	assertEquals("severity options", "trivial", options[i++]);
79	assertEquals("severity options", "enhancement", options[i++]);
80	}
81
82	// Attribute: product
83	att = itr.next();
84	assertEquals("Attribute: product", "product", att.getName());
85
86	attOptions = att.getOptionValues();
87	options = attOptions.keySet().toArray();
88	assertEquals("No product options", 0, options.length);
89
90	// Attribute: AssignedTo
91	att = itr.next();
92	assertEquals("Attribute: AssignedTo", "AssignedTo", att.getName());
93
94	attOptions = att.getOptionValues();
95	options = attOptions.keySet().toArray();
96	assertEquals("No AssignedTo options", 0, options.length);
97
98	// Attribute: OS
99	att = itr.next();
100	assertEquals("Attribute: OS", "OS", att.getName());
101
102	attOptions = att.getOptionValues();
103	options = attOptions.keySet().toArray();
104	assertEquals("# of options", 20, options.length);
105
106	i = 0;
107	while (i < options.length) {
108	assertEquals("OS options", "All", options[i++]);
109	assertEquals("OS options", "AIX Motif", options[i++]);
110	assertEquals("OS options", "Windows 95", options[i++]);
111	assertEquals("OS options", "Windows 98", options[i++]);
112	assertEquals("OS options", "Windows CE", options[i++]);
113	assertEquals("OS options", "Windows ME", options[i++]);
114	assertEquals("OS options", "Windows 2000", options[i++]);
115	assertEquals("OS options", "Windows NT", options[i++]);
116	assertEquals("OS options", "Windows XP", options[i++]);
117	assertEquals("OS options", "Windows All", options[i++]);
118	assertEquals("OS options", "MacOS X", options[i++]);
119	assertEquals("OS options", "Linux", options[i++]);
120	assertEquals("OS options", "Linux-GTK", options[i++]);
121	assertEquals("OS options", "Linux-Motif", options[i++]);
122	assertEquals("OS options", "HP-UX", options[i++]);
123	assertEquals("OS options", "Neutrino", options[i++]);
124	assertEquals("OS options", "QNX-Photon", options[i++]);
125	assertEquals("OS options", "Solaris", options[i++]);
126	assertEquals("OS options", "Unix All", options[i++]);
127	assertEquals("OS options", "other", options[i++]);
128	}
129
130	// Attribute: Version
131	att = itr.next();
132	assertEquals("Attribute: Version", "Version", att.getName());
133
134	// attOptions = (HashMap) att.getOptionValues();
135	options = att.getOptionValues().keySet().toArray();
136	assertEquals("# Version options", 5, options.length);
137
138	i = 0;
139	while (i < options.length) {
140	assertEquals("Version options", "1.0", options[i++]);
141	assertEquals("Version options", "1.0.1", options[i++]);
142	assertEquals("Version options", "1.1", options[i++]);
143	assertEquals("Version options", "1.2", options[i++]);
144	assertEquals("Version options", "2.0", options[i++]);
145	}
146
147	// Attribute: Platform
148	att = itr.next();
149	assertEquals("Attribute: Platform", "Platform", att.getName());
150
151	options = att.getOptionValues().keySet().toArray();
152	assertEquals("# Platform options", 6, options.length);
153
154	i = 0;
155	while (i < options.length) {
156	assertEquals("Platform options", "All", options[i++]);
157	assertEquals("Platform options", "Macintosh", options[i++]);
158	assertEquals("Platform options", "PC", options[i++]);
159	assertEquals("Platform options", "Power PC", options[i++]);
160	assertEquals("Platform options", "Sun", options[i++]);
161	assertEquals("Platform options", "Other", options[i++]);
162	}
163
164	// Attribute: Component
165	att = itr.next();
166	assertEquals("Attribute: Component", "Component", att.getName());
167
168	options = att.getOptionValues().keySet().toArray();
169	assertEquals("# Component options", 9, options.length);
170
171	i = 0;
172	while (i < options.length) {
173	assertEquals("Component options", "CDT-parser", options[i++]);
174	assertEquals("Component options", "Core", options[i++]);
175	assertEquals("Component options", "Cpp-Extensions", options[i++]);
176	assertEquals("Component options", "Debug", options[i++]);
177	assertEquals("Component options", "Debug-MI", options[i++]);
178	assertEquals("Component options", "Doc", options[i++]);
179	assertEquals("Component options", "Generic-Extensions", options[i++]);
180	assertEquals("Component options", "Launcher", options[i++]);
181	assertEquals("Component options", "UI", options[i++]);
182	}
183
184	// Attribute: bug_status
185	att = itr.next();
186	assertEquals("Attribute: bug_status", "bug_status", att.getName());
187
188	options = att.getOptionValues().keySet().toArray();
189	assertEquals("# bug_status options [none]", 0, options.length);
190
191	// Attribute: form_name
192	att = itr.next();
193	assertEquals("Attribute: form_name", "form_name", att.getName());
194
195	options = att.getOptionValues().keySet().toArray();
196	assertEquals("No form_name options", 0, options.length);
197
198	// Attribute: bug_file_loc
199	att = itr.next();
200	assertEquals("Attribute: bug_file_loc", "bug_file_loc", att.getName());
201
202	options = att.getOptionValues().keySet().toArray();
203	assertEquals("No bug_file_loc options", 0, options.length);
204
205	// Attribute: priority
206	att = itr.next();
207	assertEquals("Attribute: priority", "priority", att.getName());
208
209	options = att.getOptionValues().keySet().toArray();
210	assertEquals("No priority options", 0, options.length);
211
212	}
213	}

Lines 21-41 Link Here

(-)src/org/eclipse/mylar/bugzilla/tests/AllBugzillaTests.java (-5 / +5 lines)
21	public static Test suite() {	21	public static Test suite() {
22	TestSuite suite = new TestSuite("Test for org.eclipse.mylar.bugzilla.tests");	22	TestSuite suite = new TestSuite("Test for org.eclipse.mylar.bugzilla.tests");
23	// $JUnit-BEGIN$	23	// $JUnit-BEGIN$
		24	suite.addTestSuite(RepositoryReportFactoryTest.class);
24	suite.addTestSuite(BugzillaConfigurationTest.class);	25	suite.addTestSuite(BugzillaConfigurationTest.class);
25	suite.addTestSuite(BugzillaTaskHyperlinkDetectorTest.class);	26	suite.addTestSuite(BugzillaTaskHyperlinkDetectorTest.class);
26	suite.addTestSuite(ReportAttachmentTest.class);
27	suite.addTestSuite(BugzillaSearchEngineTest.class);	27	suite.addTestSuite(BugzillaSearchEngineTest.class);
28	suite.addTestSuite(Bugzilla220ParserTest.class);	28	//suite.addTestSuite(Bugzilla220ParserTest.class);
29	suite.addTestSuite(BugzillaRepositoryConnectorTest.class);	29	suite.addTestSuite(BugzillaRepositoryConnectorTest.class);
30	suite.addTestSuite(EncodingTest.class);	30	suite.addTestSuite(EncodingTest.class);
31	suite.addTestSuite(NewBugWizardTest.class);	31	//suite.addTestSuite(NewBugWizardTest.class);
32	suite.addTestSuite(RegularExpressionMatchTest.class);	32	suite.addTestSuite(RegularExpressionMatchTest.class);
33	// suite.addTestSuite(BugzillaNewBugParserTestCDT.class);	33	// suite.addTestSuite(BugzillaNewBugParserTestCDT.class);
34	// suite.addTestSuite(BugzillaNewBugParserTestEquinox.class);	34	// suite.addTestSuite(BugzillaNewBugParserTestEquinox.class);
35	// suite.addTestSuite(BugzillaNewBugParserTestGMT.class);	35	// suite.addTestSuite(BugzillaNewBugParserTestGMT.class);
36	// suite.addTestSuite(BugzillaNewBugParserTestPlatform.class);	36	// suite.addTestSuite(BugzillaNewBugParserTestPlatform.class);
37	// suite.addTestSuite(BugzillaNewBugParserTestVE.class);	37	// suite.addTestSuite(BugzillaNewBugParserTestVE.class);
38	suite.addTestSuite(BugzillaParserTestNoBug.class);	38	//suite.addTestSuite(BugzillaParserTestNoBug.class);
39	suite.addTestSuite(BugzillaProductParserTest.class);	39	suite.addTestSuite(BugzillaProductParserTest.class);
40	// TODO: enable	40	// TODO: enable
41	// suite.addTest(new TestSuite(BugzillaParserTest.class));	41	// suite.addTest(new TestSuite(BugzillaParserTest.class));

Lines 22-30 Link Here

(-)src/org/eclipse/mylar/bugzilla/tests/BugzillaSearchEngineTest.java (-2 / +2 lines)
22	import org.eclipse.core.runtime.NullProgressMonitor;	22	import org.eclipse.core.runtime.NullProgressMonitor;
23	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;	23	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
24	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;	24	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
25	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryConnector;
26	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryQuery;	25	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryQuery;
27	import org.eclipse.mylar.provisional.tasklist.AbstractQueryHit;	26	import org.eclipse.mylar.provisional.tasklist.AbstractQueryHit;
		27	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
28	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;	28	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
29	import org.eclipse.mylar.provisional.tasklist.TaskRepository;	29	import org.eclipse.mylar.provisional.tasklist.TaskRepository;
30		30
Lines 99-105 Link Here
99	QUERY_NAME,	99	QUERY_NAME,
100	MAX_HITS, MylarTaskListPlugin.getTaskListManager().getTaskList());	100	MAX_HITS, MylarTaskListPlugin.getTaskListManager().getTaskList());
101		101
102	BugzillaRepositoryConnector connector = (BugzillaRepositoryConnector) MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(BugzillaPlugin.REPOSITORY_KIND);	102	AbstractRepositoryConnector connector = (AbstractRepositoryConnector) MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(BugzillaPlugin.REPOSITORY_KIND);
103	results.addAll(connector.performQuery(repositoryQuery, new NullProgressMonitor(), new MultiStatus(MylarTaskListPlugin.PLUGIN_ID, IStatus.OK, "Query result", null)));	103	results.addAll(connector.performQuery(repositoryQuery, new NullProgressMonitor(), new MultiStatus(MylarTaskListPlugin.PLUGIN_ID, IStatus.OK, "Query result", null)));
104	return results;	104	return results;
105	}	105	}

Lines 13-29 Link Here

(-)src/org/eclipse/mylar/bugzilla/tests/BugzillaRepositoryConnectorTest.java (-21 / +21 lines)
13		13
14	import java.net.MalformedURLException;	14	import java.net.MalformedURLException;
15	import java.util.Date;	15	import java.util.Date;
16	import java.util.Iterator;
17		16
18	import javax.security.auth.login.LoginException;	17	import javax.security.auth.login.LoginException;
19		18
20	import junit.framework.TestCase;	19	import junit.framework.TestCase;
21		20
22	import org.eclipse.mylar.bugzilla.core.Attribute;	21	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
23	import org.eclipse.mylar.bugzilla.core.BugReport;
24	import org.eclipse.mylar.internal.bugzilla.core.BugzillaException;	22	import org.eclipse.mylar.internal.bugzilla.core.BugzillaException;
25	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;	23	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
26	import org.eclipse.mylar.internal.bugzilla.core.BugzillaReportSubmitForm;	24	import org.eclipse.mylar.internal.bugzilla.core.BugzillaReportSubmitForm;
		25	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
27	import org.eclipse.mylar.internal.bugzilla.core.PossibleBugzillaFailureException;	26	import org.eclipse.mylar.internal.bugzilla.core.PossibleBugzillaFailureException;
28	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaQueryHit;	27	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaQueryHit;
29	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryConnector;	28	import org.eclipse.mylar.internal.bugzilla.ui.tasklist.BugzillaRepositoryConnector;
Lines 45-51 Link Here
45		44
46	private static final String DEFAULT_KIND = BugzillaPlugin.REPOSITORY_KIND;	45	private static final String DEFAULT_KIND = BugzillaPlugin.REPOSITORY_KIND;
47		46
48	private static final String TEST_REPOSITORY_URL = "https://bugs.eclipse.org/bugs";	47	//private static final String TEST_REPOSITORY_URL = "https://bugs.eclipse.org/bugs";
49		48
50	private BugzillaRepositoryConnector client;	49	private BugzillaRepositoryConnector client;
51		50
Lines 60-66 Link Here
60	super.setUp();	59	super.setUp();
61	manager = MylarTaskListPlugin.getRepositoryManager();	60	manager = MylarTaskListPlugin.getRepositoryManager();
62	manager.clearRepositories();	61	manager.clearRepositories();
63	repository = new TaskRepository(DEFAULT_KIND, TEST_REPOSITORY_URL);	62	repository = new TaskRepository(DEFAULT_KIND, IBugzillaConstants.TEST_BUGZILLA_222_URL);
64	// repository.setAuthenticationCredentials("userid", "password");	63	// repository.setAuthenticationCredentials("userid", "password");
65	manager.addRepository(repository);	64	manager.addRepository(repository);
66	assertNotNull(manager);	65	assertNotNull(manager);
Lines 113-122 Link Here
113		112
114	// Modify it	113	// Modify it
115	String newCommentText = "BugzillaRepositoryClientTest.testSynchronize(): " + (new Date()).toString();	114	String newCommentText = "BugzillaRepositoryClientTest.testSynchronize(): " + (new Date()).toString();
116	task.getBugReport().setNewNewComment(newCommentText);	115	task.getBugReport().setNewComment(newCommentText);
117	// overwrites old fields/attributes with new content (ususually done by	116	// overwrites old fields/attributes with new content (ususually done by
118	// BugEditor)	117	// BugEditor)
119	updateBug(task.getBugReport());	118	task.getBugReport().setHasChanged(true);
		119	// updateBug(task.getBugReport());
120	assertEquals(task.getSyncState(), RepositoryTaskSyncState.SYNCHRONIZED);	120	assertEquals(task.getSyncState(), RepositoryTaskSyncState.SYNCHRONIZED);
121	client.saveBugReport(task.getBugReport());	121	client.saveBugReport(task.getBugReport());
122	assertEquals(RepositoryTaskSyncState.OUTGOING, task.getSyncState());	122	assertEquals(RepositoryTaskSyncState.OUTGOING, task.getSyncState());
Lines 155-161 Link Here
155	// because task doesn't have bug report (new query hit)	155	// because task doesn't have bug report (new query hit)
156	// Result: retrieved with no incoming status	156	// Result: retrieved with no incoming status
157	task.setSyncState(RepositoryTaskSyncState.SYNCHRONIZED);	157	task.setSyncState(RepositoryTaskSyncState.SYNCHRONIZED);
158	BugReport bugReport = task.getBugReport();	158	BugzillaReport bugReport = task.getBugReport();
159	task.setBugReport(null);	159	task.setBugReport(null);
160	client.synchronize(task, false, null);	160	client.synchronize(task, false, null);
161	assertEquals(RepositoryTaskSyncState.SYNCHRONIZED, task.getSyncState());	161	assertEquals(RepositoryTaskSyncState.SYNCHRONIZED, task.getSyncState());
Lines 186-209 Link Here
186		186
187	}	187	}
188		188
189	protected void updateBug(BugReport bug) {	189	protected void updateBug(BugzillaReport bug) {
190		190
191	// go through all of the attributes and update the main values to the	191	// go through all of the attributes and update the main values to the
192	// new ones	192	// new ones
193	for (Iterator<Attribute> it = bug.getAttributes().iterator(); it.hasNext();) {	193	// for (Iterator<AbstractRepositoryReportAttribute> it = bug.getAttributes().iterator(); it.hasNext();) {
194	Attribute attribute = it.next();	194	// AbstractRepositoryReportAttribute attribute = it.next();
195	if (attribute.getNewValue() != null && attribute.getNewValue().compareTo(attribute.getValue()) != 0) {	195	// if (attribute.getValue() != null && attribute.getValue().compareTo(attribute.getValue()) != 0) {
196	bug.setHasChanged(true);	196	// bug.setHasChanged(true);
197	}	197	// }
198	attribute.setValue(attribute.getNewValue());	198	// attribute.setValue(attribute.getNewValue());
199		199	//
200	}	200	// }
201	if (bug.getNewComment().compareTo(bug.getNewNewComment()) != 0) {	201	// if (bug.getNewComment().compareTo(bug.getNewNewComment()) != 0) {
202	bug.setHasChanged(true);	202	// bug.setHasChanged(true);
203	}	203	// }
204		204
205	// Update some other fields as well.	205	// Update some other fields as well.
206	bug.setNewComment(bug.getNewNewComment());	206	//bug.setNewComment(bug.getNewNewComment());
207		207
208	}	208	}
209		209

Lines 34-43 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/ui/tasklist/BugzillaRepositoryConnector.java (-26 / +40 lines)
34	import org.eclipse.jface.window.ApplicationWindow;	34	import org.eclipse.jface.window.ApplicationWindow;
35	import org.eclipse.jface.wizard.IWizard;	35	import org.eclipse.jface.wizard.IWizard;
36	import org.eclipse.jface.wizard.WizardDialog;	36	import org.eclipse.jface.wizard.WizardDialog;
37	import org.eclipse.mylar.bugzilla.core.BugReport;	37	import org.eclipse.mylar.bugzilla.core.AbstractRepositoryReport;
		38	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
38	import org.eclipse.mylar.bugzilla.core.BugzillaRemoteContextDelegate;	39	import org.eclipse.mylar.bugzilla.core.BugzillaRemoteContextDelegate;
39	import org.eclipse.mylar.bugzilla.core.Comment;	40	import org.eclipse.mylar.bugzilla.core.ReportAttachment;
40	import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
41	import org.eclipse.mylar.internal.bugzilla.core.BugzillaException;	41	import org.eclipse.mylar.internal.bugzilla.core.BugzillaException;
42	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;	42	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
43	import org.eclipse.mylar.internal.bugzilla.core.BugzillaReportSubmitForm;	43	import org.eclipse.mylar.internal.bugzilla.core.BugzillaReportSubmitForm;
Lines 147-158 Link Here
147	return BugzillaPlugin.REPOSITORY_KIND;	147	return BugzillaPlugin.REPOSITORY_KIND;
148	}	148	}
149		149
150	public void saveBugReport(IBugzillaBug bugzillaBug) {	150	public void saveBugReport(BugzillaReport bugzillaBug) {
151	String handle = AbstractRepositoryTask.getHandle(bugzillaBug.getRepositoryUrl(), bugzillaBug.getId());	151	String handle = AbstractRepositoryTask.getHandle(bugzillaBug.getRepositoryUrl(), bugzillaBug.getId());
152	ITask task = MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);	152	ITask task = MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);
153	if (task instanceof BugzillaTask) {	153	if (task instanceof BugzillaTask) {
154	BugzillaTask bugzillaTask = (BugzillaTask) task;	154	BugzillaTask bugzillaTask = (BugzillaTask) task;
155	bugzillaTask.setBugReport((BugReport) bugzillaBug);	155	bugzillaTask.setBugReport((BugzillaReport) bugzillaBug);
156		156
157	if (bugzillaBug.hasChanges()) {	157	if (bugzillaBug.hasChanges()) {
158	bugzillaTask.setSyncState(RepositoryTaskSyncState.OUTGOING);	158	bugzillaTask.setSyncState(RepositoryTaskSyncState.OUTGOING);
Lines 164-170 Link Here
164		164
165	}	165	}
166		166
167	private BugReport downloadReport(final BugzillaTask bugzillaTask) {	167	private BugzillaReport downloadReport(final BugzillaTask bugzillaTask) {
168	try {	168	try {
169	return BugzillaRepositoryUtil.getBug(bugzillaTask.getRepositoryUrl(), AbstractRepositoryTask	169	return BugzillaRepositoryUtil.getBug(bugzillaTask.getRepositoryUrl(), AbstractRepositoryTask
170	.getTaskIdAsInt(bugzillaTask.getHandleIdentifier()));	170	.getTaskIdAsInt(bugzillaTask.getHandleIdentifier()));
Lines 325-331 Link Here
325	}	325	}
326	}	326	}
327		327
328	private static void offlineStatusChange(IBugzillaBug bug, BugzillaOfflineStatus status, boolean forceSynch) {	328	private static void offlineStatusChange(AbstractRepositoryReport report, BugzillaOfflineStatus status,
		329	boolean forceSynch) {
329		330
330	RepositoryTaskSyncState state = null;	331	RepositoryTaskSyncState state = null;
331	if (status == BugzillaOfflineStatus.SAVED_WITH_OUTGOING_CHANGES) {	332	if (status == BugzillaOfflineStatus.SAVED_WITH_OUTGOING_CHANGES) {
Lines 350-356 Link Here
350	return;	351	return;
351	}	352	}
352		353
353	String handle = AbstractRepositoryTask.getHandle(bug.getRepositoryUrl(), bug.getId());	354	String handle = AbstractRepositoryTask.getHandle(report.getRepositoryUrl(), report.getId());
354	ITask task = MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);	355	ITask task = MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);
355	if (task != null && task instanceof BugzillaTask) {	356	if (task != null && task instanceof BugzillaTask) {
356	BugzillaTask bugTask = (BugzillaTask) task;	357	BugzillaTask bugTask = (BugzillaTask) task;
Lines 359-365 Link Here
359	}	360	}
360	}	361	}
361		362
362	public void submitBugReport(final IBugzillaBug bugReport, final BugzillaReportSubmitForm form,	363	public void submitBugReport(final BugzillaReport bugReport, final BugzillaReportSubmitForm form,
363	IJobChangeListener listener) {	364	IJobChangeListener listener) {
364		365
365	if (forceSyncExecForTesting) {	366	if (forceSyncExecForTesting) {
Lines 412-418 Link Here
412	}	413	}
413	}	414	}
414		415
415	private void internalSubmitBugReport(IBugzillaBug bugReport, BugzillaReportSubmitForm form) {	416	private void internalSubmitBugReport(BugzillaReport bugReport, BugzillaReportSubmitForm form) {
416	try {	417	try {
417	form.submitReportToRepository();	418	form.submitReportToRepository();
418	removeReport(bugReport);	419	removeReport(bugReport);
Lines 420-428 Link Here
420	// TODO: avoid getting archive tasks?	421	// TODO: avoid getting archive tasks?
421	ITask task = MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);	422	ITask task = MylarTaskListPlugin.getTaskListManager().getTaskList().getTask(handle);
422		423
423	Set<AbstractRepositoryQuery> queriesWithHandle = MylarTaskListPlugin.getTaskListManager().getTaskList()	424	// TODO: re-enable synchronization of queries with task. Redundant?
424	.getQueriesForHandle(task.getHandleIdentifier());	425	// Set<AbstractRepositoryQuery> queriesWithHandle =
425	synchronize(queriesWithHandle, null, Job.INTERACTIVE, 0);	426	// MylarTaskListPlugin.getTaskListManager().getTaskList()
		427	// .getQueriesForHandle(task.getHandleIdentifier());
		428	// synchronize(queriesWithHandle, null, Job.INTERACTIVE, 0);
		429
426	// for (AbstractRepositoryQuery query : queriesWithHandle) {	430	// for (AbstractRepositoryQuery query : queriesWithHandle) {
427	// synchronize(query, null);	431	// synchronize(query, null);
428	// }	432	// }
Lines 444-450 Link Here
444	* @param saveChosen	448	* @param saveChosen
445	* This is used to determine a refresh from a user save	449	* This is used to determine a refresh from a user save
446	*/	450	*/
447	public BugzillaOfflineStatus saveOffline(final IBugzillaBug bug, final boolean forceSynch) {	451	public BugzillaOfflineStatus saveOffline(final BugzillaReport bug, final boolean forceSynch) {
448		452
449	BugzillaOfflineStatus status = BugzillaOfflineStatus.ERROR;	453	BugzillaOfflineStatus status = BugzillaOfflineStatus.ERROR;
450		454
Lines 460-468 Link Here
460	return status;	464	return status;
461	}	465	}
462		466
463	private void internalSaveOffline(final IBugzillaBug bug, final boolean forceSynch) {	467	// TODO: pull up
		468	private void internalSaveOffline(final BugzillaReport report, final boolean forceSynch) {
464	// If there is already an offline report for this bug, update the file.	469	// If there is already an offline report for this bug, update the file.
465	if (bug.isSavedOffline()) {	470	if (((AbstractRepositoryReport) report).isSavedOffline()) {
466	offlineReportsFile.update();	471	offlineReportsFile.update();
467	} else {	472	} else {
468	try {	473	try {
Lines 479-488 Link Here
479	// // identical id.");	484	// // identical id.");
480	// // return;	485	// // return;
481	// }	486	// }
482	BugzillaOfflineStatus offlineStatus = offlineReportsFile.add(bug, false);	487	BugzillaOfflineStatus offlineStatus = offlineReportsFile.add(report, false);
483	bug.setOfflineState(true);	488	((AbstractRepositoryReport) report).setOfflineState(true);
484	// saveForced forced to false (hack)	489	// saveForced forced to false (hack)
485	offlineStatusChange(bug, offlineStatus, forceSynch);	490	offlineStatusChange(report, offlineStatus, forceSynch);
486		491
487	} catch (CoreException e) {	492	} catch (CoreException e) {
488	MylarStatusHandler.fail(e, e.getMessage(), false);	493	MylarStatusHandler.fail(e, e.getMessage(), false);
Lines 491-505 Link Here
491	}	496	}
492	}	497	}
493		498
494	public static List<IBugzillaBug> getOfflineBugs() {	499	public static List<BugzillaReport> getOfflineBugs() {
495	OfflineReportsFile file = BugzillaPlugin.getDefault().getOfflineReports();	500	OfflineReportsFile file = BugzillaPlugin.getDefault().getOfflineReports();
496	return file.elements();	501	return file.elements();
497	}	502	}
498		503
499	public static void removeReport(IBugzillaBug bug) {	504	public static void removeReport(BugzillaReport bug) {
500	bug.setOfflineState(false);	505	bug.setOfflineState(false);
501	offlineStatusChange(bug, BugzillaOfflineStatus.DELETED, false);	506	offlineStatusChange(bug, BugzillaOfflineStatus.DELETED, false);
502	ArrayList<IBugzillaBug> bugList = new ArrayList<IBugzillaBug>();	507	ArrayList<BugzillaReport> bugList = new ArrayList<BugzillaReport>();
503	bugList.add(bug);	508	bugList.add(bug);
504	BugzillaPlugin.getDefault().getOfflineReports().remove(bugList);	509	BugzillaPlugin.getDefault().getOfflineReports().remove(bugList);
505	}	510	}
Lines 574-580 Link Here
574	protected void updateOfflineState(AbstractRepositoryTask repositoryTask, boolean forceSync) {	579	protected void updateOfflineState(AbstractRepositoryTask repositoryTask, boolean forceSync) {
575	if (repositoryTask instanceof BugzillaTask) {	580	if (repositoryTask instanceof BugzillaTask) {
576	BugzillaTask bugzillaTask = (BugzillaTask) repositoryTask;	581	BugzillaTask bugzillaTask = (BugzillaTask) repositoryTask;
577	BugReport downloadedReport = downloadReport(bugzillaTask);	582	BugzillaReport downloadedReport = downloadReport(bugzillaTask);
578	if (downloadedReport != null) {	583	if (downloadedReport != null) {
579	bugzillaTask.setBugReport(downloadedReport);	584	bugzillaTask.setBugReport(downloadedReport);
580	saveOffline(downloadedReport, forceSync);	585	saveOffline(downloadedReport, forceSync);
Lines 649-659 Link Here
649	if (task instanceof BugzillaTask) {	654	if (task instanceof BugzillaTask) {
650	BugzillaTask bugzillaTask = (BugzillaTask) task;	655	BugzillaTask bugzillaTask = (BugzillaTask) task;
651	if (bugzillaTask.getBugReport() != null) {	656	if (bugzillaTask.getBugReport() != null) {
652	for (Comment comment : bugzillaTask.getBugReport().getComments()) {	657	for (ReportAttachment attachment : bugzillaTask.getBugReport().getAttachments()) {
653	if (comment.hasAttachment() && comment.getAttachmentDescription().equals(MYLAR_CONTEXT_DESCRIPTION)) {	658	if (attachment.getDescription().equals(MYLAR_CONTEXT_DESCRIPTION)) {
654	contextDelegates.add(new BugzillaRemoteContextDelegate(comment));	659	contextDelegates.add(new BugzillaRemoteContextDelegate(attachment));
655	}	660	}
656	}	661	}
		662	// for (Comment comment :
		663	// bugzillaTask.getBugReport().getComments()) {
		664	// if (comment.hasAttachment() &&
		665	// comment.getAttachmentDescription().equals(MYLAR_CONTEXT_DESCRIPTION))
		666	// {
		667	// contextDelegates.add(new
		668	// BugzillaRemoteContextDelegate(comment));
		669	// }
		670	// }
657	}	671	}
658	}	672	}
659	return contextDelegates;	673	return contextDelegates;

Lines 16-22 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/ui/tasklist/BugzillaTaskEditor.java (-4 / +4 lines)
16	import org.eclipse.core.resources.IMarker;	16	import org.eclipse.core.resources.IMarker;
17	import org.eclipse.core.runtime.IProgressMonitor;	17	import org.eclipse.core.runtime.IProgressMonitor;
18	import org.eclipse.jface.dialogs.MessageDialog;	18	import org.eclipse.jface.dialogs.MessageDialog;
19	import org.eclipse.mylar.bugzilla.core.BugReport;	19	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
20	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaAttributeListener;	20	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaAttributeListener;
21	import org.eclipse.mylar.internal.bugzilla.ui.editor.AbstractBugEditor;	21	import org.eclipse.mylar.internal.bugzilla.ui.editor.AbstractBugEditor;
22	import org.eclipse.mylar.internal.bugzilla.ui.editor.BugzillaOutlineNode;	22	import org.eclipse.mylar.internal.bugzilla.ui.editor.BugzillaOutlineNode;
Lines 42-48 Link Here
42	protected BugzillaTask bugTask;	42	protected BugzillaTask bugTask;
43		43
44	/** This bug report can be modified by the user and saved offline. */	44	/** This bug report can be modified by the user and saved offline. */
45	protected BugReport offlineBug;	45	protected BugzillaReport offlineBug;
46		46
47	private ExistingBugEditor bugzillaEditor;	47	private ExistingBugEditor bugzillaEditor;
48		48
Lines 189-195 Link Here
189	/**	189	/**
190	* @return Returns the offlineBug.	190	* @return Returns the offlineBug.
191	*/	191	*/
192	public BugReport getOfflineBug() {	192	public BugzillaReport getOfflineBug() {
193	return offlineBug;	193	return offlineBug;
194	}	194	}
195		195
Lines 270-276 Link Here
270	// }	270	// }
271	// }	271	// }
272		272
273	public void makeNewPage(BugReport serverBug, String newCommentText) {	273	public void makeNewPage(BugzillaReport serverBug, String newCommentText) {
274	if (serverBug == null) {	274	if (serverBug == null) {
275	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),	275	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
276	"Could not open bug.", "Bug #" + offlineBug.getId()	276	"Could not open bug.", "Bug #" + offlineBug.getId()

Lines 25-35 Link Here

(-)src/org/eclipse/mylar/internal/bugzilla/ui/BugzillaUITools.java (-6 / +6 lines)
25	import org.eclipse.jface.text.IRegion;	25	import org.eclipse.jface.text.IRegion;
26	import org.eclipse.jface.text.Region;	26	import org.eclipse.jface.text.Region;
27	import org.eclipse.jface.text.hyperlink.IHyperlink;	27	import org.eclipse.jface.text.hyperlink.IHyperlink;
28	import org.eclipse.mylar.bugzilla.core.BugReport;	28	import org.eclipse.mylar.bugzilla.core.BugzillaReport;
29	import org.eclipse.mylar.bugzilla.core.IBugzillaBug;	29	import org.eclipse.mylar.bugzilla.core.IBugzillaBug;
30	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;	30	import org.eclipse.mylar.internal.bugzilla.core.BugzillaPlugin;
31	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;	31	import org.eclipse.mylar.internal.bugzilla.core.IBugzillaConstants;
32	import org.eclipse.mylar.internal.bugzilla.core.NewBugModel;	32	import org.eclipse.mylar.internal.bugzilla.core.NewBugzillaReport;
33	import org.eclipse.mylar.internal.bugzilla.ui.editor.ExistingBugEditor;	33	import org.eclipse.mylar.internal.bugzilla.ui.editor.ExistingBugEditor;
34	import org.eclipse.mylar.internal.bugzilla.ui.editor.ExistingBugEditorInput;	34	import org.eclipse.mylar.internal.bugzilla.ui.editor.ExistingBugEditorInput;
35	import org.eclipse.mylar.internal.bugzilla.ui.editor.NewBugEditorInput;	35	import org.eclipse.mylar.internal.bugzilla.ui.editor.NewBugEditorInput;
Lines 227-240 Link Here
227	}	227	}
228		228
229	public static void closeEditor(IWorkbenchPage page, IBugzillaBug bug) {	229	public static void closeEditor(IWorkbenchPage page, IBugzillaBug bug) {
230	if (bug instanceof NewBugModel) {	230	if (bug instanceof NewBugzillaReport) {
231	IEditorInput input = new NewBugEditorInput((NewBugModel) bug);	231	IEditorInput input = new NewBugEditorInput((NewBugzillaReport) bug);
232	IEditorPart bugEditor = page.findEditor(input);	232	IEditorPart bugEditor = page.findEditor(input);
233	if (bugEditor != null) {	233	if (bugEditor != null) {
234	page.closeEditor(bugEditor, false);	234	page.closeEditor(bugEditor, false);
235	}	235	}
236	} else if (bug instanceof BugReport) {	236	} else if (bug instanceof BugzillaReport) {
237	IEditorInput input = new ExistingBugEditorInput((BugReport) bug);	237	IEditorInput input = new ExistingBugEditorInput((BugzillaReport) bug);
238	IEditorPart bugEditor = page.findEditor(input);	238	IEditorPart bugEditor = page.findEditor(input);
239	if (bugEditor != null) {	239	if (bugEditor != null) {
240	page.closeEditor(bugEditor, false);	240	page.closeEditor(bugEditor, false);