The REAL Josh Anderson

/// <summary>
/// Wrapper method to call methods to actually process the emails.
/// </summary>
/// <param name="folderName">The name of the Outlook email folder to process.</param>
/// <param name="lastRunDateTime">Date and time when we ran last.  Used to filter out "processed" emails.</param>
/// <param name="projectName">String holding the TFS project name to save the work items to.</param>
/// <param name="tfsServerName">String holding the TFS server name to save the work items to.</param>
/// <param name="workItemType">String holding the work item type to save the email as.</param>
private void CheckEmailInFolderForProject(string folderName, DateTime lastRunDateTime, string projectName, string tfsServerName, string workItemType)
{
    try
    {
        //Get ready to work
        this.Cursor = Cursors.WaitCursor;
        MAPIFolder folder = null;

        //Set up hook-in to outlook
        Microsoft.Office.Interop.Outlook.Application objOutlook = new Microsoft.Office.Interop.Outlook.ApplicationClass();
        Microsoft.Office.Interop.Outlook.NameSpace objOutlookNamespace = objOutlook.GetNamespace("MAPI");
        objOutlookNamespace.Logon("", "", false, true);

        //Get the folder and process emails              
        if (GetFolder(objOutlookNamespace.Folders, folderName, ref folder))
            ProcessEmailsInFolder(folder, lastRunDateTime, projectName, tfsServerName, workItemType);
        else
            this.lstHistory.Items.Add("Folder (" + folderName + ") not found.");
    }
    catch (System.Exception ex)
    {
        MessageBox.Show(ex.ToString());
    }
    finally
    {
        this.Cursor = Cursors.Default; 
        this.toolStripStatusLastCheckLabel.Text = "Last Check Time: " + DateTime.Now;

    }
}

/// <summary>
/// Recursively search Outlook for a folder name.
/// </summary>
/// <param name="folders">MAPI folder array to search.</param>
/// <param name="folderName">The folder name we are searching for.</param>
/// <param name="returnFolder">Reference field used to return MAPI folder.</param>
/// <returns>Boolean representing if the specified folder was found.</returns>
private bool GetFolder(Folders folders, string folderName, ref MAPIFolder returnFolder)
{
    bool matchFound = false;

    foreach (MAPIFolder folder in folders)
    {
        //Only process if no match found yet
        if (!matchFound)
        {
            //Did we find it?
            if (folder.Name == folderName)
            {
                returnFolder = folder;
                matchFound = true;
                break;
            }
            else
            {
                //Recurisve call if folders are found
                if (folder.Folders.Count > 0)
                    matchFound = GetFolder(folder.Folders, folderName, ref returnFolder);
            }
        }
        else
            break;
    }

    return matchFound;
}

/// <summary>
/// Loop through all non-processed items in specified folder and load into TFS.
/// </summary>
/// <param name="folder">MAPI folder to search for and process.</param>
/// <param name="lastRunDateTime">Only process items recieved after this datetime.</param>
/// <param name="projectName">String holding the TFS project name to save the work items to.</param>
/// <param name="tfsServerName">String holding the TFS server name to save the work items to.</param>
/// <param name="workItemType">String holding the work item type to save the email as.</param>
private void ProcessEmailsInFolder(MAPIFolder folder, DateTime lastRunDateTime, string projectName, string tfsServerName, string workItemType)
{
    //Initialize string and get form setup
    string listOutputString = string.Empty;
    int toBeProcessedCounter = 0;
    int chunk = 0;
    int processedCounter = 0;


    lstHistory.Items.Add("=======Import Starting for '" + projectName + "' project and '" + workItemType + "' work item type at " + System.DateTime.Now.ToString() + "=======");

    //Get and sort the emails by received date
    Microsoft.Office.Interop.Outlook.Items myItems = folder.Items;
    myItems.Sort("[ReceivedTime]", true);

    //Prepare status bar
    foreach (MailItem email in myItems)
        if (email.ReceivedTime > lastRunDateTime)
            ++toBeProcessedCounter;
        else
            break;

    //Set up the progress bar logic
    if (toBeProcessedCounter > 0)
    {
        chunk = 100 / toBeProcessedCounter;
        toolStripProgressBar.Step = chunk;
    }

    foreach (MailItem email in myItems)
    {
        //Make sure it came in after our last processing time
        if (email.ReceivedTime > lastRunDateTime)
        {
            //Add work item to TFS
            if (AddItemToTFS(tfsServerName, projectName, workItemType, email))
            {
                listOutputString = email.Subject + " from " + email.SenderName + " processed at " + System.DateTime.Now;
            }
            else
            {
                listOutputString = "FAILURE: " + email.Subject + " from " + email.SenderName + " FAILED at " + System.DateTime.Now;
            }

            //Update the screen
            lstHistory.Items.Add(listOutputString);
            toolStripProgressBar.PerformStep();
            ++processedCounter;
        }
        else
            break;
    }

    //Update settings file
    Properties.Settings.Default.LastRunDateTime = System.DateTime.Now;
    Properties.Settings.Default.Save();

    //Update the screen
    toolStripStatusLastCheckLabel.Text += " - " + processedCounter + " records processed.";
    toolStripProgressBar.Value = 0;
    lstHistory.Items.Add("=================Import Complete: " + Properties.Settings.Default.LastRunDateTime.ToString() + "=================");

}

/// <summary>
/// Method used to save the passed in fields into TFS.
/// </summary>
/// <param name="TFSServer">String designating which server TFS is located on.</param>
/// <param name="TFSProject">String identifying TFS project to be used when loading items.</param>
/// <param name="workItemType">String identifying the type of work item to save.</param>
/// <param name="email">Outlook email object used to populate Work Item fields and contains attachments.</param>
/// <returns>Boolean denoting if the save was successful.</returns>
private bool AddItemToTFS(string TFSServer, string TFSProject, string workItemType, MailItem email)
{
    try
    {
        
        //Connect to the TFS server/project
        TeamFoundationServer tfs = new TeamFoundationServer(TFSServer);
        WorkItemStore wis = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
        Project teamProject = wis.Projects[TFSProject];
        
        //Get the type of bug we need to work with
        WorkItemType witBug = teamProject.WorkItemTypes[workItemType];
        
        //Make sure we got something back.
        if (witBug != null)
        {
            //Set standard field(s)
            WorkItem workItem = new WorkItem(witBug);
            workItem.Description = email.Body;
            workItem.Title = email.Subject;
           
            //Set custom field(s)
            FieldCollection fields = workItem.Fields;
            fields["My.WorkItems.Fields.Requestor"].Value = email.SenderName;

            //Add attachments, if any
            for (int i = 0; i <= email.Attachments.Count; i++)
            {
                //To prevent array index errors since attachment array is 1 based
                if (i == 0)
                    continue;
                
                string filePathAndName = string.Empty;

                //Since we are dealing with IO operations, wrap in Try/Catch in case of
                //permission issues or who knows what else...
                try
                {
                    //Save email attachment to temp directory (note funky non-zero-based indexing)
                    filePathAndName = "C:\\Temp\\" + email.Attachments[1].FileName;
                    email.Attachments[i].SaveAsFile(filePathAndName);

                    //Create and save the TFS attachment
                    Microsoft.TeamFoundation.WorkItemTracking.Client.Attachment attachment = new Microsoft.TeamFoundation.WorkItemTracking.Client.Attachment(filePathAndName, "Email Attachment");
                    workItem.Attachments.Add(attachment);
                    
                    //We have to save after each addition if we want to easily delete the file when we are done.
                    //Saving after the delete fails because the save even then tries to reference that file after deletion.
                    workItem.Save();
            
                }
                catch (SystemException ex)
                {
                    throw ex;
                }
                finally
                {
                    //Cleanup the left-overs...
                    if (System.IO.File.Exists(filePathAndName))
                        System.IO.File.Delete(filePathAndName);
                }
            }
            
            return true;
        }
        else
        {
            NullReferenceException ex = new NullReferenceException("Work item type " + workItemType + " not found.");
            throw ex;
        }

    }
    catch 
    {
        return false;
    }
}

<FIELD name="Requestor" refname="My.WorkItems.Fields.Requestor" type="String" reportable="detail">
    <HELPTEXT>Name of the user who submitted this issue.</HELPTEXT>
</FIELD>

<Control Type="FieldControl" FieldName="My.WorkItems.Fields.Requestor" Label="Requestor:" LabelPosition="Left" />
                                    

//Connect to the TFS server/project
TeamFoundationServer tfs = new TeamFoundationServer(TFSServer);
WorkItemStore wis = (WorkItemStore)tfs.GetService(typeof(WorkItemStore));
Project teamProject = wis.Projects[TFSProject];

//Get the type of bug we need to work with
WorkItemType witBug = teamProject.WorkItemTypes[workItemType];

//Make sure we got something back.
if (witBug != null)
{
    //Set standard field(s)
    WorkItem workItem = new WorkItem(witBug);
    workItem.Description = email.Body;
    workItem.Title = email.Subject;
   
    //Set custom field(s)
    FieldCollection fields = workItem.Fields;
    fields["My.WorkItems.Fields.Requestor"].Value = email.SenderName;

//Add attachments, if any
for (int i = 0; i <= email.Attachments.Count; i++)
{
    //To prevent array index errors since attachment array is 1 based
    if (i == 0)
        continue;
    
    string filePathAndName = string.Empty;

    //Since we are dealing with IO operations, wrap in Try/Catch in case of
    //permission issues or who knows what else...
    try
    {
        //Save email attachment to temp directory (note funky non-zero-based indexing)
        filePathAndName = "C:\\Temp\\" + email.Attachments[1].FileName;
        email.Attachments[i].SaveAsFile(filePathAndName);

        //Create and save the TFS attachment
        Microsoft.TeamFoundation.WorkItemTracking.Client.Attachment attachment = new Microsoft.TeamFoundation.WorkItemTracking.Client.Attachment(filePathAndName, "Email Attachment");
        workItem.Attachments.Add(attachment);
        
        //We have to save after each addition if we want to easily delete the file when we are done.
        //Saving after the delete fails because the save even then tries to reference that file after deletion.
        workItem.Save();

    }
    catch (SystemException ex)
    {
        throw ex;
    }
    finally
    {
        //Cleanup the left-overs...
        if (System.IO.File.Exists(filePathAndName))
            System.IO.File.Delete(filePathAndName);
    }
}

private void MainForm_Resize(object sender, EventArgs e)
{
    if (FormWindowState.Minimized == WindowState)
        Hide();
}

private void RestoreMinimizedWindow()
{
    Show();
    WindowState = FormWindowState.Normal;
}